[ipfire.org.git] / src / web / wiki.py

#!/usr/bin/python3

import difflib
import tornado.web

from . import auth
from . import base
from . import ui_modules

class ActionEditHandler(auth.CacheMixin, base.BaseHandler):
	@tornado.web.authenticated
	def post(self):
		path = self.get_argument("path")

		# Check permissions
		if not self.backend.wiki.check_acl(path, self.current_user):
			raise tornado.web.HTTPError(403, "Access to %s not allowed for %s" % (path, self.current_user))

		content = self.get_argument("content", None)
		changes = self.get_argument("changes")

		# Create a new page in the database
		with self.db.transaction():
			page = self.backend.wiki.create_page(path,
				self.current_user, content, changes=changes, address=self.get_remote_ip())

			# Add user as a watcher if wanted
			watch = self.get_argument("watch", False)
			if watch:
				page.add_watcher(self.current_user)

		# Redirect back
		if page.was_deleted():
			self.redirect("/")
		else:
			self.redirect(page.url)

	def on_finish(self):
		"""
			Updates the search index after the page has been edited
		"""
		# This is being executed in the background and after
		# the response has been set to the client
		with self.db.transaction():
			self.backend.wiki.refresh()


class ActionUploadHandler(auth.CacheMixin, base.BaseHandler):
	@tornado.web.authenticated
	def post(self):
		path = self.get_argument("path")

		# Check permissions
		if not self.backend.wiki.check_acl(path, self.current_user):
			raise tornado.web.HTTPError(403, "Access to %s not allowed for %s" % (path, self.current_user))

		try:
			filename, data, mimetype = self.get_file("file")

			# XXX check valid mimetypes

			with self.db.transaction():
				file = self.backend.wiki.upload(path, filename, data,
					mimetype=mimetype, author=self.current_user,
					address=self.get_remote_ip())

		except TypeError as e:
			raise e

		self.redirect("%s/files" % path)


class ActionWatchHandler(auth.CacheMixin, base.BaseHandler):
	@tornado.web.authenticated
	def get(self, action, path):
		page = self.backend.wiki.get_page(path)
		if not page:
			raise tornado.web.HTTPError(404, "Page does not exist: %s" % path)

		with self.db.transaction():
			if action == "watch":
				page.add_watcher(self.current_user)
			elif action == "unwatch":
				page.remove_watcher(self.current_user)

		# Redirect back to page
		self.redirect(page.url)


class FilesHandler(auth.CacheMixin, base.BaseHandler):
	@tornado.web.authenticated
	def get(self, path):
		# Check permissions
		if not self.backend.wiki.check_acl(path, self.current_user):
			raise tornado.web.HTTPError(403, "Access to %s not allowed for %s" % (path, self.current_user))

		files = self.backend.wiki.get_files(path)

		self.render("wiki/files/index.html", path=path, files=files)


class FileHandler(base.BaseHandler):
	@property
	def action(self):
		return self.get_argument("action", None)

	def get(self, path):
		# Check permissions
		if not self.backend.wiki.check_acl(path, self.current_user):
			raise tornado.web.HTTPError(403, "Access to %s not allowed for %s" % (path, self.current_user))

		# Fetch the file
		file = self.backend.wiki.get_file_by_path(path)
		if not file:
			raise tornado.web.HTTPError(404, "Could not find %s" % path)

		# Render detail page
		if self.action == "detail":
			for breadcrumb, title in self.backend.wiki.make_breadcrumbs(path):
				page = self.backend.wiki.get_page(breadcrumb)
				if page:
					break

			self.render("wiki/files/detail.html", page=page, file=file)
			return

		size = self.get_argument_int("s", None)

		# Check if image should be resized
		if file.is_image() and size:
			blob = file.get_thumbnail(size)
		else:
			blob = file.blob

		# Set headers
		self.set_header("Content-Type", file.mimetype or "application/octet-stream")
		self.set_header("Content-Length", len(blob))

		# Set expires
		self.set_expires(3600)

		# Deliver content
		self.finish(blob)


