evewiki 0.0.1.dev1__py3-none-any.whl

evewiki/__init__.py

@@ -0,0 +1,6 @@
+"""Wiki plugin app for Alliance Auth."""
+
+# pylint: disable = invalid-name
+default_app_config = "evewiki.apps.EveWikiConfig"
+
+__version__ = "0.0.1.dev1"

evewiki/admin.py

@@ -0,0 +1,16 @@
+"""Admin site."""
+
+from django.contrib import admin
+
+from .models.logs import Log
+from .models.page_versions import PageVersion
+from .models.pages import Page
+from .models.settings import Setting
+
+# from django.contrib import admin
+
+# Register your models for the admin site here.
+admin.site.register(Page)
+admin.site.register(Setting)
+admin.site.register(PageVersion)
+admin.site.register(Log)

evewiki/app_settings.py

@@ -0,0 +1,5 @@
+"""App settings."""
+
+from django.conf import settings
+
+EXAMPLE_SETTING_ONE = getattr(settings, "EXAMPLE_SETTING_ONE", None)

evewiki/apps.py

@@ -0,0 +1,9 @@
+from django.apps import AppConfig
+
+from . import __version__
+
+
+class EveWikiConfig(AppConfig):
+    name = "evewiki"
+    label = "evewiki"
+    verbose_name = f"evewiki v{__version__}"

evewiki/auth_hooks.py

@@ -0,0 +1,35 @@
+from django.utils.translation import gettext_lazy as _
+
+from allianceauth import hooks
+from allianceauth.services.hooks import MenuItemHook, UrlHook
+
+from . import urls
+
+
+class EveWikiMenuItem(MenuItemHook):
+    """This class ensures only authorized users will see the menu entry"""
+
+    def __init__(self):
+        # setup menu entry for sidebar
+        MenuItemHook.__init__(
+            self,
+            _("wiki"),
+            "fas fa-tree fa-fw",
+            "evewiki:index",
+            navactive=["evewiki:"],
+        )
+
+    def render(self, request):
+        if request.user.has_perm("evewiki.basic_access"):
+            return MenuItemHook.render(self, request)
+        return ""
+
+
+@hooks.register("menu_item_hook")
+def register_menu():
+    return EveWikiMenuItem()
+
+
+@hooks.register("url_hook")
+def register_urls():
+    return UrlHook(urls, "evewiki", r"^evewiki/")

evewiki/forms.py

@@ -0,0 +1,29 @@
+from django import forms
+
+from .models.pages import Page
+
+
+class PageForm(forms.ModelForm):
+
+    # Customised ddl inferring additional context via text-indentation
+    parent = forms.ChoiceField(
+        choices=Page.list(),
+        required=False,
+        label="Path",
+        help_text=Page._meta.get_field("parent").help_text,
+    )
+
+    class Meta:
+        model = Page
+        fields = ["title", "parent", "slug", "priority", "states", "groups"]
+
+    def clean(self):
+        """
+        Django needs a little help to turn the custom `parent` field back into a model.
+        """
+        cleaned_data = super().clean()
+        parent_id = cleaned_data["parent"]
+        cleaned_data["parent"] = (
+            Page.objects.get(pk=int(parent_id)) if parent_id else None
+        )
+        return cleaned_data

evewiki/migrations/0001_initial.py

