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

#!/usr/bin/python3

import difflib
import logging
import os.path
import re
import tornado.gen
import urllib.parse

from . import misc
from . import util
from .decorators import *

class Wiki(misc.Object):
	def _get_pages(self, query, *args):
		res = self.db.query(query, *args)

		for row in res:
			yield Page(self.backend, row.id, data=row)

	def _get_page(self, query, *args):
		res = self.db.get(query, *args)

		if res:
			return Page(self.backend, res.id, data=res)

	def make_path(self, page, path):
		# Nothing to do for absolute links
		if path.startswith("/"):
			pass

		# Relative links (one-level down)
		elif path.startswith("./"):
			path = os.path.join(page, path)

		# All other relative links
		else:
			p = os.path.dirname(page)
			path = os.path.join(p, path)

		# Normalise links
		return os.path.normpath(path)

	def page_exists(self, path):
		page = self.get_page(path)

		# Page must have been found and not deleted
		return page and not page.was_deleted()

	def get_page_title(self, page, default=None):
		# Try to retrieve title from cache
		title = self.memcache.get("wiki:title:%s" % page)
		if title:
			return title

		# If the title has not been in the cache, we will
		# have to look it up
		doc = self.get_page(page)
		if doc:
			title = doc.title
		else:
			title = os.path.basename(page)

		# Save in cache for forever
		self.memcache.set("wiki:title:%s" % page, title)

		return title

	def get_page(self, page, revision=None):
		page = Page.sanitise_page_name(page)
		assert page

		if revision:
			return self._get_page("SELECT * FROM wiki WHERE page = %s \
				AND timestamp = %s", page, revision)
		else:
			return self._get_page("SELECT * FROM wiki WHERE page = %s \
				ORDER BY timestamp DESC LIMIT 1", page)

	def get_recent_changes(self, account, limit=None):
		pages = self._get_pages("SELECT * FROM wiki \
			ORDER BY timestamp DESC")

		for page in pages:
			if not page.check_acl(account):
				continue

			yield page

			limit -= 1
			if not limit:
				break

	def create_page(self, page, author, content, changes=None, address=None):
		page = Page.sanitise_page_name(page)

		# Write page to the database
		page = self._get_page("INSERT INTO wiki(page, author_uid, markdown, changes, address) \
			VALUES(%s, %s, %s, %s, %s) RETURNING *", page, author.uid, content or None, changes, address)

		# Update cache
		self.memcache.set("wiki:title:%s" % page.page, page.title)

		# Send email to all watchers
		page._send_watcher_emails(excludes=[author])

		return page

	def delete_page(self, page, author, **kwargs):
		# Do nothing if the page does not exist
		if not self.get_page(page):
			return

		# Just creates a blank last version of the page
		self.create_page(page, author=author, content=None, **kwargs)

	def make_breadcrumbs(self, url):
		# Split and strip all empty elements (double slashes)
		parts = list(e for e in url.split("/") if e)

		ret = []
		for part in ("/".join(parts[:i]) for i in range(1, len(parts))):
			ret.append(("/%s" % part, self.get_page_title(part, os.path.basename(part))))

		return ret

	def search(self, query, account=None, limit=None):
		query = util.parse_search_query(query)

		res = self._get_pages("SELECT wiki.* FROM wiki_search_index search_index \
			LEFT JOIN wiki ON search_index.wiki_id = wiki.id \
			WHERE search_index.document @@ to_tsquery('english', %s) \
				ORDER BY ts_rank(search_index.document, to_tsquery('english', %s)) DESC",
			query, query)

		pages = []
		for page in res:
			# Skip any pages the user doesn't have permission for
			if not page.check_acl(account):
				continue

			# Return any other pages
			pages.append(page)

			# Break when we have found enough pages
			if limit and len(pages) >= limit:
				break

		return pages

	def refresh(self):
		"""
			Needs to be called after a page has been changed
		"""
		self.db.execute("REFRESH MATERIALIZED VIEW wiki_search_index")

	def get_watchlist(self, account):
		pages = self._get_pages(
			"WITH pages AS (SELECT * FROM wiki_current \
					LEFT JOIN wiki ON wiki_current.id = wiki.id) \
			SELECT * FROM wiki_watchlist watchlist \
				LEFT JOIN pages ON watchlist.page = pages.page \
				WHERE watchlist.uid = %s",
			account.uid,
		)

		return sorted(pages)

	# ACL

	def check_acl(self, page, account):
		res = self.db.query("SELECT * FROM wiki_acls \
			WHERE %s ILIKE (path || '%%') ORDER BY LENGTH(path) DESC LIMIT 1", page)

		for row in res:
			# Access not permitted when user is not logged in
			if not account:
				return False

			# If user is in a matching group, we grant permission
			for group in row.groups:
				if group in account.groups:
					return True

			# Otherwise access is not permitted
			return False

		# If no ACLs are found, we permit access
		return True

	# Files

	def _get_files(self, query, *args):
		res = self.db.query(query, *args)

		for row in res:
			yield File(self.backend, row.id, data=row)

	def _get_file(self, query, *args):
		res = self.db.get(query, *args)

		if res:
			return File(self.backend, res.id, data=res)

	def get_files(self, path):
		files = self._get_files("SELECT * FROM wiki_files \
			WHERE path = %s AND deleted_at IS NULL ORDER BY filename", path)

		return list(files)

	def get_file_by_path(self, path, revision=None):
		path, filename = os.path.dirname(path), os.path.basename(path)

		if revision:
			# Fetch a specific revision
			return self._get_file("SELECT * FROM wiki_files \
				WHERE path = %s AND filename = %s AND created_at <= %s \
				ORDER BY created_at DESC LIMIT 1", path, filename, revision)

		# Fetch latest version
		return self._get_file("SELECT * FROM wiki_files \
			WHERE path = %s AND filename = %s AND deleted_at IS NULL",
			path, filename)

	def get_file_by_path_and_filename(self, path, filename):
		return self._get_file("SELECT * FROM wiki_files \
			WHERE path = %s AND filename = %s AND deleted_at IS NULL",
			path, filename)

	def upload(self, path, filename, data, mimetype, author, address):
		# Replace any existing files
		file = self.get_file_by_path_and_filename(path, filename)
		if file:
			file.delete(author)

		# Upload the blob first
		blob = self.db.get("INSERT INTO wiki_blobs(data) VALUES(%s) RETURNING id", data)

		# Create entry for file
		return self._get_file("INSERT INTO wiki_files(path, filename, author_uid, address, \
			mimetype, blob_id, size) VALUES(%s,  %s, %s, %s, %s, %s, %s) RETURNING *", path,
			filename, author.uid, address, mimetype, blob.id, len(data))

	def render(self, path, text):
		r = WikiRenderer(self.backend, path)

		return r.render(text)


