webapp/handlers_admin.py

   1 #!/usr/bin/python
   2
   3 import datetime
   4 import tornado.web
   5
   6 from handlers_base import *
   7
   8 import backend
   9
  10 class AdminBaseHandler(BaseHandler):
  11         def get_current_user(self):
  12                 return self.get_secure_cookie("account")
  13
  14
  15 class AdminLoginHandler(AdminBaseHandler):
  16         def get(self):
  17                 self.render("admin-login.html")
  18
  19         def post(self):
  20                 account = self.accounts.search(self.get_argument("name"))
  21                 if not account:
  22                         raise tornado.web.HTTPError(403)
  23
  24                 if account.check_password(self.get_argument("password")):
  25                         self.set_secure_cookie("account", account.uid)
  26                 else:
  27                         raise tornado.web.HTTPError(403)
  28
  29                 self.redirect("/")
  30
  31
  32 class AdminLogoutHandler(AdminBaseHandler):
  33         def get(self):
  34                 self.clear_cookie("account")
  35                 self.redirect("/")
  36
  37
  38 class AdminIndexHandler(AdminBaseHandler):
  39         @tornado.web.authenticated
  40         def get(self):
  41                 self.render("admin-index.html")
  42
  43
  44 class AdminApiPlanetRenderMarkupHandler(AdminBaseHandler):
  45         @tornado.web.authenticated
  46         def post(self):
  47                 text = self.get_argument("text", "")
  48
  49                 # Render markup
  50                 output = {
  51                         "html" : self.planet.render(text),
  52                 }
  53                 self.finish(output)
  54
  55
  56 class AdminPlanetHandler(AdminBaseHandler):
  57         @tornado.web.authenticated
  58         def get(self):
  59                 entries = self.planet.get_entries(status=None, limit=100)
  60
  61                 self.render("admin-planet.html", entries=entries)
  62
  63
  64 class AdminPlanetComposeHandler(AdminBaseHandler):
  65         @tornado.web.authenticated
  66         def get(self, slug=None):
  67                 entry = None
  68
  69                 if slug:
  70                         entry = self.planet.get_entry_by_slug(slug)
  71                         if not entry:
  72                                 raise tornado.web.HTTPError(404)
  73
  74                 self.render("admin-planet-compose.html", entry=entry)
  75
  76         @tornado.web.authenticated
  77         def post(self):
  78                 title = self.get_argument("title")
  79                 markdown = self.get_argument("markdown")
  80
  81                 status = self.get_argument("status", "draft")
  82                 assert status in ("draft", "published")
  83
  84                 author = self.accounts.find(self.current_user)
  85
  86                 entry = self.planet.create(title=title, markdown=markdown,
  87                         author=author, status=status)
  88
  89                 self.redirect("/planet")
  90
  91
  92 class AdminPlanetEditHandler(AdminPlanetComposeHandler):
  93         @tornado.web.authenticated
  94         def post(self, slug):
  95                 entry = self.planet.get_entry_by_slug(slug)
  96                 if not entry:
  97                         raise tornado.web.HTTPError(404)
  98
  99                 entry.title = self.get_argument("title")
 100                 entry.markdown = self.get_argument("markdown")
 101
 102                 entry.status = self.get_argument("status", "draft")
 103
 104                 self.redirect("/planet")
 105
 106
 107 class AdminPlanetPublishHandler(AdminBaseHandler):
 108         @tornado.web.authenticated
 109         def get(self, slug):
 110                 entry = self.planet.get_entry_by_slug(slug)
 111                 if not entry:
 112                         raise tornado.web.HTTPError(404)
 113
 114                 entry.status = "published"
 115                 entry.published = datetime.datetime.utcnow()
 116
 117                 self.redirect("/planet")
 118
 119
 120 class AdminAccountsBaseHandler(AdminBaseHandler):
 121         pass
 122
 123
 124 class AdminAccountsHandler(AdminAccountsBaseHandler):
 125         @tornado.web.authenticated
 126         def get(self):
 127                 accounts = self.accounts.list()
 128                 self.render("admin-accounts.html", accounts=accounts)
 129
 130
 131 class AdminAccountsEditHandler(AdminAccountsBaseHandler):
 132         @tornado.web.authenticated
 133         def get(self, id):
 134                 account = self.accounts.search(id)
 135                 if not account:
 136                         raise tornado.web.HTTPError(404)
 137
 138                 self.render("admin-accounts-edit.html", account=account)
 139
 140
 141 class AdminAccountsDeleteHandler(AdminAccountsBaseHandler):
 142         @tornado.web.authenticated
 143         def get(self, id):
 144                 account = self.accounts.search(id)
 145                 if not account:
 146                         raise tornado.web.HTTPError(404)
 147
 148                 self.accounts.delete(id)
 149                 self.redirect("/accounts")
 150
 151
 152 class AdminMirrorsBaseHandler(AdminBaseHandler):
 153         pass
 154
 155
 156 class AdminMirrorsHandler(AdminMirrorsBaseHandler):
 157         @tornado.web.authenticated
 158         def get(self):
 159                 mirrors = self.mirrors.get_all()
 160
 161                 self.render("admin-mirrors.html", mirrors=mirrors)
 162
 163
 164 class AdminMirrorsUpdateHandler(AdminMirrorsBaseHandler):
 165         @tornado.web.authenticated
 166         def get(self):
 167                 self.mirrors.check_all()
 168                 self.redirect("/mirrors")
 169
 170
 171 class AdminMirrorsCreateHandler(AdminMirrorsBaseHandler):
 172         @tornado.web.authenticated
 173         def get(self, id=None):
 174                 if id:
 175                         mirror = self.db.get("SELECT * FROM mirrors WHERE id = %s", id)
 176                 else:
 177                         mirror = tornado.database.Row(
 178                                 id="",
 179                                 hostname="",
 180                                 owner="",
 181                                 location="",
 182                                 path="/",
 183                                 releases="Y",
 184                                 pakfire2="Y",
 185                                 pakfire3="Y",
 186                                 disabled="N"
 187                         )
 188
 189                 self.render("admin-mirrors-create.html", mirror=mirror)
 190
 191         @tornado.web.authenticated
 192         def post(self, id=None):
 193                 args = tornado.database.Row()
 194                 for key in ("id", "hostname", "owner", "location", "path", "releases",
 195                                 "pakfire2", "pakfire3", "disabled"):
 196                         args[key] = self.get_argument(key, "")
 197
 198                 if args.id:
 199                         if not self.mirrors.get(args.id):
 200                                 raise tornado.web.HTTPError(404)
 201
 202                         #self.db.execute("""UPDATE mirrors SET
 203                         #       hostname = %s, owner = %s, location = %s, path = %s, mirror = %s,
 204                         #       pakfire2 = %s, pakfire3 = %s, disabled = %s
 205                         #       WHERE id = %s""", args.hostname, args.owner, args.location,
 206                         #       args.path, args.mirror, args.pakfire2, args.pakfire3, args.disabled,
 207                         #       args.id)
 208                         self.db.update("mirrors", args.id, **args)
 209
 210                 else:
 211                         #self.db.execute("""INSERT INTO
 212                         #       mirrors(hostname, owner, location, path, mirror, pakfire2, pakfire3, disabled)
 213                         #       VALUES(%s, %s, %s, %s, %s, %s, %s, %s)""", args.hostname, args.owner,
 214                         #       args.location, args.path, args.mirror, args.pakfire2, args.pakfire3, args.disabled)
 215                         self.db.insert("mirrors", **args)
 216
 217                 # Update database information
 218                 self.mirrors.check_all()
 219
 220                 self.redirect("/mirrors")
 221
 222
 223 class AdminMirrorsEditHandler(AdminMirrorsCreateHandler):
 224         pass
 225
 226
 227 class AdminMirrorsDeleteHandler(AdminMirrorsBaseHandler):
 228         @tornado.web.authenticated
 229         def get(self, id):
 230                 self.db.execute("DELETE FROM mirrors WHERE id=%s", id)
 231                 self.db.execute("DELETE FROM mirror_files WHERE mirror=%s", id)
 232                 self.redirect("/mirrors")
 233
 234
 235 class AdminMirrorsDetailsHandler(AdminMirrorsBaseHandler):
 236         @tornado.web.authenticated
 237         def get(self, id):
 238                 mirror = self.mirrors.get(id)
 239                 if not mirror:
 240                         raise tornado.web.HTTPError(404)
 241
 242                 self.render("admin-mirrors-details.html", mirror=mirror)
 243
 244
 245 class AdminNewsBaseHandler(AdminBaseHandler):
 246         @property
 247         def news(self):
 248                 return self.backend.news
 249
 250
 251 class AdminNewsHandler(AdminNewsBaseHandler):
 252         @tornado.web.authenticated
 253         def get(self):
 254                 news = self.news.get_all()
 255
 256                 self.render("admin-news.html", news=news)
 257
 258
 259 class AdminNewsCreateHandler(AdminNewsBaseHandler):
 260         @tornado.web.authenticated
 261         def get(self, id=None):
 262                 # if XXX
 263
 264
 265                 self.render("admin-news-create.html", news=news)
 266
 267
 268 class AdminNewsEditHandler(AdminNewsCreateHandler):
 269         pass
 270
 271
 272 class AdminDownloadsHandler(AdminBaseHandler):
 273         @tornado.web.authenticated
 274         def get(self):
 275                 self.render("admin-downloads.html",
 276                         downloads_total = self.downloads.total,
 277                         downloads_today = self.downloads.today,
 278                         downloads_yesterday = self.downloads.yesterday,
 279                         downloads_locations_today = self.downloads.get_countries("today"),
 280                         downloads_locations_total = self.downloads.get_countries(),
 281                 )
 282
 283
 284 class AdminDownloadsMirrorsHandler(AdminBaseHandler):
 285         @tornado.web.authenticated
 286         def get(self):
 287                 self.render("admin-downloads-mirrors.html",
 288                         mirror_load_total = self.downloads.get_mirror_load(),
 289                         mirror_load_today = self.downloads.get_mirror_load("today"),
 290                 )