291 lines
11 KiB
Python
291 lines
11 KiB
Python
from django.conf import settings
|
|
from django.contrib.auth.models import User, Group
|
|
from django.db import models
|
|
from django.utils.translation import gettext as _
|
|
from simple_history.models import HistoricalRecords
|
|
|
|
from datetime import datetime
|
|
import difflib
|
|
import logging
|
|
import os
|
|
from zoneinfo import ZoneInfo
|
|
|
|
from users.models import get_userprofile
|
|
from pages import url_page
|
|
|
|
import mycreole
|
|
|
|
logger = logging.getLogger(settings.ROOT_LOGGER_NAME).getChild(__name__)
|
|
|
|
|
|
class PikiPage(models.Model):
|
|
SAVE_ON_CHANGE_FIELDS = ["rel_path", "page_txt", "tags", "deleted", "owner", "group"]
|
|
#
|
|
rel_path = models.CharField(unique=True, max_length=1000)
|
|
page_txt = models.TextField(max_length=50000)
|
|
tags = models.CharField(max_length=1000, null=True, blank=True)
|
|
deleted = models.BooleanField(default=False)
|
|
#
|
|
creation_time = models.DateTimeField(null=True, blank=True)
|
|
creation_user = models.ForeignKey(User, null=True, blank=True, on_delete=models.SET_NULL, related_name="creation_user")
|
|
modified_time = models.DateTimeField(null=True, blank=True)
|
|
modified_user = models.ForeignKey(User, null=True, blank=True, on_delete=models.SET_NULL, related_name="modified_user")
|
|
#
|
|
owner = models.ForeignKey(User, null=True, blank=True, on_delete=models.SET_NULL, related_name="owner")
|
|
group = models.ForeignKey(Group, null=True, blank=True, on_delete=models.SET_NULL, related_name="group")
|
|
# owner_perms
|
|
owner_perms_read = models.BooleanField(default=True)
|
|
owner_perms_write = models.BooleanField(default=True)
|
|
# group_perms
|
|
group_perms_read = models.BooleanField(default=True)
|
|
group_perms_write = models.BooleanField(default=True)
|
|
# other_perms
|
|
other_perms_read = models.BooleanField(default=True)
|
|
other_perms_write = models.BooleanField(default=False)
|
|
#
|
|
history = HistoricalRecords()
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
|
|
def prepare_save(self, request):
|
|
# Set date
|
|
tmd = datetime.now(tz=ZoneInfo("UTC")).replace(microsecond=0)
|
|
self.creation_time = self.creation_time or tmd
|
|
self.modified_time = tmd
|
|
# Set user
|
|
self.creation_user = self.creation_user or request.user
|
|
self.owner = self.owner or request.user
|
|
self.modified_user = request.user
|
|
|
|
def save(self, force_insert=False, force_update=False, using=None, update_fields=None):
|
|
if self.id and not force_update:
|
|
orig = PikiPage.objects.get(id=self.id)
|
|
for key in self.SAVE_ON_CHANGE_FIELDS:
|
|
if getattr(self, key) != getattr(orig, key):
|
|
break
|
|
else:
|
|
self.save_needed = False
|
|
return False
|
|
self.save_needed = True
|
|
return models.Model.save(self, force_insert=force_insert, force_update=force_update, using=using, update_fields=update_fields)
|
|
|
|
#
|
|
# Set history datetime to modified datetime
|
|
#
|
|
@property
|
|
def _history_date(self):
|
|
return self.modified_time
|
|
|
|
@_history_date.setter
|
|
def _history_date(self, value):
|
|
self.modified_time = value
|
|
|
|
#
|
|
# My information
|
|
#
|
|
@property
|
|
def title(self):
|
|
return self.rel_path.split("/")[-1]
|
|
|
|
#
|
|
# My methods
|
|
#
|
|
def render_to_html(self, request, history=None):
|
|
if history:
|
|
h = self.history.get(history_id=history)
|
|
return self.render_text(request, h.page_txt)
|
|
else:
|
|
return self.render_text(request, self.page_txt)
|
|
|
|
def user_datetime(self, request, dtm):
|
|
try:
|
|
up = get_userprofile(request.user)
|
|
except AttributeError:
|
|
tz = ZoneInfo("UTC")
|
|
else:
|
|
tz = ZoneInfo(up.timezone)
|
|
#
|
|
return datetime.astimezone(dtm, tz)
|
|
|
|
def render_meta(self, request, history):
|
|
# Page information
|
|
meta = f'= {_("Meta data")}\n'
|
|
meta += f'|{_("Created by")}:|{self.creation_user}|\n'
|
|
meta += f'|{_("Created at")}:|{self.user_datetime(request, self.creation_time)}|\n'
|
|
meta += f'|{_("Modified by")}:|{self.modified_user}|\n'
|
|
meta += f'|{_("Modified at")}:|{self.user_datetime(request, self.modified_time)}|\n'
|
|
meta += f'|{_("Owner")}:|{self.owner or "---"}|\n'
|
|
meta += f'|{_("Group")}:|{self.group or "---"}|\n'
|
|
meta += f'|{_("Tags")}|{self.tags or "---"}|\n'
|
|
#
|
|
# List of history page versions
|
|
#
|
|
hl = self.history.all()[1:]
|
|
if len(hl) > 0:
|
|
meta += f'= {_("History")}\n'
|
|
meta += f'| ={_("Version")} | ={_("Date")} | ={_("Page")} | ={_("Meta data")} | ={_("Page changed")} | ={_("Tags changed")} | \n'
|
|
# Current
|
|
name = _("Current")
|
|
meta += f"| {name} \
|
|
| {self.user_datetime(request, self.modified_time)} \
|
|
| [[{url_page(self.rel_path)} | Page]] \
|
|
| [[{url_page(self.rel_path, meta=None)} | Meta]] |"
|
|
page_content = self.page_txt.replace("\r\n", "\n").strip("\n")
|
|
tags = self.tags
|
|
for h_page in hl:
|
|
page_changed = page_content != h_page.page_txt.replace("\r\n", "\n").strip("\n")
|
|
tags_changed = tags != h_page.tags
|
|
if page_changed or tags_changed:
|
|
meta += " %s |" % ("Yes" if page_changed else "No")
|
|
meta += " %s |" % ("Yes" if tags_changed else "No")
|
|
meta += "\n"
|
|
meta += f"| {h_page.history_id} \
|
|
| {self.user_datetime(request, h_page.modified_time)} \
|
|
| [[{url_page(self.rel_path, history=h_page.history_id)} | Page]] \
|
|
| [[{url_page(self.rel_path, meta=None, history=h_page.history_id)} | Meta]] (with diff to current) |"
|
|
page_content = h_page.page_txt[:].replace("\r\n", "\n").strip("\n")
|
|
tags = h_page.tags
|
|
meta += " --- | --- |\n"
|
|
# Diff
|
|
html_diff = ""
|
|
if history:
|
|
h_page = self.history.get(history_id=history)
|
|
#
|
|
meta += f'= {_("Page differences")}\n'
|
|
#
|
|
left_lines = self.page_txt.splitlines()
|
|
right_lines = h_page.page_txt.splitlines()
|
|
html_diff = difflib.HtmlDiff(wrapcolumn=80).make_table(left_lines, right_lines, "Current page", "Page Version %d" % history)
|
|
#
|
|
return mycreole.render_simple(meta) + html_diff
|
|
|
|
#
|
|
# Creole stuff
|
|
#
|
|
def render_text(self, request, txt):
|
|
macros = {
|
|
"subpages": self.macro_subpages,
|
|
"allpages": self.macro_allpages,
|
|
"subpagetree": self.macro_subpagetree,
|
|
"allpagestree": self.macro_allpagestree,
|
|
}
|
|
return mycreole.render(request, txt, self.rel_path, macros=macros)
|
|
|
|
def macro_subpages(self, *args, **kwargs):
|
|
return self.macro_pages(*args, **kwargs)
|
|
|
|
def macro_allpages(self, *args, **kwargs):
|
|
kwargs["allpages"] = True
|
|
return self.macro_pages(*args, **kwargs)
|
|
|
|
def macro_allpagestree(self, *args, **kwargs):
|
|
kwargs["allpages"] = True
|
|
kwargs["tree"] = True
|
|
return self.macro_pages(*args, **kwargs)
|
|
|
|
def macro_subpagetree(self, * args, **kwargs):
|
|
kwargs["tree"] = True
|
|
return self.macro_pages(*args, **kwargs)
|
|
|
|
def macro_pages(self, *args, **kwargs):
|
|
allpages = kwargs.pop("allpages", False)
|
|
tree = kwargs.pop("tree", False)
|
|
#
|
|
|
|
def parse_depth(s: str):
|
|
try:
|
|
return int(s)
|
|
except ValueError:
|
|
pass
|
|
|
|
params = kwargs.get('', '')
|
|
filter_str = ''
|
|
depth = parse_depth(params)
|
|
if depth is None:
|
|
params = params.split(",")
|
|
depth = parse_depth(params[0])
|
|
if len(params) == 2:
|
|
filter_str = params[1]
|
|
elif depth is None:
|
|
filter_str = params[0]
|
|
#
|
|
if not allpages:
|
|
filter_str = os.path.join(self.rel_path, filter_str)
|
|
#
|
|
pages = PikiPage.objects.filter(rel_path__contains=filter_str)
|
|
pl = page_list([p for p in pages if not p.deleted])
|
|
#
|
|
if tree:
|
|
return "<pre>\n" + page_tree(pl).html() + "</pre>\n"
|
|
else:
|
|
return pl.html_list(depth=depth, filter_str=filter_str, parent_rel_path='' if allpages else self.rel_path)
|
|
|
|
|
|
class page_list(list):
|
|
def __init__(self, *args, **kwargs):
|
|
return super().__init__(*args, **kwargs)
|
|
|
|
def sort_basename(self):
|
|
return list.sort(self, key=lambda x: os.path.basename(x.rel_path))
|
|
|
|
def creole_list(self, depth=None, filter_str='', parent_rel_path=''):
|
|
self.sort_basename()
|
|
depth = depth or 9999 # set a random high value if None
|
|
#
|
|
rv = ""
|
|
last_char = None
|
|
for page in self:
|
|
if page.rel_path.startswith(filter_str) and page.rel_path != filter_str:
|
|
name = page.rel_path[len(parent_rel_path):].lstrip("/")
|
|
if name.count('/') < depth:
|
|
first_char = os.path.basename(name)[0].upper()
|
|
if last_char != first_char:
|
|
last_char = first_char
|
|
rv += f"=== {first_char}\n"
|
|
rv += f"* [[{url_page(page.rel_path)} | {name} ]]\n"
|
|
return rv
|
|
|
|
def html_list(self, depth=9999, filter_str='', parent_rel_path=''):
|
|
return mycreole.render_simple(self.creole_list(depth, filter_str, parent_rel_path))
|
|
|
|
|
|
class page_tree(dict):
|
|
T_PATTERN = "├── "
|
|
L_PATTERN = "└── "
|
|
I_PATTERN = "│ "
|
|
D_PATTERN = " "
|
|
|
|
def __init__(self, pl: page_list):
|
|
super().__init__()
|
|
for page in pl:
|
|
store_item = self
|
|
for entry in page.rel_path.split("/"):
|
|
if not entry in store_item:
|
|
store_item[entry] = {}
|
|
store_item = store_item[entry]
|
|
|
|
def html(self, rel_path=None, fill=""):
|
|
base = self
|
|
try:
|
|
for key in rel_path.split("/"):
|
|
base = base[key]
|
|
except AttributeError:
|
|
rel_path = ''
|
|
#
|
|
rv = ""
|
|
#
|
|
l = len(base)
|
|
for entry in sorted(list(base.keys())):
|
|
l -= 1
|
|
page_path = os.path.join(rel_path, entry)
|
|
try:
|
|
PikiPage.objects.get(rel_path=page_path)
|
|
except PikiPage.DoesNotExist:
|
|
pass
|
|
else:
|
|
entry = f'<a href="{url_page(page_path)}">{entry}</a>'
|
|
rv += fill + (self.L_PATTERN if l == 0 else self.T_PATTERN) + entry + "\n"
|
|
rv += self.html(page_path, fill=fill+(self.D_PATTERN if l == 0 else self.I_PATTERN))
|
|
return rv
|