class Page(misc.Object):
	def init(self, id, data=None):
		self.id = id
		self.data = data

	def __repr__(self):
		return "<%s %s %s>" % (self.__class__.__name__, self.page, self.timestamp)

	def __eq__(self, other):
		if isinstance(other, self.__class__):
			return self.id == other.id

	def __lt__(self, other):
		if isinstance(other, self.__class__):
			if self.page == other.page:
				return self.timestamp < other.timestamp

			return self.page < other.page

	@staticmethod
	def sanitise_page_name(page):
		if not page:
			return "/"

		# Make sure that the page name does NOT end with a /
		if page.endswith("/"):
			page = page[:-1]

		# Make sure the page name starts with a /
		if not page.startswith("/"):
			page = "/%s" % page

		# Remove any double slashes
		page = page.replace("//", "/")

		return page

	@property
	def url(self):
		return self.page

	@property
	def full_url(self):
		return "https://wiki.ipfire.org%s" % self.url

	@property
	def page(self):
		return self.data.page

	@property
	def title(self):
		return self._title or os.path.basename(self.page[1:])

	@property
	def _title(self):
		if not self.markdown:
			return

		# Find first H1 headline in markdown
		markdown = self.markdown.splitlines()

		m = re.match(r"^#\s*(.*)( #)?$", markdown[0])
		if m:
			return m.group(1)

	@lazy_property
	def author(self):
		if self.data.author_uid:
			return self.backend.accounts.get_by_uid(self.data.author_uid)

	@property
	def markdown(self):
		return self.data.markdown or ""

	@property
	def html(self):
		return self.backend.wiki.render(self.page, self.markdown)

	@property
	def timestamp(self):
		return self.data.timestamp

	def was_deleted(self):
		return self.markdown is None

	@lazy_property
	def breadcrumbs(self):
		return self.backend.wiki.make_breadcrumbs(self.page)

	def get_latest_revision(self):
		revisions = self.get_revisions()

		# Return first object
		for rev in revisions:
			return rev

	def get_revisions(self):
		return self.backend.wiki._get_pages("SELECT * FROM wiki \
			WHERE page = %s ORDER BY timestamp DESC", self.page)

	@lazy_property
	def previous_revision(self):
		return self.backend.wiki._get_page("SELECT * FROM wiki \
			WHERE page = %s AND timestamp < %s ORDER BY timestamp DESC \
			LIMIT 1", self.page, self.timestamp)

	@property
	def changes(self):
		return self.data.changes

	# ACL

	def check_acl(self, account):
		return self.backend.wiki.check_acl(self.page, account)

	# Sidebar

	@lazy_property
	def sidebar(self):
		parts = self.page.split("/")

		while parts:
			sidebar = self.backend.wiki.get_page("%s/sidebar" % os.path.join(*parts))
			if sidebar:
				return sidebar

			parts.pop()

	# Watchers

	@lazy_property
	def diff(self):
		if self.previous_revision:
			diff = difflib.unified_diff(
				self.previous_revision.markdown.splitlines(),
				self.markdown.splitlines(),
			)

			return "\n".join(diff)

	@property
	def watchers(self):
		res = self.db.query("SELECT uid FROM wiki_watchlist \
			WHERE page = %s", self.page)

		for row in res:
			# Search for account by UID and skip if none was found
			account = self.backend.accounts.get_by_uid(row.uid)
			if not account:
				continue

			# Return the account
			yield account

	def is_watched_by(self, account):
		res = self.db.get("SELECT 1 FROM wiki_watchlist \
			WHERE page = %s AND uid = %s", self.page, account.uid)

		if res:
			return True

		return False

	def add_watcher(self, account):
		if self.is_watched_by(account):
			return

		self.db.execute("INSERT INTO wiki_watchlist(page, uid) \
			VALUES(%s, %s)", self.page, account.uid)

	def remove_watcher(self, account):
		self.db.execute("DELETE FROM wiki_watchlist \
			WHERE page = %s AND uid = %s", self.page, account.uid)

	def _send_watcher_emails(self, excludes=[]):
		# Nothing to do if there was no previous revision
		if not self.previous_revision:
			return

		for watcher in self.watchers:
			# Skip everyone who is excluded
			if watcher in excludes:
				logging.debug("Excluding %s" % watcher)
				continue

			# Check permissions
			if not self.backend.wiki.check_acl(self.page, watcher):
				logging.debug("Watcher %s does not have permissions" % watcher)
				continue

			logging.debug("Sending watcher email to %s" % watcher)

			# Compose message
			self.backend.messages.send_template("wiki/messages/page-changed",
				sender="IPFire Wiki <wiki@ipfire.org>", recipients=[watcher],
				page=self, priority=-10)