class PageHandler(auth.CacheMixin, base.BaseHandler):
	@property
	def action(self):
		return self.get_argument("action", None)

	def write_error(self, status_code, **kwargs):
		# Render a custom page for 404
		if status_code == 404:
			self.render("wiki/404.html", **kwargs)
			return

		# Otherwise raise this to one layer above
		super().write_error(status_code, **kwargs)

	@tornado.web.removeslash
	def get(self, page):
		# Check permissions
		if not self.backend.wiki.check_acl(page, self.current_user):
			raise tornado.web.HTTPError(403, "Access to %s not allowed for %s" % (page, self.current_user))

		# Check if we are asked to render a certain revision
		revision = self.get_argument("revision", None)

		# Fetch the wiki page
		page = self.backend.wiki.get_page(page, revision=revision)

		# Diff
		if self.action == "diff":
			# Get both revisions
			a = self.get_argument("a")
			b = self.get_argument("b")

			# Fetch both versions of the page
			a = self.backend.wiki.get_page(page.page, revision=a)
			b = self.backend.wiki.get_page(page.page, revision=b)
			if not a or not b:
				raise tornado.web.HTTPError(404)

			# Cannot render a diff for the identical page
			if a == b:
				raise tornado.web.HTTPError(400)

			# Make sure that b is newer than a
			if a > b:
				a, b = b, a

			self.render("wiki/diff.html", page=page, a=a, b=b)
			return

		# Edit
		elif self.action == "edit":
			if not self.current_user:
				raise tornado.web.HTTPError(401)

			# Empty page if it was deleted
			if page and page.was_deleted():
				page = None

			# Render page
			self.render("wiki/edit.html", page=page)
			return

		# Revisions
		elif self.action == "revisions":
			self.render("wiki/revisions.html", page=page)
			return

		# If the page does not exist, we send 404
		if not page or page.was_deleted():
			raise tornado.web.HTTPError(404)

		# Fetch the latest revision
		latest_revision = page.get_latest_revision()

		# Render page
		self.render("wiki/page.html", page=page, latest_revision=latest_revision)


class SearchHandler(auth.CacheMixin, base.BaseHandler):
	@base.blacklisted
	def get(self):
		q = self.get_argument("q")

		pages = self.backend.wiki.search(q, account=self.current_user, limit=50)

		self.render("wiki/search-results.html", q=q, pages=list(pages))


class RecentChangesHandler(auth.CacheMixin, base.BaseHandler):
	def get(self):
		recent_changes = self.backend.wiki.get_recent_changes(self.current_user, limit=50)

		self.render("wiki/recent-changes.html", recent_changes=recent_changes)


class WikiDiffModule(ui_modules.UIModule):
	differ = difflib.Differ()

	def render(self, a, b):
		diff = self.differ.compare(
			a.markdown.splitlines(),
			b.markdown.splitlines(),
		)

		return self.render_string("wiki/modules/diff.html", diff=diff)


class WikiListModule(ui_modules.UIModule):
	def render(self, pages, link_revision=False, show_breadcrumbs=True, show_changes=False):
		return self.render_string("wiki/modules/list.html", link_revision=link_revision,
			pages=pages, show_breadcrumbs=show_breadcrumbs, show_changes=show_changes)


class WikiNavbarModule(ui_modules.UIModule):
	def render(self, suffix=None):
		_ = self.locale.translate

		breadcrumbs = self.backend.wiki.make_breadcrumbs(self.request.path)

		# Don't search for a title for the file manager
		if self.request.path.endswith("/files"):
			title = _("Files")
		else:
			title = self.backend.wiki.get_page_title(self.request.path)

		return self.render_string("wiki/modules/navbar.html",
			breadcrumbs=breadcrumbs, page_title=title, suffix=suffix)
Commit	Line	Data
181d08f3 MT	1	#!/usr/bin/python3
181d08f3 MT	2
c21ffadb	3	import difflib
181d08f3 MT	4	import tornado.web
	5
	6	from . import auth
	7	from . import base
6ac7e934	8	from . import ui_modules
181d08f3	9
b6e8b28f MT	10	class ActionEditHandler(auth.CacheMixin, base.BaseHandler):
	11	@tornado.web.authenticated
	12	def post(self):
	13	path = self.get_argument("path")
	14
	15	# Check permissions
	16	if not self.backend.wiki.check_acl(path, self.current_user):
	17	raise tornado.web.HTTPError(403, "Access to %s not allowed for %s" % (path, self.current_user))
	18
	19	content = self.get_argument("content", None)
	20	changes = self.get_argument("changes")
	21
	22	# Create a new page in the database
	23	with self.db.transaction():
	24	page = self.backend.wiki.create_page(path,
	25	self.current_user, content, changes=changes, address=self.get_remote_ip())
	26
d64a1e35 MT	27	# Add user as a watcher if wanted
	28	watch = self.get_argument("watch", False)
	29	if watch:
	30	page.add_watcher(self.current_user)
	31
b6e8b28f MT	32	# Redirect back
	33	if page.was_deleted():
	34	self.redirect("/")
	35	else:
	36	self.redirect(page.url)
	37
	38	def on_finish(self):
	39	"""
	40	Updates the search index after the page has been edited
	41	"""
	42	# This is being executed in the background and after
	43	# the response has been set to the client
	44	with self.db.transaction():
	45	self.backend.wiki.refresh()
	46
	47
