src/web/wiki.py

   1 #!/usr/bin/python3
   2
   3 import tornado.web
   4
   5 from . import auth
   6 from . import base
   7 from . import ui_modules
   8
   9 class ActionUploadHandler(auth.CacheMixin, base.BaseHandler):
  10         @tornado.web.authenticated
  11         def post(self):
  12                 path = self.get_argument("path")
  13
  14                 try:
  15                         filename, data, mimetype = self.get_file("file")
  16
  17                         # XXX check valid mimetypes
  18
  19                         with self.db.transaction():
  20                                 file = self.backend.wiki.upload(path, filename, data,
  21                                         mimetype=mimetype, author=self.current_user,
  22                                         address=self.get_remote_ip())
  23
  24                 except TypeError as e:
  25                         raise e
  26
  27                 self.redirect("%s/files" % path)
  28
  29
  30 class FilesHandler(auth.CacheMixin, base.BaseHandler):
  31         @tornado.web.authenticated
  32         def get(self, path):
  33                 files = self.backend.wiki.get_files(path)
  34
  35                 self.render("wiki/files/index.html", path=path, files=files)
  36
  37
  38 class FileHandler(base.BaseHandler):
  39         @property
  40         def action(self):
  41                 return self.get_argument("action", None)
  42
  43         def get(self, path):
  44                 file = self.backend.wiki.get_file_by_path(path)
  45                 if not file:
  46                         raise tornado.web.HTTPError(404, "Could not find %s" % path)
  47
  48                 # Render detail page
  49                 if self.action == "detail":
  50                         self.render("wiki/files/detail.html", file=file)
  51                         return
  52
  53                 size = self.get_argument_int("s", None)
  54
  55                 # Check if image should be resized
  56                 if file.is_image() and size:
  57                         blob = file.get_thumbnail(size)
  58                 else:
  59                         blob = file.blob
  60
  61                 # Set headers
  62                 self.set_header("Content-Type", file.mimetype or "application/octet-stream")
  63                 self.set_header("Content-Length", len(blob))
  64
  65                 # Set expires
  66                 self.set_expires(3600)
  67
  68                 # Deliver content
  69                 self.finish(blob)
  70
  71
  72 class PageHandler(auth.CacheMixin, base.BaseHandler):
  73         @property
  74         def action(self):
  75                 return self.get_argument("action", None)
  76
  77         def write_error(self, status_code, **kwargs):
  78                 # Render a custom page for 404
  79                 if status_code == 404:
  80                         self.render("wiki/404.html", **kwargs)
  81                         return
  82
  83                 # Otherwise raise this to one layer above
  84                 super().write_error(status_code, **kwargs)
  85
  86         @tornado.web.removeslash
  87         def get(self, page):
  88                 # Check if we are asked to render a certain revision
  89                 revision = self.get_argument("revision", None)
  90
  91                 # Fetch the wiki page
  92                 page = self.backend.wiki.get_page(page, revision=revision)
  93
  94                 # Edit
  95                 if self.action == "edit":
  96                         if not self.current_user:
  97                                 raise tornado.web.HTTPError(401)
  98
  99                         # Empty page if it was deleted
 100                         if page and page.was_deleted():
 101                                 page = None
 102
 103                         # Render page
 104                         self.render("wiki/edit.html", page=page)
 105                         return
 106
 107                 # Revisions
 108                 elif self.action == "revisions":
 109                         self.render("wiki/revisions.html", page=page)
 110                         return
 111
 112                 # If the page does not exist, we send 404
 113                 if not page or page.was_deleted():
 114                         raise tornado.web.HTTPError(404)
 115
 116                 # Fetch the latest revision
 117                 latest_revision = page.get_latest_revision()
 118
 119                 # Render page
 120                 self.render("wiki/page.html", page=page, latest_revision=latest_revision)
 121
 122         @tornado.web.authenticated
 123         def post(self, page):
 124                 content = self.get_argument("content", None)
 125                 changes = self.get_argument("changes")
 126
 127                 # Create a new page in the database
 128                 with self.db.transaction():
 129                         page = self.backend.wiki.create_page(page,
 130                                 self.current_user, content, changes=changes, address=self.get_remote_ip())
 131
 132                 # Redirect back
 133                 if page.was_deleted():
 134                         self.redirect("/")
 135                 else:
 136                         self.redirect(page.url)
 137
 138                 # Update the search index
 139                 with self.db.transaction():
 140                         self.backend.wiki.refresh()
 141
 142
 143 class SearchHandler(auth.CacheMixin, base.BaseHandler):
 144         @base.blacklisted
 145         def get(self):
 146                 q = self.get_argument("q")
 147
 148                 pages = self.backend.wiki.search(q, limit=50)
 149
 150                 self.render("wiki/search-results.html", q=q, pages=pages)
 151
 152
 153 class RecentChangesHandler(auth.CacheMixin, base.BaseHandler):
 154         def get(self):
 155                 recent_changes = self.backend.wiki.get_recent_changes(limit=50)
 156
 157                 self.render("wiki/recent-changes.html", recent_changes=recent_changes)
 158
 159
 160 class WikiListModule(ui_modules.UIModule):
 161         def render(self, pages, link_revision=False, show_breadcrumbs=True, show_changes=False):
 162                 return self.render_string("wiki/modules/list.html", link_revision=link_revision,
 163                         pages=pages, show_breadcrumbs=show_breadcrumbs, show_changes=show_changes)
 164
 165
 166 class WikiNavbarModule(ui_modules.UIModule):
 167         def render(self, suffix=None):
 168                 _ = self.locale.translate
 169
 170                 breadcrumbs = self.backend.wiki.make_breadcrumbs(self.request.path)
 171
 172                 # Don't search for a title for the file manager
 173                 if self.request.path.endswith("/files"):
 174                         title = _("Files")
 175                 else:
 176                         title = self.backend.wiki.get_page_title(self.request.path)
 177
 178                 return self.render_string("wiki/modules/navbar.html",
 179                         breadcrumbs=breadcrumbs, page_title=title, suffix=suffix)