www/webapp/ui_modules.py

   1 #!/usr/bin/python
   2
   3 from __future__ import division
   4
   5 import hashlib
   6 import logging
   7 import operator
   8 import socket
   9 import textile
  10 import tornado.escape
  11 import tornado.locale
  12 import tornado.web
  13
  14 from tornado.database import Row
  15
  16 import backend
  17 import backend.stasy
  18
  19 class UIModule(tornado.web.UIModule):
  20         @property
  21         def accounts(self):
  22                 return self.handler.accounts
  23
  24         @property
  25         def banners(self):
  26                 return self.handler.banners
  27
  28         @property
  29         def memcached(self):
  30                 return self.handler.memcached
  31
  32         @property
  33         def releases(self):
  34                 return self.handler.releases
  35
  36
  37 class MenuModule(UIModule):
  38         def render(self):
  39                 hostname = self.request.host.lower().split(':')[0]
  40
  41                 menuitems = []
  42                 for m in backend.Menu().get(hostname):
  43                         m.active = False
  44
  45                         if m.uri and self.request.uri.endswith(m.uri):
  46                                 m.active = True
  47
  48                         # Translate the description of the link
  49                         m.description = \
  50                                 self.locale.translate(m.description)
  51                         m.description = tornado.escape.xhtml_escape(m.description)
  52
  53                         menuitems.append(m)
  54
  55                 return self.render_string("modules/menu.html", menuitems=menuitems)
  56
  57
  58 class NewsItemModule(UIModule):
  59         def get_author(self, author):
  60                 # Get name of author
  61                 author = self.accounts.find(author)
  62                 if author:
  63                         return author.cn
  64                 else:
  65                         _ = self.locale.translate
  66                         return _("Unknown author")
  67
  68         def render(self, item, uncut=False):
  69                 # Get author
  70                 item.author = self.get_author(item.author_id)
  71
  72                 if not uncut and len(item.text) >= 400:
  73                         item.text = item.text[:400] + "..."
  74
  75                 # Render text
  76                 text_id = "news-%s" % hashlib.md5(item.text.encode("utf-8")).hexdigest()
  77
  78                 text = self.memcached.get(text_id)
  79                 if not text:
  80                         text = textile.textile(item.text)
  81                         self.memcached.set(text_id, text, 60)
  82
  83                 item.text = text
  84
  85                 return self.render_string("modules/news-item.html", item=item, uncut=uncut)
  86
  87
  88 class NewsLineModule(NewsItemModule):
  89         def render(self, item):
  90                 return self.render_string("modules/news-line.html", item=item)
  91
  92
  93 class MirrorItemModule(UIModule):
  94         def render(self, item):
  95                 return self.render_string("modules/mirror-item.html", item=item)
  96
  97
  98 class SidebarItemModule(UIModule):
  99         def render(self):
 100                 return self.render_string("modules/sidebar-item.html")
 101
 102
 103 class SidebarReleaseModule(UIModule):
 104         def render(self):
 105                 return self.render_string("modules/sidebar-release.html",
 106                         latest=self.releases.get_latest())
 107
 108
 109 class ReleaseItemModule(UIModule):
 110         def render(self, item):
 111                 return self.render_string("modules/release-item.html", release=item)
 112
 113
 114 class SidebarBannerModule(UIModule):
 115         def render(self, item=None):
 116                 if not item:
 117                         item = self.banners.get_random()
 118
 119                 return self.render_string("modules/sidebar-banner.html", item=item)
 120
 121
 122 class PlanetEntryModule(UIModule):
 123         def render(self, entry, short=False):
 124                 return self.render_string("modules/planet-entry.html",
 125                         entry=entry, short=short)
 126
 127
 128 class TrackerPeerListModule(UIModule):
 129         def render(self, peers, percentages=False):
 130                 # Guess country code and hostname of the host
 131                 for peer in peers:
 132                         country_code = backend.GeoIP().get_country(peer["ip"])
 133                         peer["country_code"] = country_code or "unknown"
 134
 135                         try:
 136                                 peer["hostname"] = socket.gethostbyaddr(peer["ip"])[0]
 137                         except:
 138                                 peer["hostname"] = ""
 139
 140                 return self.render_string("modules/tracker-peerlist.html",
 141                         peers=[Row(p) for p in peers], percentages=percentages)
 142
 143
 144 class StasyTableModule(UIModule):
 145         def render(self, items, sortby="key", reverse=False, percentage=False, flags=False, locale=False):
 146                 hundred_percent = 0
 147                 for v in items.values():
 148                         hundred_percent += v
 149
 150                 keys = []
 151                 if sortby == "key":
 152                         keys = sorted(items.keys(), reverse=reverse)
 153                 elif sortby == "percentage":
 154                         keys = [k for k,v in sorted(items.items(), key=operator.itemgetter(1))]
 155                         if not reverse:
 156                                 keys = reversed(keys)
 157                 else:
 158                         raise Exception, "Unknown sortby parameter was provided"
 159
 160                 if hundred_percent:
 161                         _items = []
 162                         for k in keys:
 163                                 if not percentage:
 164                                         v = items[k] * 100 / hundred_percent
 165                                 else:
 166                                         v = items[k] * 100
 167                                 _items.append((k, v))
 168                         items = _items
 169
 170                 if items and type(items[0][0]) == type(()) :
 171                         _ = self.locale.translate
 172                         _items = []
 173                         for k, v in items:
 174                                 k = _("%s to %s") % k
 175                                 _items.append((k, v))
 176                         items = _items
 177
 178                 if locale:
 179                         flags = False
 180                         locales = tornado.locale.LOCALE_NAMES
 181                         _items = []
 182                         for k, v in items:
 183                                 for code, locale in locales.items():
 184                                         if code.startswith(k):
 185                                                 k = locale["name"].split()[0]
 186                                 _items.append((k, v))
 187                         items = _items
 188
 189                 return self.render_string("modules/stasy-table.html", items=items, flags=flags)
 190
 191
 192 class StasyDeviceTableModule(UIModule):
 193         def render(self, devices):
 194                 groups = {}
 195
 196                 for device in devices:
 197                         if not groups.has_key(device.cls):
 198                                 groups[device.cls] = []
 199
 200                         groups[device.cls].append(device)
 201
 202                 return self.render_string("modules/stasy-table-devices.html",
 203                         groups=groups.items())