class File(misc.Object):
	def init(self, id, data):
		self.id   = id
		self.data = data

	def __eq__(self, other):
		if isinstance(other, self.__class__):
			return self.id == other.id

	@property
	def url(self):
		return os.path.join(self.path, self.filename)

	@property
	def path(self):
		return self.data.path

	@property
	def filename(self):
		return self.data.filename

	@property
	def mimetype(self):
		return self.data.mimetype

	@property
	def size(self):
		return self.data.size

	@lazy_property
	def author(self):
		if self.data.author_uid:
			return self.backend.accounts.get_by_uid(self.data.author_uid)

	@property
	def created_at(self):
		return self.data.created_at

	def delete(self, author):
		# XXX handle author
		self.db.execute("UPDATE wiki_files SET deleted_at = NOW() \
			WHERE id = %s", self.id)

	@property
	def deleted_at(self):
		return self.data.deleted_at

	def get_latest_revision(self):
		revisions = self.get_revisions()

		# Return first object
		for rev in revisions:
			return rev

	def get_revisions(self):
		revisions = self.backend.wiki._get_files("SELECT * FROM wiki_files \
			WHERE path = %s ORDER BY created_at DESC", self.path)

		return list(revisions)

	def is_pdf(self):
		return self.mimetype in ("application/pdf", "application/x-pdf")

	def is_image(self):
		return self.mimetype.startswith("image/")

	@lazy_property
	def blob(self):
		res = self.db.get("SELECT data FROM wiki_blobs \
			WHERE id = %s", self.data.blob_id)

		if res:
			return bytes(res.data)

	def get_thumbnail(self, size):
		cache_key = "-".join((self.path, util.normalize(self.filename), self.created_at.isoformat(), "%spx" % size))

		# Try to fetch the data from the cache
		thumbnail = self.memcache.get(cache_key)
		if thumbnail:
			return thumbnail

		# Generate the thumbnail
		thumbnail = util.generate_thumbnail(self.blob, size)

		# Put it into the cache for forever
		self.memcache.set(cache_key, thumbnail)

		return thumbnail


class WikiRenderer(misc.Object):
	schemas = (
		"ftp://",
		"git://",
		"http://",
		"https://",
		"rsync://",
		"sftp://",
		"ssh://",
		"webcal://",
	)

	# Links
	links = re.compile(r"<a href=\"(.*?)\">(.*?)</a>")

	# Images
	images = re.compile(r"<img alt(?:=\"(.*?)\")? src=\"(.*?)\" (?:title=\"(.*?)\" )?/>")

	def init(self, path):
		self.path = path

	def _render_link(self, m):
		url, text = m.groups()

		# Emails
		if "@" in url:
			# Strip mailto:
			if url.startswith("mailto:"):
				url = url[7:]

			return """<a class="link-external" href="mailto:%s">%s</a>""" % \
				(url, text or url)

		# External Links
		for schema in self.schemas:
			if url.startswith(schema):
				return """<a class="link-external" href="%s">%s</a>""" % \
					(url, text or url)

		# Everything else must be an internal link
		path = self.backend.wiki.make_path(self.path, url)

		return """<a href="%s">%s</a>""" % \
			(path, text or self.backend.wiki.get_page_title(path))

	def _render_image(self, m):
		alt_text, url, caption = m.groups()

		# Skip any absolute and external URLs
		if url.startswith("/") or url.startswith("https://") or url.startswith("http://"):
			return """<figure class="figure"><img src="%s" class="figure-img img-fluid rounded" alt="%s">
				<figcaption class="figure-caption">%s</figcaption></figure>
			""" % (url, alt_text, caption or "")

		# Try to split query string
		url, delimiter, qs = url.partition("?")

		# Parse query arguments
		args = urllib.parse.parse_qs(qs)

		# Build absolute path
		url = self.backend.wiki.make_path(self.path, url)

		# Find image
		file = self.backend.wiki.get_file_by_path(url)
		if not file or not file.is_image():
			return "<!-- Could not find image %s in %s -->" % (url, self.path)

		# Scale down the image if not already done
		if not "s" in args:
			args["s"] = "920"

		return """<figure class="figure"><img src="%s?%s" class="figure-img img-fluid rounded" alt="%s">
		<figcaption class="figure-caption">%s</figcaption></figure>
		""" % (url, urllib.parse.urlencode(args), caption, caption or "")

	def render(self, text):
		logging.debug("Rendering %s" % self.path)

		# Borrow this from the blog
		text = self.backend.blog._render_text(text, lang="markdown")

		# Postprocess links
		text = self.links.sub(self._render_link, text)

		# Postprocess images to <figure>
		text = self.images.sub(self._render_image, text)

		return text
