Drop Bootstrap Notes

[ipfire.org.git] / src / web / handlers.py

#!/usr/bin/python

#import httplib
import iso3166
#import logging
#import markdown2
import operator
import os
#import random
#import re
#import socket
#import time
#import tornado.database
#import tornado.locale
import tornado.gen
import tornado.web
#import unicodedata

from handlers_accounts import *
from handlers_admin import *
from handlers_base import *
from handlers_boot import *
from handlers_download import *
from handlers_fireinfo import *
from handlers_iuse import *
from handlers_mirrors import *
from handlers_news import *
from handlers_nopaste import *
from handlers_planet import *
from handlers_rss import *
from handlers_talk import *

class LangCompatHandler(BaseHandler):
	"""
		Redirect links in the old format to current site:

		E.g. /en/index -> /index
	"""
	def get(self, lang, page):
		self.redirect("/%s" % page)


class IndexHandler(BaseHandler):
	rss_url = "/news.rss"

	"""
		This handler displays the welcome page.
	"""
	def get(self):
		# Get the latest release.
		latest_release = self.releases.get_latest()

		# Get a list of the most recent news items and put them on the page.		
		latest_news = self.get_latest_news()

		return self.render("index.html", latest_news=latest_news,
			latest_release=latest_release,
			fireinfo_country=self.fireinfo.get_random_country_penetration())

	def get_latest_news(self, count=5):
		latest_news = []

		for news in self.news.get_latest(limit=count):
			latest_news.append(("news", news))

		for post in self.planet.get_entries(limit=count):
			latest_news.append(("planet", post))

		latest_news.sort(key=operator.itemgetter(1), reverse=True)

		return latest_news[:count]


class GeoIPHandler(BaseHandler):
	def get_address(self):
		addr = self.get_argument("addr", None)

		if not addr:
			addr = self.get_remote_ip()

		return addr

	def get(self):
		addr = self.get_address()

		peer = self.geoip.get_all(addr)
		if peer:
			peer["country_name"] = self.geoip.get_country_name(peer.country)

		mirrors = self.mirrors.get_for_location(peer)

		self.render("geoip/index.html", addr=addr, peer=peer, mirrors=mirrors)


class DonateHandler(BaseHandler):
	def get(self):
		location = self.get_remote_location()

		if location:
			country = location.country
		else:
			country = None

		self.render("donate.html", countries=iso3166.countries, country=country)

	@tornado.gen.coroutine
	def post(self):
		# Get form inputs
		args = {
			"amount"       : self.get_argument("amount"),
			"currency"     : self.get_argument("currency", "EUR"),
			"method"       : self.get_argument("method", None),

			# Is this a recurring donation?
			"recurring"    : self.get_argument("frequency") == "monthly",

			# XXX Missing inputs
			"email"        : "john.doe@example.com",
			"first_name"   : "John",
			"last_name"    : "Doe",
			"street1"      : "Street 1",
			"street2"      : "Street 2",
			"post_code"    : "POST CODE",
			"city"         : "City",
			"state"        : "State",
			"country_code" : "DE",
		}

		# Send request to Zeiterfassung
		try:
			response = yield self.backend.zeiterfassung.send_request(
				"/api/v1/donations/create/ipfire-project", **args)

		except Exception:
			raise # XXX handle any problems when Zeiterfassung is unreachable

		# Redirect the user to the payment page
		redirect_url = response.get("redirect_url")
		if not redirect_url:
			raise tornado.web.HTTPError(500, "Did not receive a redirect URL")

		self.redirect(redirect_url)


class DownloadHandler(BaseHandler):
	def get(self):
		release = self.releases.get_latest()

		self.render("download.html", release=release)


class StaticHandler(BaseHandler):
	def initialize(self, template):
		self._template = template

	def get(self):
		self.render("static/%s" % self._template)