src/web/handlers_base.py

   1 #!/usr/bin/python
   2
   3 import pakfire
   4
   5 import datetime
   6 import httplib
   7 import pytz
   8 import time
   9 import tornado.locale
  10 import tornado.web
  11 import traceback
  12
  13 from .. import __version__
  14 from .. import misc
  15 from ..decorators import *
  16
  17 class BaseHandler(tornado.web.RequestHandler):
  18         @property
  19         def backend(self):
  20                 return self.application.backend
  21
  22         @property
  23         def db(self):
  24                 return self.backend.db
  25
  26         @lazy_property
  27         def session(self):
  28                 # Get the session from the cookie
  29                 session_id = self.get_cookie("session_id", None)
  30
  31                 # Search for a valid database session
  32                 if session_id:
  33                         session = self.backend.sessions.get(session_id)
  34
  35                         # Found a valid session
  36                         if session:
  37                                 return session
  38
  39         def get_current_user(self):
  40                 if self.session:
  41                         return self.session.impersonated_user or self.session.user
  42
  43         def get_user_locale(self):
  44                 # Get the locale from the user settings.
  45                 if self.current_user and self.current_user.locale:
  46                         locale = tornado.locale.get(self.current_user.locale)
  47                         if locale:
  48                                 return locale
  49
  50                 # If no locale was provided, we take what ever the browser requested.
  51                 return self.get_browser_locale()
  52
  53         @property
  54         def current_address(self):
  55                 """
  56                         Returns the IP address the request came from.
  57                 """
  58                 return self.request.headers.get("X-Real-IP") or self.request.remote_ip
  59
  60         @property
  61         def user_agent(self):
  62                 """
  63                         Returns the HTTP user agent
  64                 """
  65                 return self.request.headers.get("User-Agent", None)
  66
  67         @property
  68         def timezone(self):
  69                 if self.current_user:
  70                         return self.current_user.timezone
  71
  72                 return pytz.utc
  73
  74         def format_date(self, date, relative=True, shorter=False,
  75                         full_format=False):
  76                 # XXX not very precise but working for now.
  77                 gmt_offset = self.timezone.utcoffset(date).total_seconds() / -60
  78
  79                 return self.locale.format_date(date, gmt_offset=gmt_offset,
  80                         relative=relative, shorter=shorter, full_format=full_format)
  81
  82         def get_template_namespace(self):
  83                 ns = tornado.web.RequestHandler.get_template_namespace(self)
  84
  85                 ns.update({
  86                         "bugtracker"      : self.pakfire.bugzilla,
  87                         "hostname"        : self.request.host,
  88                         "format_date"     : self.format_date,
  89                         "format_size"     : misc.format_size,
  90                         "friendly_time"   : misc.friendly_time,
  91                         "format_email"    : misc.format_email,
  92                         "format_filemode" : misc.format_filemode,
  93                         "lang"            : self.locale.code[:2],
  94                         "session"         : self.session,
  95                         "version"         : __version__,
  96                         "year"            : time.strftime("%Y"),
  97                 })
  98
  99                 return ns
 100
 101         def get_error_html(self, status_code, exception=None, **kwargs):
 102                 error_document = "errors/error.html"
 103
 104                 kwargs.update({
 105                         "code"      : status_code,
 106                         "message"   : httplib.responses[status_code],
 107                 })
 108
 109                 if status_code in (400, 403, 404):
 110                         error_document = "errors/error-%s.html" % status_code
 111
 112                 # Collect more information about the exception if possible.
 113                 if exception:
 114                         exception = traceback.format_exc()
 115
 116                 return self.render_string(error_document, exception=exception, **kwargs)
 117
 118         @property
 119         def pakfire(self):
 120                 return self.backend
 121
 122         @property
 123         def mirrors(self):
 124                 return self.pakfire.mirrors
 125
 126         @property
 127         def public(self):
 128                 """
 129                         Indicates what level of public/non-public things a user
 130                         may see.
 131                 """
 132                 if self.current_user and self.current_user.is_admin():
 133                         public = None
 134                 else:
 135                         public = True
 136
 137                 return public