Commit	Line	Data
181d08f3 MT	1	#!/usr/bin/python3
181d08f3 MT	2
4ed1dadb	3	import difflib
181d08f3	4	import logging
6ac7e934	5	import os.path
181d08f3	6	import re
addc18d5	7	import tornado.gen
9e90e800	8	import urllib.parse
181d08f3 MT	9
181d08f3 MT	10	from . import misc
9523790a	11	from . import util
181d08f3 MT	12	from .decorators import *
181d08f3 MT	13
181d08f3 MT	14	class Wiki(misc.Object):
	15	def _get_pages(self, query, *args):
	16	res = self.db.query(query, *args)
	17
	18	for row in res:
	19	yield Page(self.backend, row.id, data=row)
	20
d398ca08 MT	21	def _get_page(self, query, *args):
	22	res = self.db.get(query, *args)
	23
	24	if res:
	25	return Page(self.backend, res.id, data=res)
	26
c78ad26e MT	27	def make_path(self, page, path):
	28	# Nothing to do for absolute links
	29	if path.startswith("/"):
	30	pass
	31
	32	# Relative links (one-level down)
	33	elif path.startswith("./"):
	34	path = os.path.join(page, path)
	35
	36	# All other relative links
	37	else:
	38	p = os.path.dirname(page)
	39	path = os.path.join(p, path)
	40
	41	# Normalise links
	42	return os.path.normpath(path)
	43
9ff59d70 MT	44	def page_exists(self, path):
	45	page = self.get_page(path)
	46
	47	# Page must have been found and not deleted
	48	return page and not page.was_deleted()
	49
6ac7e934	50	def get_page_title(self, page, default=None):
50c8dc11 MT	51	# Try to retrieve title from cache
	52	title = self.memcache.get("wiki:title:%s" % page)
	53	if title:
	54	return title
	55
	56	# If the title has not been in the cache, we will
	57	# have to look it up
6ac7e934 MT	58	doc = self.get_page(page)
6ac7e934 MT	59	if doc:
50c8dc11 MT	60	title = doc.title
	61	else:
	62	title = os.path.basename(page)
6ac7e934	63
50c8dc11 MT	64	# Save in cache for forever
	65	self.memcache.set("wiki:title:%s" % page, title)
	66
	67	return title
6ac7e934	68
181d08f3 MT	69	def get_page(self, page, revision=None):
	70	page = Page.sanitise_page_name(page)
	71	assert page
	72
	73	if revision:
d398ca08	74	return self._get_page("SELECT * FROM wiki WHERE page = %s \
181d08f3 MT	75	AND timestamp = %s", page, revision)
181d08f3 MT	76	else:
d398ca08	77	return self._get_page("SELECT * FROM wiki WHERE page = %s \
181d08f3 MT	78	ORDER BY timestamp DESC LIMIT 1", page)
181d08f3 MT	79
11afe905 MT	80	def get_recent_changes(self, account, limit=None):
11afe905 MT	81	pages = self._get_pages("SELECT * FROM wiki \
11afe905 MT	82	ORDER BY timestamp DESC")
	83
	84	for page in pages:
	85	if not page.check_acl(account):
	86	continue
	87
	88	yield page
	89
	90	limit -= 1
	91	if not limit:
	92	break
181d08f3	93
495e9dc4	94	def create_page(self, page, author, content, changes=None, address=None):
181d08f3 MT	95	page = Page.sanitise_page_name(page)
181d08f3 MT	96
aba5e58a MT	97	# Write page to the database
aba5e58a MT	98	page = self._get_page("INSERT INTO wiki(page, author_uid, markdown, changes, address) \
df01767e	99	VALUES(%s, %s, %s, %s, %s) RETURNING *", page, author.uid, content or None, changes, address)
181d08f3	100
50c8dc11	101	# Update cache
980e486d	102	self.memcache.set("wiki:title:%s" % page.page, page.title)
50c8dc11	103
aba5e58a MT	104	# Send email to all watchers
	105	page._send_watcher_emails(excludes=[author])
	106
	107	return page
	108