f2cfd873 MT	48	class ActionUploadHandler(auth.CacheMixin, base.BaseHandler):
	49	@tornado.web.authenticated
	50	def post(self):
	51	path = self.get_argument("path")
	52
11afe905 MT	53	# Check permissions
	54	if not self.backend.wiki.check_acl(path, self.current_user):
	55	raise tornado.web.HTTPError(403, "Access to %s not allowed for %s" % (path, self.current_user))
	56
f2cfd873 MT	57	try:
	58	filename, data, mimetype = self.get_file("file")
	59
	60	# XXX check valid mimetypes
	61
	62	with self.db.transaction():
	63	file = self.backend.wiki.upload(path, filename, data,
	64	mimetype=mimetype, author=self.current_user,
	65	address=self.get_remote_ip())
	66
	67	except TypeError as e:
	68	raise e
	69
	70	self.redirect("%s/files" % path)
	71
	72
d64a1e35 MT	73	class ActionWatchHandler(auth.CacheMixin, base.BaseHandler):
	74	@tornado.web.authenticated
	75	def get(self, action, path):
	76	page = self.backend.wiki.get_page(path)
	77	if not page:
	78	raise tornado.web.HTTPError(404, "Page does not exist: %s" % path)
	79
	80	with self.db.transaction():
	81	if action == "watch":
	82	page.add_watcher(self.current_user)
	83	elif action == "unwatch":
	84	page.remove_watcher(self.current_user)
	85
	86	# Redirect back to page
	87	self.redirect(page.url)
	88
	89
f2cfd873 MT	90	class FilesHandler(auth.CacheMixin, base.BaseHandler):
	91	@tornado.web.authenticated
	92	def get(self, path):
11afe905 MT	93	# Check permissions
	94	if not self.backend.wiki.check_acl(path, self.current_user):
	95	raise tornado.web.HTTPError(403, "Access to %s not allowed for %s" % (path, self.current_user))
	96
f2cfd873 MT	97	files = self.backend.wiki.get_files(path)
	98
	99	self.render("wiki/files/index.html", path=path, files=files)
	100
	101
568b265b	102	class FileHandler(base.BaseHandler):
8cb0bea4 MT	103	@property
	104	def action(self):
	105	return self.get_argument("action", None)
	106
f2cfd873	107	def get(self, path):
11afe905 MT	108	# Check permissions
	109	if not self.backend.wiki.check_acl(path, self.current_user):
	110	raise tornado.web.HTTPError(403, "Access to %s not allowed for %s" % (path, self.current_user))
	111
	112	# Fetch the file
f2cfd873 MT	113	file = self.backend.wiki.get_file_by_path(path)
	114	if not file:
	115	raise tornado.web.HTTPError(404, "Could not find %s" % path)
	116
8cb0bea4 MT	117	# Render detail page
8cb0bea4 MT	118	if self.action == "detail":
531846f7 MT	119	for breadcrumb, title in self.backend.wiki.make_breadcrumbs(path):
	120	page = self.backend.wiki.get_page(breadcrumb)
	121	if page:
	122	break
	123
	124	self.render("wiki/files/detail.html", page=page, file=file)
8cb0bea4 MT	125	return
8cb0bea4 MT	126
79dd9a0f MT	127	size = self.get_argument_int("s", None)
	128
	129	# Check if image should be resized
	130	if file.is_image() and size:
	131	blob = file.get_thumbnail(size)
	132	else:
	133	blob = file.blob
	134
f2cfd873 MT	135	# Set headers
f2cfd873 MT	136	self.set_header("Content-Type", file.mimetype or "application/octet-stream")
79dd9a0f	137	self.set_header("Content-Length", len(blob))
f2cfd873	138
568b265b MT	139	# Set expires
	140	self.set_expires(3600)
	141
79dd9a0f MT	142	# Deliver content
79dd9a0f MT	143	self.finish(blob)
f2cfd873 MT	144
f2cfd873 MT	145
181d08f3	146	class PageHandler(auth.CacheMixin, base.BaseHandler):
d398ca08 MT	147	@property
	148	def action(self):
	149	return self.get_argument("action", None)
	150
a446dcb9 MT	151	def write_error(self, status_code, **kwargs):
	152	# Render a custom page for 404
	153	if status_code == 404:
	154	self.render("wiki/404.html", **kwargs)
	155	return
	156
	157	# Otherwise raise this to one layer above
	158	super().write_error(status_code, **kwargs)
	159
