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 import backend
  14 import backend.misc
  15
  16 class BaseHandler(tornado.web.RequestHandler):
  17         @property
  18         def cache(self):
  19                 return self.pakfire.cache
  20
  21         def get_current_user(self):
  22                 session_id = self.get_cookie("session_id")
  23                 if not session_id:
  24                         return
  25
  26                 # Get the session from the database.
  27                 session = self.pakfire.sessions.get(session_id)
  28
  29                 # Return nothing, if no session was found.
  30                 if not session:
  31                         return
  32
  33                 # Update the session lifetime.
  34                 session.refresh(self.request.remote_ip)
  35                 self.set_cookie("session_id", session.id, expires=session.valid_until)
  36
  37                 # If the session impersonated a user, we return that one.
  38                 if session.impersonated_user:
  39                         return session.impersonated_user
  40
  41                 # By default, we return the user of this session.
  42                 return session.user
  43
  44         @property
  45         def session(self):
  46                 if self.current_user:
  47                         return self.current_user.session
  48
  49         def get_user_locale(self):
  50                 # Get the locale from the user settings.
  51                 if self.current_user and self.current_user.locale:
  52                         locale = tornado.locale.get(self.current_user.locale)
  53                         if locale:
  54                                 return locale
  55
  56                 # If no locale was provided, we take what ever the browser requested.
  57                 return self.get_browser_locale()
  58
  59         @property
  60         def remote_address(self):
  61                 """
  62                         Returns the IP address the request came from.
  63                 """
  64                 remote_ips = self.request.remote_ip.split(", ")
  65
  66                 return remote_ips[-1]
  67
  68         @property
  69         def timezone(self):
  70                 if self.current_user:
  71                         return self.current_user.timezone
  72
  73                 return pytz.utc
  74
  75         def format_date(self, date, relative=True, shorter=False,
  76                         full_format=False):
  77                 # XXX not very precise but working for now.
  78                 gmt_offset = self.timezone.utcoffset(date).total_seconds() / -60
  79
  80                 return self.locale.format_date(date, gmt_offset=gmt_offset,
  81                         relative=relative, shorter=shorter, full_format=full_format)
  82
  83         @property
  84         def render_args(self):
  85                 session = None
  86                 if self.current_user:
  87                         session = self.current_user.session
  88
  89                 ret = {
  90                         "bugtracker"      : self.pakfire.bugzilla,
  91                         "hostname"        : self.request.host,
  92                         "format_date"     : self.format_date,
  93                         "format_size"     : backend.misc.format_size,
  94                         "friendly_time"   : backend.misc.friendly_time,
  95                         "format_email"    : backend.misc.format_email,
  96                         "format_filemode" : backend.misc.format_filemode,
  97                         "lang"            : self.locale.code[:2],
  98                         "pakfire_version" : pakfire.__version__,
  99                         "session"         : session,
 100                         "year"            : time.strftime("%Y"),
 101                 }
 102
 103                 return ret
 104
 105         def render(self, *args, **kwargs):
 106                 kwargs.update(self.render_args)
 107                 tornado.web.RequestHandler.render(self, *args, **kwargs)
 108
 109         def render_string(self, *args, **kwargs):
 110                 kwargs.update(self.render_args)
 111                 return tornado.web.RequestHandler.render_string(self, *args, **kwargs)
 112
 113         def get_error_html(self, status_code, exception=None, **kwargs):
 114                 error_document = "errors/error.html"
 115
 116                 kwargs.update({
 117                         "code"      : status_code,
 118                         "message"   : httplib.responses[status_code],
 119                 })
 120
 121                 if status_code in (400, 403, 404):
 122                         error_document = "errors/error-%s.html" % status_code
 123
 124                 # Collect more information about the exception if possible.
 125                 if exception:
 126                         exception = traceback.format_exc()
 127
 128                 return self.render_string(error_document, exception=exception, **kwargs)
 129
 130         @property
 131         def pakfire(self):
 132                 return self.application.pakfire
 133
 134         @property
 135         def arches(self):
 136                 return self.pakfire.arches
 137
 138         @property
 139         def mirrors(self):
 140                 return self.pakfire.mirrors
 141
 142         @property
 143         def public(self):
 144                 """
 145                         Indicates what level of public/non-public things a user
 146                         may see.
 147                 """
 148                 if self.current_user and self.current_user.is_admin():
 149                         public = None
 150                 else:
 151                         public = True
 152
 153                 return public