495e9dc4	109	def delete_page(self, page, author, **kwargs):
181d08f3 MT	110	# Do nothing if the page does not exist
	111	if not self.get_page(page):
	112	return
	113
	114	# Just creates a blank last version of the page
495e9dc4	115	self.create_page(page, author=author, content=None, **kwargs)
181d08f3	116
3168788e MT	117	def make_breadcrumbs(self, url):
3168788e MT	118	# Split and strip all empty elements (double slashes)
181d08f3 MT	119	parts = list(e for e in url.split("/") if e)
181d08f3 MT	120
3168788e	121	ret = []
b1bf7d48	122	for part in ("/".join(parts[:i]) for i in range(1, len(parts))):
3168788e	123	ret.append(("/%s" % part, self.get_page_title(part, os.path.basename(part))))
181d08f3	124
3168788e	125	return ret
181d08f3	126
11afe905	127	def search(self, query, account=None, limit=None):
9523790a MT	128	query = util.parse_search_query(query)
	129
	130	res = self._get_pages("SELECT wiki.* FROM wiki_search_index search_index \
	131	LEFT JOIN wiki ON search_index.wiki_id = wiki.id \
	132	WHERE search_index.document @@ to_tsquery('english', %s) \
11afe905 MT	133	ORDER BY ts_rank(search_index.document, to_tsquery('english', %s)) DESC",
11afe905 MT	134	query, query)
9523790a	135
df80be2c	136	pages = []
11afe905 MT	137	for page in res:
	138	# Skip any pages the user doesn't have permission for
	139	if not page.check_acl(account):
	140	continue
	141
	142	# Return any other pages
df80be2c	143	pages.append(page)
11afe905	144
df80be2c MT	145	# Break when we have found enough pages
df80be2c MT	146	if limit and len(pages) >= limit:
11afe905	147	break
9523790a	148
df80be2c MT	149	return pages
df80be2c MT	150
9523790a MT	151	def refresh(self):
	152	"""
	153	Needs to be called after a page has been changed
	154	"""
	155	self.db.execute("REFRESH MATERIALIZED VIEW wiki_search_index")
	156
2f23c558 MT	157	def get_watchlist(self, account):
	158	pages = self._get_pages(
	159	"WITH pages AS (SELECT * FROM wiki_current \
	160	LEFT JOIN wiki ON wiki_current.id = wiki.id) \
	161	SELECT * FROM wiki_watchlist watchlist \
	162	LEFT JOIN pages ON watchlist.page = pages.page \
	163	WHERE watchlist.uid = %s",
	164	account.uid,
	165	)
	166
	167	return sorted(pages)
	168
11afe905 MT	169	# ACL
	170
	171	def check_acl(self, page, account):
	172	res = self.db.query("SELECT * FROM wiki_acls \
	173	WHERE %s ILIKE (path \|\| '%%') ORDER BY LENGTH(path) DESC LIMIT 1", page)
	174
	175	for row in res:
	176	# Access not permitted when user is not logged in
	177	if not account:
	178	return False
	179
	180	# If user is in a matching group, we grant permission
	181	for group in row.groups:
	182	if group in account.groups:
	183	return True
	184
	185	# Otherwise access is not permitted
	186	return False
	187
	188	# If no ACLs are found, we permit access
	189	return True
	190
f2cfd873 MT	191	# Files
	192
	193	def _get_files(self, query, *args):
	194	res = self.db.query(query, *args)
	195
	196	for row in res:
	197	yield File(self.backend, row.id, data=row)
	198
	199	def _get_file(self, query, *args):
	200	res = self.db.get(query, *args)
	201
	202	if res:
	203	return File(self.backend, res.id, data=res)
	204
	205	def get_files(self, path):
	206	files = self._get_files("SELECT * FROM wiki_files \
	207	WHERE path = %s AND deleted_at IS NULL ORDER BY filename", path)
	208
	209	return list(files)
	210
ff14dea3	211	def get_file_by_path(self, path, revision=None):
f2cfd873 MT	212	path, filename = os.path.dirname(path), os.path.basename(path)
f2cfd873 MT	213
ff14dea3 MT	214	if revision:
	215	# Fetch a specific revision
	216	return self._get_file("SELECT * FROM wiki_files \
	217	WHERE path = %s AND filename = %s AND created_at <= %s \
	218	ORDER BY created_at DESC LIMIT 1", path, filename, revision)
	219
	220	# Fetch latest version
	221	return self._get_file("SELECT * FROM wiki_files \
	222	WHERE path = %s AND filename = %s AND deleted_at IS NULL",
	223	path, filename)
	224
	225	def get_file_by_path_and_filename(self, path, filename):
