webapp/handlers_base.py

   1 #!/usr/bin/python
   2
   3 from __future__ import division
   4
   5 import httplib
   6 import datetime
   7 import time
   8 import tornado.locale
   9 import tornado.web
  10
  11 import backend
  12
  13 def format_size(b):
  14         units = ["B", "k", "M", "G"]
  15         unit_pointer = 0
  16
  17         while b >= 1024 and unit_pointer < len(units):
  18                 b /= 1024
  19                 unit_pointer += 1
  20
  21         return "%.1f%s" % (b, units[unit_pointer])
  22
  23
  24 class BaseHandler(tornado.web.RequestHandler):
  25         rss_url = None
  26
  27         def get_account(self, uid):
  28                 # Find the name of the author
  29                 return self.accounts.find(uid)
  30
  31         def get_query_locale(self):
  32                 locale = self.get_argument("locale", None)
  33
  34                 if locale is None:
  35                         return
  36
  37                 return tornado.locale.get(locale)
  38
  39         def prepare(self):
  40                 locale = self.get_query_locale()
  41                 if locale:
  42                         self.set_cookie("locale", locale.code)
  43
  44         def get_user_locale(self):
  45                 # The planet is always in english.
  46                 if self.request.host == "planet.ipfire.org":
  47                         return tornado.locale.get("en_US")
  48
  49                 # Get the locale from the query.
  50                 locale = self.get_query_locale()
  51                 if locale:
  52                         return locale
  53
  54                 # Read the locale from the cookies.
  55                 locale = self.get_cookie("locale", None)
  56                 if locale:
  57                         return tornado.locale.get(locale)
  58
  59                 # Otherwise take the browser locale.
  60                 return self.get_browser_locale()
  61
  62         @property
  63         def render_args(self):
  64                 today = datetime.date.today()
  65
  66                 return {
  67                         "format_size" : format_size,
  68                         "hostname" : self.request.host,
  69                         "lang" : self.locale.code[:2],
  70                         "rss_url" : self.rss_url,
  71                         "year" : today.year,
  72                 }
  73
  74         def render(self, *args, **_kwargs):
  75                 kwargs = self.render_args
  76                 kwargs.update(_kwargs)
  77                 tornado.web.RequestHandler.render(self, *args, **kwargs)
  78
  79         def render_string(self, *args, **_kwargs):
  80                 kwargs = self.render_args
  81                 kwargs.update(_kwargs)
  82                 return tornado.web.RequestHandler.render_string(self, *args, **kwargs)
  83
  84         def write_error(self, status_code, **kwargs):
  85                 if status_code in (404, 500):
  86                         render_args = ({
  87                                 "code"      : status_code,
  88                                 "exception" : kwargs.get("exception", None),
  89                                 "message"   : httplib.responses[status_code],
  90                         })
  91                         self.render("error-%s.html" % status_code, **render_args)
  92                 else:
  93                         return tornado.web.RequestHandler.write_error(self, status_code, **kwargs)
  94
  95         def static_url(self, path, static=True):
  96                 ret = tornado.web.RequestHandler.static_url(self, path)
  97
  98                 if self.settings.get("debug", False):
  99                         return ret
 100
 101                 elif self.request.host == "admin.ipfire.org":
 102                         return ret
 103
 104                 elif static:
 105                         return "http://static.ipfire.org%s" % ret
 106
 107                 return ret
 108
 109         @property
 110         def backend(self):
 111                 return self.application.backend
 112
 113         @property
 114         def advertisements(self):
 115                 return backend.Advertisements()
 116
 117         @property
 118         def accounts(self):
 119                 return self.backend.accounts
 120
 121         @property
 122         def banners(self):
 123                 return backend.Banners()
 124
 125         @property
 126         def memcached(self):
 127                 return backend.Memcached()
 128
 129         @property
 130         def mirrors(self):
 131                 return backend.Mirrors()
 132
 133         @property
 134         def news(self):
 135                 return backend.News()
 136
 137         @property
 138         def config(self):
 139                 return backend.Config()
 140
 141         @property
 142         def releases(self):
 143                 return backend.Releases()
 144
 145         @property
 146         def banners(self):
 147                 return backend.Banners()
 148
 149         @property
 150         def geoip(self):
 151                 return backend.GeoIP()
 152
 153         @property
 154         def tracker(self):
 155                 return backend.Tracker()
 156
 157         @property
 158         def planet(self):
 159                 return self.backend.planet
 160
 161         @property
 162         def wishlist(self):
 163                 return backend.Wishlist()