src/web/base.py

   1 #!/usr/bin/python
   2
   3 import http.client
   4 import time
   5 import tornado.locale
   6 import tornado.web
   7 import traceback
   8
   9 from .. import __version__
  10 from .. import misc
  11 from ..decorators import *
  12
  13 class BaseHandler(tornado.web.RequestHandler):
  14         @property
  15         def backend(self):
  16                 return self.application.backend
  17
  18         @property
  19         def db(self):
  20                 return self.backend.db
  21
  22         @lazy_property
  23         def session(self):
  24                 # Get the session from the cookie
  25                 session_id = self.get_cookie("session_id", None)
  26
  27                 # Search for a valid database session
  28                 if session_id:
  29                         return self.backend.sessions.get(session_id)
  30
  31         def get_current_user(self):
  32                 if self.session:
  33                         return self.session.user
  34
  35         def get_user_locale(self):
  36                 # Get the locale from the user settings
  37                 if self.current_user:
  38                         return self.current_user.locale
  39
  40                 # If no locale was provided, we take what ever the browser requested
  41                 return self.get_browser_locale()
  42
  43         @property
  44         def current_address(self):
  45                 """
  46                         Returns the IP address the request came from.
  47                 """
  48                 return self.request.headers.get("X-Real-IP") or self.request.remote_ip
  49
  50         @property
  51         def user_agent(self):
  52                 """
  53                         Returns the HTTP user agent
  54                 """
  55                 return self.request.headers.get("User-Agent", None)
  56
  57         def format_date(self, date, relative=True, shorter=False, full_format=False):
  58                 return self.locale.format_date(date, relative=relative,
  59                         shorter=shorter, full_format=full_format)
  60
  61         def get_template_namespace(self):
  62                 ns = tornado.web.RequestHandler.get_template_namespace(self)
  63
  64                 ns.update({
  65                         "backend"         : self.backend,
  66                         "hostname"        : self.request.host,
  67                         "format_date"     : self.format_date,
  68                         "format_size"     : misc.format_size,
  69                         "friendly_time"   : misc.friendly_time,
  70                         "lang"            : self.locale.code[:2],
  71                         "session"         : self.session,
  72                         "version"         : __version__,
  73                         "year"            : time.strftime("%Y"),
  74                 })
  75
  76                 return ns
  77
  78         def write_error(self, status_code, exc_info=None, **kwargs):
  79                 if status_code in (400, 403, 404):
  80                         error_document = "errors/error-%s.html" % status_code
  81                 else:
  82                         error_document = "errors/error.html"
  83
  84                 try:
  85                         status_message = http.client.responses[status_code]
  86                 except KeyError:
  87                         status_message = None
  88
  89                 # Collect more information about the exception if possible.
  90                 if exc_info:
  91                         tb = traceback.format_exception(*exc_info)
  92                 else:
  93                         tb = None
  94
  95                 self.render(error_document, status_code=status_code,
  96                         status_message=status_message, exc_info=exc_info, tb=tb, **kwargs)
  97
  98         # Typed Arguments
  99
 100         def get_argument_bool(self, name):
 101                 arg = self.get_argument(name, default=None)
 102
 103                 return arg == "on"
 104
 105         def get_argument_int(self, *args, **kwargs):
 106                 arg = self.get_argument(*args, **kwargs)
 107
 108                 # Return nothing
 109                 if not arg:
 110                         return None
 111
 112                 try:
 113                         return int(arg)
 114                 except (TypeError, ValueError):
 115                         raise tornado.web.HTTPError(400, "%s is not an integer" % arg)
 116
 117         def get_argument_distro(self, *args, **kwargs):
 118                 slug = self.get_argument(*args, **kwargs)
 119
 120                 if slug:
 121                         return self.backend.distros.get_by_slug(slug)
 122
 123         def get_argument_user(self, *args, **kwargs):
 124                 name = self.get_argument(*args, **kwargs)
 125
 126                 if name:
 127                         return self.backend.users.get_by_name(name)