f2cfd873	226	return self._get_file("SELECT * FROM wiki_files \
ff14dea3 MT	227	WHERE path = %s AND filename = %s AND deleted_at IS NULL",
ff14dea3 MT	228	path, filename)
f2cfd873 MT	229
f2cfd873 MT	230	def upload(self, path, filename, data, mimetype, author, address):
ff14dea3 MT	231	# Replace any existing files
	232	file = self.get_file_by_path_and_filename(path, filename)
	233	if file:
	234	file.delete(author)
	235
f2cfd873 MT	236	# Upload the blob first
	237	blob = self.db.get("INSERT INTO wiki_blobs(data) VALUES(%s) RETURNING id", data)
	238
	239	# Create entry for file
	240	return self._get_file("INSERT INTO wiki_files(path, filename, author_uid, address, \
	241	mimetype, blob_id, size) VALUES(%s, %s, %s, %s, %s, %s, %s) RETURNING *", path,
	242	filename, author.uid, address, mimetype, blob.id, len(data))
	243
2901b734 MT	244	def render(self, path, text):
2901b734 MT	245	r = WikiRenderer(self.backend, path)
181d08f3	246
2901b734	247	return r.render(text)
e2205cff	248
154f6179	249
2901b734	250	class Page(misc.Object):
181d08f3 MT	251	def init(self, id, data=None):
	252	self.id = id
	253	self.data = data
	254
dc847af5 MT	255	def __repr__(self):
	256	return "<%s %s %s>" % (self.__class__.__name__, self.page, self.timestamp)
	257
c21ffadb MT	258	def __eq__(self, other):
	259	if isinstance(other, self.__class__):
	260	return self.id == other.id
	261
181d08f3 MT	262	def __lt__(self, other):
	263	if isinstance(other, self.__class__):
	264	if self.page == other.page:
	265	return self.timestamp < other.timestamp
	266
	267	return self.page < other.page
	268
	269	@staticmethod
	270	def sanitise_page_name(page):
	271	if not page:
	272	return "/"
	273
	274	# Make sure that the page name does NOT end with a /
	275	if page.endswith("/"):
	276	page = page[:-1]
	277
	278	# Make sure the page name starts with a /
	279	if not page.startswith("/"):
	280	page = "/%s" % page
	281
	282	# Remove any double slashes
	283	page = page.replace("//", "/")
	284
	285	return page
	286
	287	@property
	288	def url(self):
db8448d9	289	return self.page
181d08f3	290
4ed1dadb MT	291	@property
	292	def full_url(self):
	293	return "https://wiki.ipfire.org%s" % self.url
	294
181d08f3 MT	295	@property
	296	def page(self):
	297	return self.data.page
	298
	299	@property
	300	def title(self):
51e7a876	301	return self._title or os.path.basename(self.page[1:])
181d08f3 MT	302
	303	@property
	304	def _title(self):
	305	if not self.markdown:
	306	return
	307
	308	# Find first H1 headline in markdown
	309	markdown = self.markdown.splitlines()
	310
0074e919	311	m = re.match(r"^#\s(.)( #)?$", markdown[0])
181d08f3 MT	312	if m:
	313	return m.group(1)
	314
3b05ef6e MT	315	@lazy_property
	316	def author(self):
	317	if self.data.author_uid:
	318	return self.backend.accounts.get_by_uid(self.data.author_uid)
	319
181d08f3 MT	320	@property
181d08f3 MT	321	def markdown(self):
c21ffadb	322	return self.data.markdown or ""
181d08f3 MT	323
	324	@property
	325	def html(self):
2901b734	326	return self.backend.wiki.render(self.page, self.markdown)
addc18d5	327
181d08f3 MT	328	@property
	329	def timestamp(self):
	330	return self.data.timestamp
	331
	332	def was_deleted(self):
	333	return self.markdown is None
	334
	335	@lazy_property
	336	def breadcrumbs(self):
	337	return self.backend.wiki.make_breadcrumbs(self.page)
	338
	339	def get_latest_revision(self):
7d699684 MT	340	revisions = self.get_revisions()
	341
	342	# Return first object
	343	for rev in revisions:
	344	return rev
	345
	346	def get_revisions(self):
	347	return self.backend.wiki._get_pages("SELECT * FROM wiki \
	348	WHERE page = %s ORDER BY timestamp DESC", self.page)
091ac36b	349
c21ffadb MT	350	@lazy_property
	351	def previous_revision(self):
	352	return self.backend.wiki._get_page("SELECT * FROM wiki \
	353	WHERE page = %s AND timestamp < %s ORDER BY timestamp DESC \
	354	LIMIT 1", self.page, self.timestamp)
	355
d398ca08 MT	356	@property
	357	def changes(self):
	358	return self.data.changes
	359
11afe905 MT	360	# ACL
	361
	362	def check_acl(self, account):
	363	return self.backend.wiki.check_acl(self.page, account)
	364
