webapp/handlers_base.py

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