@@ -0,0 +1,190 @@
+# Generated by Django 4.2.21 on 2025-05-27 00:35
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ("auth", "0012_alter_user_first_name_max_length"),
+        ("authentication", "0024_alter_userprofile_language"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="General",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+            ],
+            options={
+                "permissions": (
+                    ("basic_access", "Can access this app"),
+                    ("editor_access", "Can edit this app"),
+                ),
+                "managed": False,
+                "default_permissions": (),
+            },
+        ),
+        migrations.CreateModel(
+            name="Log",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("user", models.TextField(blank=True, default="", null=True)),
+                ("action", models.TextField(blank=True, default="", null=True)),
+                ("details", models.TextField(blank=True, default="", null=True)),
+                ("created", models.DateTimeField(auto_now_add=True)),
+            ],
+        ),
+        migrations.CreateModel(
+            name="Page",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "title",
+                    models.CharField(
+                        help_text="Required: Displayed above content and in menu",
+                        max_length=255,
+                    ),
+                ),
+                (
+                    "slug",
+                    models.CharField(
+                        help_text="Required: Indentifier for path and links",
+                        max_length=255,
+                    ),
+                ),
+                (
+                    "priority",
+                    models.IntegerField(
+                        default=10,
+                        help_text="Required: Sort order for pages on the same path",
+                    ),
+                ),
+                ("content", models.TextField(blank=True, default="", null=True)),
+                (
+                    "groups",
+                    models.ManyToManyField(
+                        blank=True,
+                        default=None,
+                        help_text="Optional: Restrict Page to specific Groups",
+                        related_name="+",
+                        to="auth.group",
+                        verbose_name="groups",
+                    ),
+                ),
+                (
+                    "parent",
+                    models.ForeignKey(
+                        blank=True,
+                        help_text="Required: Oragnise page hierarchy",
+                        null=True,
+                        on_delete=django.db.models.deletion.PROTECT,
+                        related_name="children",
+                        to="evewiki.page",
+                    ),
+                ),
+                (
+                    "states",
+                    models.ManyToManyField(
+                        blank=True,
+                        default=None,
+                        help_text="Optional: Restrict Page to specific States",
+                        related_name="+",
+                        to="authentication.state",
+                        verbose_name="states",
+                    ),
+                ),
+            ],
+        ),
+        migrations.CreateModel(
+            name="Setting",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "hierarchy_max_display_depth",
+                    models.IntegerField(
+                        default=10,
+                        help_text="Limit the depth of the tree for the hierarchy on the main display",
+                    ),
+                ),
+                (
+                    "max_versions",
+                    models.IntegerField(
+                        default=1000,
+                        help_text="No one has infinite disk space, a sensible limit which can be modified to clear down the history",
+                    ),
+                ),
+            ],
+        ),
+        migrations.CreateModel(
+            name="PageVersion",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("content", models.TextField(blank=True, default="", null=True)),
+                ("created", models.DateTimeField(auto_now_add=True)),
+                (
+                    "page",
+                    models.ForeignKey(
+                        blank=True,
+                        help_text="Page being edited",
+                        null=True,
+                        on_delete=django.db.models.deletion.SET_NULL,
+                        to="evewiki.page",
+                    ),
+                ),
+                (
+                    "user",
+                    models.ForeignKey(
+                        blank=True,
+                        help_text="User editing the page",
+                        null=True,
+                        on_delete=django.db.models.deletion.SET_NULL,
+                        to="authentication.userprofile",
+                    ),
+                ),
+            ],
+        ),
+    ]

evewiki/models/logs.py

@@ -0,0 +1,15 @@
+from django.db import models
+
+
+class Log(models.Model):
+    """
+    No relationships just a log.
+    """
+
+    user = models.TextField(default="", blank=True, null=True)
+
+    action = models.TextField(default="", blank=True, null=True)
+
+    details = models.TextField(default="", blank=True, null=True)
+
+    created = models.DateTimeField(auto_now_add=True)

evewiki/models/page_versions.py

@@ -0,0 +1,48 @@
+from django.db import models
+
+from allianceauth.authentication.models import UserProfile
+
+from .pages import Page
+from .settings import Setting
+
+
+class PageVersion(models.Model):
+    """
+    Previous edits have value
+    """
+
+    page = models.ForeignKey(
+        Page,
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        help_text="Page being edited",
+    )
+
+    user = models.ForeignKey(
+        UserProfile,
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        help_text="User editing the page",
+    )
+
+    content = models.TextField(default="", blank=True, null=True)
+
+    created = models.DateTimeField(auto_now_add=True)
+
+    def save(self, *args, **kwargs):
+        """
+        Clean up old versions when saving
+        """
+        super().save(*args, **kwargs)
+        if self.page_id:
+            # Get the IDs of old versions to delete
+            settings = Setting.get_settings()
+            old_version_ids = list(
+                PageVersion.objects.filter(page=self.page)
+                .order_by("-created")
+                .values_list("id", flat=True)[settings.max_versions :]
+            )
+            if old_version_ids:
+                PageVersion.objects.filter(id__in=old_version_ids).delete()

evewiki/models/pages.py