091ac36b MT	365	# Sidebar
	366
	367	@lazy_property
	368	def sidebar(self):
	369	parts = self.page.split("/")
	370
	371	while parts:
3cc5f666	372	sidebar = self.backend.wiki.get_page("%s/sidebar" % os.path.join(*parts))
091ac36b MT	373	if sidebar:
	374	return sidebar
	375
	376	parts.pop()
f2cfd873	377
d64a1e35 MT	378	# Watchers
d64a1e35 MT	379
4ed1dadb MT	380	@lazy_property
	381	def diff(self):
	382	if self.previous_revision:
	383	diff = difflib.unified_diff(
	384	self.previous_revision.markdown.splitlines(),
	385	self.markdown.splitlines(),
	386	)
	387
	388	return "\n".join(diff)
	389
aba5e58a MT	390	@property
	391	def watchers(self):
	392	res = self.db.query("SELECT uid FROM wiki_watchlist \
	393	WHERE page = %s", self.page)
	394
	395	for row in res:
	396	# Search for account by UID and skip if none was found
	397	account = self.backend.accounts.get_by_uid(row.uid)
	398	if not account:
	399	continue
	400
	401	# Return the account
	402	yield account
	403
f2e25ded	404	def is_watched_by(self, account):
d64a1e35 MT	405	res = self.db.get("SELECT 1 FROM wiki_watchlist \
	406	WHERE page = %s AND uid = %s", self.page, account.uid)
	407
	408	if res:
	409	return True
	410
	411	return False
	412
	413	def add_watcher(self, account):
f2e25ded	414	if self.is_watched_by(account):
d64a1e35 MT	415	return
	416
	417	self.db.execute("INSERT INTO wiki_watchlist(page, uid) \
	418	VALUES(%s, %s)", self.page, account.uid)
	419
	420	def remove_watcher(self, account):
	421	self.db.execute("DELETE FROM wiki_watchlist \
	422	WHERE page = %s AND uid = %s", self.page, account.uid)
	423
aba5e58a MT	424	def _send_watcher_emails(self, excludes=[]):
	425	# Nothing to do if there was no previous revision
	426	if not self.previous_revision:
	427	return
	428
	429	for watcher in self.watchers:
	430	# Skip everyone who is excluded
	431	if watcher in excludes:
	432	logging.debug("Excluding %s" % watcher)
	433	continue
	434
516da0a9 MT	435	# Check permissions
	436	if not self.backend.wiki.check_acl(self.page, watcher):
	437	logging.debug("Watcher %s does not have permissions" % watcher)
	438	continue
	439
aba5e58a MT	440	logging.debug("Sending watcher email to %s" % watcher)
aba5e58a MT	441
4ed1dadb MT	442	# Compose message
4ed1dadb MT	443	self.backend.messages.send_template("wiki/messages/page-changed",
68ee09e8 MT	444	sender="IPFire Wiki <wiki@ipfire.org>", recipients=[watcher],
68ee09e8 MT	445	page=self, priority=-10)
aba5e58a	446
f2cfd873 MT	447
	448	class File(misc.Object):
	449	def init(self, id, data):
	450	self.id = id
	451	self.data = data
	452
ff14dea3 MT	453	def __eq__(self, other):
	454	if isinstance(other, self.__class__):
	455	return self.id == other.id
	456
f2cfd873 MT	457	@property
	458	def url(self):
	459	return os.path.join(self.path, self.filename)
	460
	461	@property
	462	def path(self):
	463	return self.data.path
	464
	465	@property
	466	def filename(self):
	467	return self.data.filename
	468
	469	@property
	470	def mimetype(self):
	471	return self.data.mimetype
	472
	473	@property
	474	def size(self):
	475	return self.data.size
	476
8cb0bea4 MT	477	@lazy_property
	478	def author(self):
	479	if self.data.author_uid:
	480	return self.backend.accounts.get_by_uid(self.data.author_uid)
	481
	482	@property
	483	def created_at(self):
	484	return self.data.created_at
	485
ff14dea3 MT	486	def delete(self, author):
	487	# XXX handle author
	488	self.db.execute("UPDATE wiki_files SET deleted_at = NOW() \
	489	WHERE id = %s", self.id)
	490
	491	@property
	492	def deleted_at(self):
	493	return self.data.deleted_at
	494
	495	def get_latest_revision(self):
	496	revisions = self.get_revisions()
	497
	498	# Return first object
	499	for rev in revisions:
	500	return rev
	501
	502	def get_revisions(self):
	503	revisions = self.backend.wiki._get_files("SELECT * FROM wiki_files \
	504	WHERE path = %s ORDER BY created_at DESC", self.path)
	505
	506	return list(revisions)
	507
8cb0bea4 MT	508	def is_pdf(self):
	509	return self.mimetype in ("application/pdf", "application/x-pdf")
	510
f2cfd873 MT	511	def is_image(self):
	512	return self.mimetype.startswith("image/")
	513
	514	@lazy_property
	515	def blob(self):
	516	res = self.db.get("SELECT data FROM wiki_blobs \
	517	WHERE id = %s", self.data.blob_id)
	518
	519	if res:
	520	return bytes(res.data)