181d08f3 MT	160	@tornado.web.removeslash
181d08f3 MT	161	def get(self, page):
11afe905 MT	162	# Check permissions
	163	if not self.backend.wiki.check_acl(page, self.current_user):
	164	raise tornado.web.HTTPError(403, "Access to %s not allowed for %s" % (page, self.current_user))
	165
7d699684 MT	166	# Check if we are asked to render a certain revision
	167	revision = self.get_argument("revision", None)
	168
	169	# Fetch the wiki page
	170	page = self.backend.wiki.get_page(page, revision=revision)
181d08f3	171
c21ffadb MT	172	# Diff
	173	if self.action == "diff":
	174	# Get both revisions
	175	a = self.get_argument("a")
	176	b = self.get_argument("b")
	177
	178	# Fetch both versions of the page
	179	a = self.backend.wiki.get_page(page.page, revision=a)
	180	b = self.backend.wiki.get_page(page.page, revision=b)
	181	if not a or not b:
	182	raise tornado.web.HTTPError(404)
	183
	184	# Cannot render a diff for the identical page
	185	if a == b:
	186	raise tornado.web.HTTPError(400)
	187
	188	# Make sure that b is newer than a
	189	if a > b:
	190	a, b = b, a
	191
	192	self.render("wiki/diff.html", page=page, a=a, b=b)
	193	return
	194
d398ca08	195	# Edit
c21ffadb	196	elif self.action == "edit":
d398ca08 MT	197	if not self.current_user:
	198	raise tornado.web.HTTPError(401)
	199
	200	# Empty page if it was deleted
addc4eb7	201	if page and page.was_deleted():
d398ca08 MT	202	page = None
d398ca08 MT	203
7d699684 MT	204	# Render page
	205	self.render("wiki/edit.html", page=page)
	206	return
	207
	208	# Revisions
	209	elif self.action == "revisions":
	210	self.render("wiki/revisions.html", page=page)
	211	return
d398ca08	212
181d08f3 MT	213	# If the page does not exist, we send 404
	214	if not page or page.was_deleted():
	215	raise tornado.web.HTTPError(404)
	216
	217	# Fetch the latest revision
	218	latest_revision = page.get_latest_revision()
	219
	220	# Render page
	221	self.render("wiki/page.html", page=page, latest_revision=latest_revision)
	222
181d08f3 MT	223
	224	class SearchHandler(auth.CacheMixin, base.BaseHandler):
	225	@base.blacklisted
	226	def get(self):
	227	q = self.get_argument("q")
	228
11afe905	229	pages = self.backend.wiki.search(q, account=self.current_user, limit=50)
181d08f3	230
11afe905	231	self.render("wiki/search-results.html", q=q, pages=list(pages))
6ac7e934 MT	232
6ac7e934 MT	233
f9db574a MT	234	class RecentChangesHandler(auth.CacheMixin, base.BaseHandler):
f9db574a MT	235	def get(self):
11afe905	236	recent_changes = self.backend.wiki.get_recent_changes(self.current_user, limit=50)
f9db574a MT	237
	238	self.render("wiki/recent-changes.html", recent_changes=recent_changes)
	239
	240
c21ffadb MT	241	class WikiDiffModule(ui_modules.UIModule):
	242	differ = difflib.Differ()
	243
	244	def render(self, a, b):
	245	diff = self.differ.compare(
	246	a.markdown.splitlines(),
	247	b.markdown.splitlines(),
	248	)
	249
	250	return self.render_string("wiki/modules/diff.html", diff=diff)
	251
	252
f9db574a	253	class WikiListModule(ui_modules.UIModule):
7d699684 MT	254	def render(self, pages, link_revision=False, show_breadcrumbs=True, show_changes=False):
7d699684 MT	255	return self.render_string("wiki/modules/list.html", link_revision=link_revision,
66a814d9	256	pages=pages, show_breadcrumbs=show_breadcrumbs, show_changes=show_changes)
f9db574a MT	257
f9db574a MT	258
6ac7e934	259	class WikiNavbarModule(ui_modules.UIModule):
67573803	260	def render(self, suffix=None):
f2cfd873 MT	261	_ = self.locale.translate
f2cfd873 MT	262
67573803 MT	263	breadcrumbs = self.backend.wiki.make_breadcrumbs(self.request.path)
67573803 MT	264
f2cfd873 MT	265	# Don't search for a title for the file manager
	266	if self.request.path.endswith("/files"):
	267	title = _("Files")
	268	else:
	269	title = self.backend.wiki.get_page_title(self.request.path)
6ac7e934 MT	270
6ac7e934 MT	271	return self.render_string("wiki/modules/navbar.html",
67573803	272	breadcrumbs=breadcrumbs, page_title=title, suffix=suffix)