@@ -0,0 +1,249 @@
+import re
+from html import escape
+
+from django.contrib.auth.models import Group
+from django.core.exceptions import ValidationError
+from django.db import models
+
+from allianceauth.authentication.models import State
+
+
+class General(models.Model):
+    """A meta model for app permissions."""
+
+    class Meta:
+        managed = False
+        default_permissions = ()
+        permissions = (
+            ("basic_access", "Can access this app"),
+            ("editor_access", "Can edit this app"),
+        )
+
+
+class Page(models.Model):
+    """
+    Pages in a hierarchy, identifiable by slugs with a light touch of folder sorting.
+    """
+
+    title = models.CharField(
+        max_length=255,
+        null=False,
+        help_text="Required: Displayed above content and in menu",
+    )
+
+    parent = models.ForeignKey(
+        "self",
+        on_delete=models.PROTECT,
+        related_name="children",
+        null=True,
+        blank=True,
+        help_text="Required: Oragnise page hierarchy",
+    )
+
+    slug = models.CharField(
+        max_length=255, help_text="Required: Indentifier for path and links"
+    )
+
+    priority = models.IntegerField(
+        default=10, help_text="Required: Sort order for pages on the same path"
+    )
+
+    states = models.ManyToManyField(
+        State,
+        default=None,
+        blank=True,
+        related_name="+",
+        verbose_name=("states"),
+        help_text="Optional: Restrict Page to specific States",
+    )
+
+    groups = models.ManyToManyField(
+        Group,
+        default=None,
+        blank=True,
+        related_name="+",
+        verbose_name=("groups"),
+        help_text="Optional: Restrict Page to specific Groups",
+    )
+
+    content = models.TextField(default="", blank=True, null=True)
+
+    def __str__(self):
+        return self.title
+
+    def clean(self):
+
+        # Force slugs to be alphanumber lowercase with dashes
+        self.slug = self.slug.lower().replace(" ", "-")
+        self.slug = re.sub(r"[^a-z0-9\-]", "", self.slug)
+
+        # Check slug is unique for this path
+        # Prepare the queryset for siblings (excluding self if updating)
+        siblings_qs = Page.objects.filter(parent=self.parent)
+        if self.pk is not None:
+            siblings_qs = siblings_qs.exclude(pk=self.pk)
+
+        sibling_slugs = list(siblings_qs.values_list("slug", flat=True))
+        if self.slug in sibling_slugs:
+            raise ValidationError(
+                f'A slug with "{self.slug}" already exists ar this path'
+            )
+
+        # Check circular reference to self
+        if self.parent and self.pk and self.parent.pk == self.pk:
+            raise ValidationError("A page cannot be its own parent.")
+
+    @property
+    def path(self):
+        segments = []
+        node = self
+        while node is not None:
+            segments.append(node.slug)
+            node = node.parent
+        return "/".join(reversed(segments))
+
+    @property
+    def summary(self):
+        """
+        Generates a summary of headers from Markdown text as a nested HTML list of links.
+        """
+        header_pattern = re.compile(r"^(#{1,6})\s+(.*)", re.MULTILINE)
+        headers = []
+
+        for match in header_pattern.finditer(self.content):
+            hashes, title = match.groups()
+            level = len(hashes)
+            anchor = re.sub(r"[^\w\s-]", "", title).strip().lower()
+            anchor = re.sub(r"\s+", "-", anchor)
+            headers.append((level, title, anchor))
+
+        # Build nested HTML list
+        html = []
+        prev_level = 0
+        for level, title, anchor in headers:
+            while prev_level < level:
+                html.append("<ul>")
+                prev_level += 1
+            while prev_level > level:
+                html.append("</ul>")
+                prev_level -= 1
+            html.append(f'<li><a href="#{escape(anchor)}">{escape(title)}</a></li>')
+        while prev_level > 0:
+            html.append("</ul>")
+            prev_level -= 1
+
+        return "\n".join(html)
+
+    @classmethod
+    def list(cls, pages=None, parent=None, level=0):
+        """
+        Returns a flat list of pages with titles indented by hierarchy level.
+        Returns: list of tuple
+        """
+        if pages is None:
+            pages = list(cls.objects.all().select_related("parent"))
+
+        flat = []
+        children = [p for p in pages if p.parent_id == (parent.id if parent else None)]
+        children.sort(key=lambda p: p.priority)
+
+        for child in children:
+            indent = "\u2003" * level
+            display = f"{indent}{child.title} [/{child.path}]"
+            flat.append((child.id, display))
+            flat.extend(cls.list(pages, child, level + 1))
+
+        if parent is None and level == 0:
+            flat.insert(0, ("", "/"))
+
+        return flat
+
+    @classmethod
+    def tree(cls, user=None, pages=None, parent=None, depth=0):
+        """
+        Recursively builds a tree of pages as nested dicts,
+        ordered by priority, with 'path' property.
+        Returns: List[Dict]
+        """
+        if pages is None:
+            pages = list(cls.objects.all().select_related("parent"))
+
+        tree = []
+        children = [p for p in pages if p.parent_id == (parent.id if parent else None)]
+        children.sort(key=lambda p: p.priority)
+
+        for child in children:
+            node = {
+                "id": child.id,
+                "title": child.title,
+                "slug": child.slug,
+                "priority": child.priority,
+                "path": getattr(child, "path", None),
+                "depth": depth,
+                "children": cls.tree(user, pages, child, depth=depth + 1),
+            }
+            if child.user_access(user=user):
+                tree.append(node)
+        return tree
+
+    @classmethod
+    def get_by_path(cls, path: str, user):
+        """
+        Find an id for a given path
+        Returns: Page id or None
+        """
+        path = path.split("/")
+        parent = None
+        page = None
+        for slug in path:
+            try:
+                page = cls.objects.filter(slug=slug, parent=parent).first()
+            except cls.DoesNotExist:
+                return None
+            parent = page
+
+        if page and not page.user_access(user=user):
+            return None
+
+        return page if page else None
+
+    def user_access(self, user):
+
+        # Admin has full access
+        if user.profile.state.name == "Admin":
+            return True
+
+        # Editor has full access
+        if user.has_perm("evewiki.editor_access"):
+            return True
+
+        access = False
+
+        # If no groups or states assigned then yes
+        groups_empty = not self.groups.exists()
+        states_empty = not self.states.exists()
+        if groups_empty and states_empty:
+            access = True
+
+        # If any of the user's groups are allowed access
+        user_has_group = False
+        if any(
+            group in self.groups.all()
+            for group in user.groups.values_list("name", flat=True)
+        ):
+            access = True
+            user_has_group = True
+
+        # If the user's states is in the states list
+        user_has_state = False
+        if self.states.filter(name=user.profile.state.name).exists():
+            access = True
+            user_has_state = True
+
+        # If Page has both User needs both
+        if not groups_empty and not states_empty:
+            access = False
+            if user_has_group and user_has_state:
+                access = True
+
+        return access