79dd9a0f MT	521
79dd9a0f MT	522	def get_thumbnail(self, size):
75d9b3da MT	523	cache_key = "-".join((self.path, util.normalize(self.filename), self.created_at.isoformat(), "%spx" % size))
	524
	525	# Try to fetch the data from the cache
	526	thumbnail = self.memcache.get(cache_key)
	527	if thumbnail:
	528	return thumbnail
	529
	530	# Generate the thumbnail
5ef115cd	531	thumbnail = util.generate_thumbnail(self.blob, size)
75d9b3da MT	532
	533	# Put it into the cache for forever
	534	self.memcache.set(cache_key, thumbnail)
	535
	536	return thumbnail
2901b734 MT	537
	538
	539	class WikiRenderer(misc.Object):
4ddad3e5 MT	540	schemas = (
	541	"ftp://",
	542	"git://",
	543	"http://",
	544	"https://",
	545	"rsync://",
	546	"sftp://",
	547	"ssh://",
	548	"webcal://",
	549	)
	550
	551	# Links
	552	links = re.compile(r"<a href=\"(.?)\">(.?)</a>")
2901b734	553
c78ad26e	554	# Images
e9c6d581	555	images = re.compile(r"<img alt(?:=\"(.?)\")? src=\"(.?)\" (?:title=\"(.*?)\" )?/>")
c78ad26e	556
2901b734 MT	557	def init(self, path):
	558	self.path = path
	559
4ddad3e5 MT	560	def _render_link(self, m):
4ddad3e5 MT	561	url, text = m.groups()
2901b734	562
4ddad3e5 MT	563	# Emails
	564	if "@" in url:
	565	# Strip mailto:
	566	if url.startswith("mailto:"):
	567	url = url[7:]
2901b734	568
4ddad3e5 MT	569	return """<a class="link-external" href="mailto:%s">%s</a>""" % \
4ddad3e5 MT	570	(url, text or url)
2901b734	571
4ddad3e5 MT	572	# External Links
	573	for schema in self.schemas:
	574	if url.startswith(schema):
	575	return """<a class="link-external" href="%s">%s</a>""" % \
	576	(url, text or url)
2901b734	577
4ddad3e5 MT	578	# Everything else must be an internal link
4ddad3e5 MT	579	path = self.backend.wiki.make_path(self.path, url)
2901b734	580
4ddad3e5 MT	581	return """<a href="%s">%s</a>""" % \
4ddad3e5 MT	582	(path, text or self.backend.wiki.get_page_title(path))
2901b734	583
c78ad26e	584	def _render_image(self, m):
e9c6d581	585	alt_text, url, caption = m.groups()
2901b734	586
c78ad26e MT	587	# Skip any absolute and external URLs
c78ad26e MT	588	if url.startswith("/") or url.startswith("https://") or url.startswith("http://"):
fa8c5edd MT	589	return """<figure class="figure"><img src="%s" class="figure-img img-fluid rounded" alt="%s">
fa8c5edd MT	590	<figcaption class="figure-caption">%s</figcaption></figure>
9881e9ef	591	""" % (url, alt_text, caption or "")
2901b734	592
c78ad26e MT	593	# Try to split query string
c78ad26e MT	594	url, delimiter, qs = url.partition("?")
2901b734	595
c78ad26e MT	596	# Parse query arguments
c78ad26e MT	597	args = urllib.parse.parse_qs(qs)
2901b734	598
c78ad26e MT	599	# Build absolute path
c78ad26e MT	600	url = self.backend.wiki.make_path(self.path, url)
2901b734	601
c78ad26e MT	602	# Find image
	603	file = self.backend.wiki.get_file_by_path(url)
	604	if not file or not file.is_image():
	605	return "<!-- Could not find image %s in %s -->" % (url, self.path)
2901b734	606
c78ad26e MT	607	# Scale down the image if not already done
c78ad26e MT	608	if not "s" in args:
9ce45afb	609	args["s"] = "920"
2901b734	610
fa8c5edd MT	611	return """<figure class="figure"><img src="%s?%s" class="figure-img img-fluid rounded" alt="%s">
	612	<figcaption class="figure-caption">%s</figcaption></figure>
	613	""" % (url, urllib.parse.urlencode(args), caption, caption or "")
2901b734	614
c78ad26e MT	615	def render(self, text):
c78ad26e MT	616	logging.debug("Rendering %s" % self.path)
2901b734	617
9881e9ef MT	618	# Borrow this from the blog
	619	text = self.backend.blog._render_text(text, lang="markdown")
	620
4ddad3e5 MT	621	# Postprocess links
	622	text = self.links.sub(self._render_link, text)
	623
9881e9ef	624	# Postprocess images to <figure>
c78ad26e MT	625	text = self.images.sub(self._render_image, text)
c78ad26e MT	626
9881e9ef	627	return text