blog: Save timestamp when a feed has been updated last

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

#!/usr/bin/python

from __future__ import division

import datetime
import dateutil.parser
import httplib
import ipaddr
import logging
import time
import tornado.locale
import tornado.web

from .. import util

class BaseHandler(tornado.web.RequestHandler):
	@property
	def hostname(self):
		# Remove the development prefix
		return self.request.host.replace(".dev.", ".")

	def get_template_namespace(self):
		ns = tornado.web.RequestHandler.get_template_namespace(self)

		today = datetime.date.today()

		ns.update({
			"format_size" : util.format_size,
			"format_time" : util.format_time,
			"hostname" : self.hostname,
			"year" : today.year,
		})

		return ns

	def get_remote_ip(self):
		# Fix for clients behind a proxy that sends "X-Forwarded-For".
		remote_ips = self.request.remote_ip.split(", ")

		for remote_ip in remote_ips:
			try:
				addr = ipaddr.IPAddress(remote_ip)
			except ValueError:
				# Skip invalid IP addresses.
				continue

			# Check if the given IP address is from a
			# private network.
			if addr.is_private:
				continue

			return remote_ip

		# Return the last IP if nothing else worked
		return remote_ips.pop()

	def get_remote_location(self):
		if not hasattr(self, "__remote_location"):
			remote_ip = self.get_remote_ip()

			self.__remote_location = self.geoip.get_location(remote_ip)

		return self.__remote_location

	def get_argument_int(self, *args, **kwargs):
		arg = self.get_argument(*args, **kwargs)

		if arg is None or arg == "":
			return

		try:
			return int(arg)
		except ValueError:
			raise tornado.web.HTTPError(400)

	def get_argument_date(self, arg, *args, **kwargs):
		value = self.get_argument(arg, *args, **kwargs)
		if value is None:
			return

		try:
			return dateutil.parser.parse(value)
		except ValueError:
			raise tornado.web.HTTPError(400)

	# Login stuff

	def get_current_user(self):
		session_id = self.get_cookie("session_id")
		if not session_id:
			return

		# Get account from the session object
		account = self.backend.accounts.get_by_session(session_id, self.request.host)

		# If the account was not found or the session was not valid
		# any more, we will remove the cookie.
		if not account:
			self.clear_cookie("session_id")

		return account

	def login(self, username, password):
		# Find account
		account = self.backend.accounts.find_account(username)
		if not account:
			logging.warning(401, "unknown account: %s" % username)
			return False

		# Check credentials
		if not account.check_password(password):
			logging.warning("invalid password for %s" % account)
			return False

		# User has logged in, create a session
		session_id, session_expires = self.backend.accounts.create_session(account,
			self.request.host)

		# Check if a new session was created
		if not session_id:
			logging.warning("Could not create session")
			return False

		# Send session cookie to the client
		self.set_cookie("session_id", session_id,
			domain=self.request.host, expires=session_expires)

		return True

	def logout(self):
		session_id = self.get_cookie("session_id")

		if not session_id:
			return

		success = self.backend.accounts.destroy_session(session_id, self.request.host)
		if success:
			self.clear_cookie("session_id")

	@property
	def backend(self):
		return self.application.backend

	@property
	def db(self):
		return self.backend.db

	@property
	def accounts(self):
		return self.backend.accounts

	@property
	def downloads(self):
		return self.backend.downloads

	@property
	def fireinfo(self):
		return self.backend.fireinfo

	@property
	def iuse(self):
		return self.backend.iuse

	@property
	def memcached(self):
		return self.backend.memcache

	@property
	def mirrors(self):
		return self.backend.mirrors

	@property
	def netboot(self):
		return self.backend.netboot

	@property
	def releases(self):
		return self.backend.releases

	@property
	def geoip(self):
		return self.backend.geoip

	@property
	def talk(self):
		return self.backend.talk


class LoginHandler(BaseHandler):
	def get(self):
		self.render("auth/login.html")

	def post(self):
		username = self.get_argument("username")
		password = self.get_argument("password")

		if not self.login(username, password):
			raise tornado.web.HTTPError(401)

		next = self.get_argument("next", "/")
		return self.redirect(next)


class LogoutHandler(BaseHandler):
	def get(self):
		self.logout()

		# Get back to the start page
		self.redirect("/")


class NotFoundHandler(BaseHandler):
	def prepare(self):
		# Raises 404 as soon as it is called
		raise tornado.web.HTTPError(404)

	def write_error(self, status_code, **kwargs):
		assert status_code == 404

		self.render("error-404.html")