evewiki/models/settings.py

@@ -0,0 +1,35 @@
+from django.db import models
+
+
+class Setting(models.Model):
+    """
+    Settings and feature flags.
+    """
+
+    hierarchy_max_display_depth = models.IntegerField(
+        default=10,
+        null=False,
+        help_text="Limit the depth of the tree for the hierarchy on the main display",
+    )
+
+    max_versions = models.IntegerField(
+        default=1000,
+        null=False,
+        help_text="No one has infinite disk space, a sensible limit which can be modified to clear down the history",
+    )
+
+    def get_settings():
+        """
+        Returns the Setting instance with the lowest id,
+        or a default Setting instance (not saved) if none exist.
+        """
+        setting = Setting.objects.order_by("id").first()
+        if setting is not None:
+            return setting
+
+        return Setting(
+            hierarchy_max_display_depth=Setting._meta.get_field(
+                "hierarchy_max_display_depth"
+            ).get_default(),
+            max_versions=Setting._meta.get_field("max_versions").get_default(),
+        )

evewiki/tasks.py

@@ -0,0 +1,12 @@
+"""Tasks."""
+
+from celery import shared_task
+
+from allianceauth.services.hooks import get_extension_logger
+
+logger = get_extension_logger(__name__)
+
+
+@shared_task
+def my_task():
+    """An example task."""

evewiki/templates/evewiki/base.html

@@ -0,0 +1,11 @@
+{% extends 'allianceauth/base-bs5.html' %}
+{% load i18n %}
+
+{% block page_title %}{% translate "wiki" %}{% endblock %}
+
+{% block content %}
+    <div class="allianceauth-evewiki-plugin">
+
+        {% block details %}{% endblock %}
+    </div>
+{% endblock %}

evewiki/templates/evewiki/help.html

@@ -0,0 +1,16 @@
+{% block details %}
+<h1>Wiki</h1>
+Use the `+` icon to add a new Page.<br />
+On the left; the menu/hierarchy will appear as pages are added.<br />
+On the right; details/options for a page will become available as you navigate the hierarchy.
+
+{% endblock %}
+
+{% block extra_javascript %}
+{% endblock %}
+
+{% block extra_css %}
+{% endblock %}
+
+{% block extra_script %}
+{% endblock %}