lino 25.8.3__py3-none-any.whl → 25.9.0__py3-none-any.whl

lino/modlib/publisher/config/publisher/page.pub.html

@@ -1,10 +1,10 @@
 {% extends "bootstrap5/base.html" %}
-
+{% block title %}{{site.title or site.verbose_name}}{% endblock %}
 {% block header %}
 <div class="container-fluid lino-bs-header">
   {% if ar -%}
     {% if isinstance(obj, rt.models.publisher.Page) -%}
-    {{obj.get_prev_link(ar)}} | {{obj.get_next_link(ar)}} |
+    {{obj.get_prev_link(ar)}} {{obj.get_next_link(ar)}} |
     {% endif -%}
     {% if dd.is_installed('react') %}
         {% set ar_react = obj.get_default_table().request(parent=ar, permalink_uris=True, renderer=dd.plugins.react.renderer) %}
@@ -18,9 +18,10 @@
         {{_("Home")}}
     {% endif -%}
     {% if site.kernel.editing_front_end.url_prefix -%}
-        <a href="/{{site.kernel.editing_front_end.url_prefix}}/">{{_("Admin")}}</a>
+       | <a href="/{{site.kernel.editing_front_end.url_prefix}}/">{{_("Admin")}}</a>
     {% endif -%}
     {% if len(site.languages) > 1 -%}
+      |
       {% for lang in site.languages -%}
         {% if lang.django_code == requested_language -%}
             {{lang.django_code}}
@@ -29,26 +30,91 @@
         {% endif -%}
       {% endfor -%}
     {% endif -%}
+    |
+    {% set user = ar.get_user() %}
+    {% if user.is_anonymous %}
+        <a href="" data-bs-toggle="modal" data-bs-target="#signinModal">
+            {{str(user)}}
+        </a>
+    {% else %}
+        {{str(user)}} <a href="/logout">{{_("Sign out")}}</a>
+    {% endif %}
     {%- if site.kernel.admin_ui -%}
         &mdash;
         <a href="{{site.kernel.admin_ui.build_plain_url()}}/">{{site.kernel.admin_ui.ui_label}}</a>
     {%- endif -%}
 {% endif -%}
 
+<div class="modal fade" id="signinModal" tabindex="-1" aria-labelledby="exampleModalLabel" aria-hidden="true">
+  <div class="modal-dialog modal-dialog-centered">
+    <div class="modal-content">
+      <div class="modal-header">
+        <h1 class="modal-title fs-5" id="exampleModalLabel">{{_("Sign in form")}}</h1>
+        <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+      </div>
+      <div class="modal-body">
+          <form id="signinForm" action="/login" method="post">
+              <div id="signinError" class="alert alert-danger d-none" role="alert">
+                  {{_("Incorrect username or password.")}}
+              </div>
+              <div class="mb-3">
+                  <label for="signinInputUsername" class="form-label">{{_("Username")}}</label>
+                  <input type="text" name="username" class="form-control" id="signinInputUsername" aria-describedby="usernameHelp" required="true">
+<!--                  <div id="usernameHelp" class="form-text">Enter your username.</div>-->
+              </div>
+              <div class="mb-3">
+                  <label for="signinInputPassword" class="form-label">{{_("Password")}}</label>
+                  <input type="password" name="password" class="form-control" id="signinInputPassword" required="true">
+              </div>
+          </form>
+      </div>
+      <div class="modal-footer">
+        <button form="signinForm" type="submit" class="btn btn-primary">{{_("Sign in")}}</button>
+      </div>
+    </div>
+  </div>
+</div>
+
+<script>
+    const form = document.getElementById("signinForm");
+    form.addEventListener("submit", (event) => {
+        event.preventDefault();
+        const formData = new FormData(form);
+        fetch(form.action, {
+            method: form.method,
+            body: formData
+        }).then((resp) => {
+            if (resp.status >= 400) {
+                const eel = document.getElementById("signinError");
+                eel.innerText = "Some unknown error occured, please contact site administrator";
+                eel.classList.remove("d-none")
+                return {success: false}
+            }
+            return resp.json()
+        }).then((resp) => {
+            if (resp.success) window.location.reload()
+            else {
+                const eel = document.getElementById("signinError");
+                eel.classList.remove("d-none")
+            }
+        })
+    });
+</script>
+
 </div>
 {% endblock %}
 
 {% block navbar %}
 <nav class="navbar navbar-expand-lg bg-body-tertiary">
   <div class="container-fluid">
-      {% set index_node, home_children = obj.home_and_children(ar) %}
-      <a class="navbar-brand" href="{{ar.obj2url(index_node)}}">{{ index_node.title }}</a>
+      {% set homepage, children = obj.home_and_children(ar) %}
+      <a class="navbar-brand" href="{{ar.obj2url(homepage)}}"><span class="pi pi-home"/></a>
       <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#bs-navbar-collapsible-content" aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
         <span class="navbar-toggler-icon"></span>
       </button>
       <div class="collapse navbar-collapse" id="bs-navbar-collapsible-content">
           <ul class="navbar-nav me-auto mb-2 mb-lg-0">
-              {% for child in home_children %}
+              {% for child in children %}
               <li class="nav-item">
                   <a class="nav-link" href="{{ar.obj2url(child)}}">{{str(child)}}</a>
               </li>
@@ -60,7 +126,7 @@
 {% endblock %}
 
 {% block content %}
-<div class="row-fluid">
+<div class="row-fluid ql-editor">
   {% for chunk in obj.as_page(ar) %}
     {{ chunk }}
   {% endfor %}

lino/modlib/publisher/fixtures/std.py

@@ -11,13 +11,26 @@ from lino.api import rt
 
 
 def objects():
+    Tree = rt.models.publisher.Tree
     Page = rt.models.publisher.Page
+    index = Tree(ref='index')
+    yield index
+    # lng2tree = dict()
+    # for lng in settings.SITE.languages:
+    #     with translation.override(lng.django_code):
+    #         kwargs = dict(language=lng.django_code, ref='index')
+    #         obj = Tree(**kwargs)
+    #         yield obj
+    #         lng2tree[lng.django_code] = obj
+
     for sp in SpecialPages.get_list_items():
         translated_from = None
         for lng in settings.SITE.languages:
             with translation.override(lng.django_code):
-                kwargs = dict(language=lng.django_code, special_page=sp)
+                # tree = lng2tree[lng.django_code]
+                kwargs = dict(publisher_tree=index, special_page=sp)
                 kwargs.update(publishing_state="published")
+                kwargs.update(language=lng.django_code)
                 # kwargs.update(sp.default_values)
                 if lng.suffix:
                     kwargs.update(translated_from=translated_from)

lino/modlib/publisher/mixins.py

@@ -12,9 +12,8 @@ from django import http
 # from lino.utils import buildurl
 from lino.utils.html import mark_safe
 from lino.modlib.printing.mixins import Printable
-from lino.modlib.users.mixins import PrivacyRelevant
 from lino.api import dd, rt, _
-from .choicelists import PublishingStates, PageFillers, SpecialPages
+from .choicelists import PublishingStates, SpecialPages
 # from .choicelists import PublisherViews, PublishingStates
 
 
@@ -46,9 +45,7 @@ class Publishable(Printable):
     publisher_template = "publisher/page.pub.html"
     _lino_publisher_location = None
 
-    root_page = dd.ForeignKey(
-        "publisher.Page", null=True, blank=True,
-        verbose_name=_("Root page"), related_name='+')
+    publisher_tree = dd.ForeignKey("publisher.Tree", null=True, blank=True)
 
     @dd.htmlbox()
     def full_page(self, ar):
@@ -83,18 +80,21 @@ class Publishable(Printable):
         # context.update(content=html)
         tpl = dd.plugins.jinja.renderer.jinja_env.get_template(self.publisher_template)
         return http.HttpResponse(
-            tpl.render(**context), content_type='text/html;charset="utf-8"'
-        )
+            tpl.render(**context), content_type='text/html;charset="utf-8"')
 
     def home_and_children(self, ar):
-        home = self.root_page
+        # home = self.publisher_tree.root_page
+        Page = rt.models.publisher.Page
+        qs = Page.objects.filter(
+            publisher_tree=self.publisher_tree, parent__isnull=True)
+        home = qs.first()
         if home is None:
             home = SpecialPages.home.get_object()
-        return home, rt.models.publisher.Page.objects.filter(parent=home)
+        return home, Page.objects.filter(parent=home)
         # return dv.model.objects.filter(models.Q(parent=index_node) | models.Q(ref='index'), language=language)
 
 
-class PublishableContent(Publishable, PrivacyRelevant):
+class PublishableContent(Publishable):
 
     class Meta:
         abstract = True
@@ -102,9 +102,12 @@ class PublishableContent(Publishable, PrivacyRelevant):
 
     language = dd.LanguageField()
     publishing_state = PublishingStates.field(default="draft")
-    filler = PageFillers.field(blank=True, null=True)
     main_image = dd.ForeignKey('uploads.Upload', blank=True,
                                null=True, verbose_name=_("Main image"))
+    translated_from = dd.ForeignKey(
+        "self", verbose_name=_("Translated from"),
+        null=True, blank=True,
+        related_name="translated_to")
 
     def get_print_language(self):
         return self.language
@@ -118,6 +121,32 @@ class PublishableContent(Publishable, PrivacyRelevant):
         super().on_duplicate(ar, master)
 
     def is_public(self):
-        if self.private:
+        if self.publisher_tree.private:
             return False
         return self.publishing_state.is_public
+
+    def get_publisher_response(self, ar):
+        if ar and ar.request and self.language != ar.request.LANGUAGE_CODE:
+            rqlang = ar.request.LANGUAGE_CODE
+            # tt = rt.models.pages.Translation.objects.filter(
+            #     parent=self, language=ar.request.LANGUAGE_CODE).first()
+            obj = None
+            if self.translated_from_id and self.translated_from.language == rqlang:
+                obj = self.translated_from
+            else:
+                sources = set([self.id])
+                p = self.translated_from
+                while p is not None:
+                    sources.add(p.id)
+                    p = p.translated_from
+                qs = self.__class__.objects.filter(
+                    language=rqlang, translated_from__in=sources)
+                obj = qs.first()
+                # obj = self.translated_to.filter(language=rqlang).first()
+            # print("20231027 redirect to translation", tt.language, ar.request.LANGUAGE_CODE)
+            if obj is not None:
+                # print("20231028", self.language, "!=", ar.request.LANGUAGE_CODE, tt)
+                ar.selected_rows = [obj]
+                url = ar.get_request_url()
+                return http.HttpResponseRedirect(url)
+        return super().get_publisher_response(ar)

lino/modlib/publisher/models.py

@@ -5,28 +5,57 @@
 from html import escape
 from lorem import get_paragraph
 from django.db import models
-from django.http import HttpResponseRedirect
 from django.conf import settings
 from django.utils import translation
-# from django.utils.translation import get_language
+from django.utils.translation import get_language
 from lino.api import dd, rt, _
 # from lino.utils import mti
-from lino.utils.html import E, tostring
+from lino.utils.html import E, tostring, format_html
+from lino.utils.instantiator import get_or_create
 # from lino.core.renderer import add_user_language
 # from lino.utils.mldbc.fields import LanguageField
-from lino.mixins import Hierarchical, Sequenced
+from lino.mixins import Hierarchical, Sequenced, Referrable
 # from lino.modlib.summaries.mixins import Summarized
 from lino.modlib.publisher.mixins import Publishable, PublishableContent
 from lino.modlib.comments.mixins import Commentable
 from lino.modlib.linod.choicelists import schedule_daily
 from lino.modlib.memo.mixins import Previewable
+from lino.modlib.users.mixins import PrivacyRelevant
 from lino_xl.lib.topics.mixins import Taggable
 
-from .choicelists import PublishingStates, PageFillers, SpecialPages
+from .choicelists import PublishingStates, SpecialPages
 from .mixins import Publishable
 from .ui import *
 
 
+class Tree(PrivacyRelevant, Referrable):
+    class Meta:
+        verbose_name = _("Tree")
+        verbose_name_plural = _("Trees")
+        abstract = dd.is_abstract_model(__name__, "Tree")
+        # unique_together = ["ref", "language"]
+
+    # ref = dd.CharField(_("Reference"), max_length=200, blank=True, null=True)
+    # root_page = dd.ForeignKey(
+    #     "publisher.Page", null=True, blank=True,
+    #     verbose_name=_("Root page"), related_name='+')
+
+    @dd.virtualfield(dd.ForeignKey(
+        'publisher.Page', verbose_name=_("Root page")))
+    def root_page(self, ar=None):
+        return self.get_root_page(get_language())
+
+    def get_root_page(self, language):
+        if self.pk is not None:
+            qs = Page.objects.filter(
+                parent__isnull=True, publisher_tree=self, language=language)
+            return qs.first()
+            # try:
+            #     return Page.objects.get(parent=None, publisher_tree=self)
+            # except Page.DoesNotExist:
+            #     return None
+
+
 class Page(
     Hierarchical, Sequenced, Previewable, Commentable, PublishableContent,
     Taggable
@@ -39,31 +68,21 @@ class Page(
         #     unique_together = ["group", "ref", "language"]
         # else:
         #     unique_together = ["ref", "language"]
-        unique_together = ["ref", "language"]
+        # unique_together = ["publisher_tree", "language"]
 
     memo_command = "page"
     allow_cascaded_delete = ['parent']
 
-    ref = dd.CharField(_("Reference"), max_length=200, blank=True, null=True)
     title = dd.CharField(_("Title"), max_length=250, blank=True)
     child_node_depth = models.IntegerField(default=1)
-    # page_type = PageTypes.field(blank=True, null=True)
     special_page = SpecialPages.field(blank=True)
 
-    translated_from = dd.ForeignKey(
-        "publisher.Page",
-        verbose_name=_("Translated from"),
-        null=True,
-        blank=True,
-        related_name="translated_to",
-    )
-
     previous_page = dd.ForeignKey(
         "self", null=True, blank=True, editable=False,
         verbose_name=_("Previous page"), related_name='+')
 
     def __str__(self):
-        return self.title or self.ref or super().__str__()
+        return self.title or super().__str__()
 
     # def on_create(self, ar):
     #     self.page_type = self.get_page_type()
@@ -81,11 +100,7 @@ class Page(
         return ""
 
     def is_public(self):
-        return not self.private
-
-    # def full_clean(self):
-    #     self.page_type = self.mti_child().get_page_type()
-    #     super().full_clean()
+        return not self.publisher_tree.private
 
     def mti_child(self):
         #     if self.page_type:
@@ -104,7 +119,7 @@ class Page(
     # def as_story_item(self, ar, **kwargs):
     #     return "".join(self.as_page(ar, **kwargs))
 
-    def as_paragraph(self, ar):
+    def old_as_paragraph(self, ar):
         title = E.b(escape(self.title))
         url = ar.obj2url(self)
         if url is not None:
@@ -115,6 +130,17 @@ class Page(
         item = E.li(title, body)
         return tostring(item)
 
+    def as_paragraph(self, ar):
+        title = format_html("<b>{}</b>", self.title)
+        if (url := ar.obj2url(self)) is not None:
+            title = format_html(
+                '<a href="{url}" style="text-decoration:none;color:black;">{title}</a>',
+                title=title, url=url)
+        body = self.get_body_parsed(ar, short=True)
+        if body:
+            return format_html("{} &mdash; {}", title, body)
+        return title
+
     def toc_html(self, ar, max_depth=1):
         def li(obj):
             # return "<li>{}</li>".format(obj.memo2html(ar, str(obj)))
@@ -131,8 +157,7 @@ class Page(
             if len(breadcrumbs) > 1:
                 breadcrumbs = [
                     """<a href="{0}">{1}</a>""".format(
-                        ar.obj2url(p.mti_child()), p.title
-                    )
+                        ar.obj2url(p.mti_child()), p.title)
                     for p in breadcrumbs[:-1]
                 ]
                 yield "<p>{}</p>".format(" &raquo; ".join(breadcrumbs))
@@ -168,7 +193,7 @@ class Page(
 
         # if display_mode in ("detail", "story"):
         if display_mode == "detail":
-            if hlevel == 1 and not dd.plugins.memo.use_markup and self.ref != 'index':
+            if hlevel == 1 and not dd.plugins.memo.use_markup and self.parent_id:
                 yield self.toc_html(ar)
 
             if hlevel == 1 and self.main_image:
@@ -185,12 +210,11 @@ class Page(
             # yield self.body_full_preview
             yield self.get_body_parsed(ar, short=False)
 
-            if self.filler:
-                yield "\n\n"
-                if hlevel == 1:
-                    yield self.filler.get_dynamic_story(ar, self)
-                else:
-                    yield self.filler.get_dynamic_paragraph(ar, self)
+            # if self.filler:
+            #     if hlevel == 1:
+            #         yield self.filler.get_dynamic_story(ar, self)
+            #     else:
+            #         yield self.filler.get_dynamic_paragraph(ar, self)
 
             # if dd.plugins.memo.use_markup:
             #     return
@@ -234,17 +258,17 @@ class Page(
         return "".join(ar.row_as_page(self))
 
     def full_clean(self):
-        if self.root_page is None and self.parent is not None:
-            self.root_page = self.parent.root_page
+        if self.publisher_tree is None and self.parent is not None:
+            self.publisher_tree = self.parent.publisher_tree
         super().full_clean()
 
-    def update_page(self, prev, root):
+    def update_page(self, prev, tree):
         save = False
         if self.previous_page != prev:
             self.previous_page = prev
             save = True
-        if self.root_page != root:
-            self.root_page = root
+        if self.publisher_tree != tree:
+            self.publisher_tree = tree
             save = True
         if save:
             self.save()
@@ -285,40 +309,14 @@ class Page(
 
     def get_absolute_url(self, **kwargs):
         parts = []
-        if self.group is not None:
-            if self.group.ref is not None:
-                parts.append(self.group.ref)
-        if self.ref:
-            if self.ref != "index":
-                parts.append(self.group.ref)
+        # if self.group is not None:
+        #     if self.group.ref is not None:
+        #         parts.append(self.group.ref)
+        if self.publisher_tree.ref:
+            if self.publisher_tree.ref != "index":
+                parts.append(self.publisher_tree.ref)
         return dd.plugins.publisher.build_plain_url(*parts, **kwargs)
 
-    def get_publisher_response(self, ar):
-        if ar and ar.request and self.language != ar.request.LANGUAGE_CODE:
-            rqlang = ar.request.LANGUAGE_CODE
-            # tt = rt.models.pages.Translation.objects.filter(
-            #     parent=self, language=ar.request.LANGUAGE_CODE).first()
-            obj = None
-            if self.translated_from_id and self.translated_from.language == rqlang:
-                obj = self.translated_from
-            else:
-                sources = set([self.id])
-                p = self.translated_from
-                while p is not None:
-                    sources.add(p.id)
-                    p = p.translated_from
-                qs = self.__class__.objects.filter(
-                    language=rqlang, translated_from__in=sources)
-                obj = qs.first()
-                # obj = self.translated_to.filter(language=rqlang).first()
-            # print("20231027 redirect to translation", tt.language, ar.request.LANGUAGE_CODE)
-            if obj is not None:
-                # print("20231028", self.language, "!=", ar.request.LANGUAGE_CODE, tt)
-                ar.selected_rows = [obj]
-                url = ar.get_request_url()
-                return HttpResponseRedirect(url)
-        return super().get_publisher_response(ar)
-
 
 if dd.plugins.memo.use_markup:
     dd.update_field(Page, "body", format="plain")
@@ -337,13 +335,15 @@ def update_publisher_pages(ar):
     for root in Page.objects.filter(parent__isnull=True):
         prev = None
         for obj in root.walk():
-            obj.update_page(prev, root)
+            obj.update_page(prev, root.publisher_tree)
             prev = obj
             count += 1
     ar.logger.info("%d pages have been updated.", count)
 
 
 def make_demo_pages(pages_desc, root_ref, group=None):
+    Tree = rt.models.publisher.Tree
+    tree = get_or_create(Tree, ref=root_ref, group=group)
     # Translation = rt.models.pages.Translation
     # for lc in settings.SITE.LANGUAGE_CHOICES:
     #     language = lc[0]
@@ -365,19 +365,18 @@ def make_demo_pages(pages_desc, root_ref, group=None):
                     if len(page) != 3:
                         raise Exception(f"Oops {page}")
                     title, body, children = page
-                    kwargs = dict(title=title, group=group)
+                    # kwargs = dict(title=title, group=group)
+                    kwargs = dict(title=title, publisher_tree=tree,
+                                  language=lng.django_code)
                     if body is None:
                         kwargs.update(body=get_paragraph())
                     else:
                         kwargs.update(body=body)
-                    if parent is None:
-                        kwargs.update(ref=root_ref)
-                    else:
+                    if parent is not None:
                         kwargs.update(parent=parent)
                     if lng.suffix:
                         kwargs.update(
                             translated_from=parent_nodes[counter[None]])
-                    kwargs.update(language=lng.django_code)
                     if dd.is_installed("publisher"):
                         kwargs.update(publishing_state='published')
                     obj = Page(**kwargs)

lino/modlib/publisher/renderer.py

@@ -1,29 +1,37 @@
 # -*- coding: UTF-8 -*-
-# Copyright 2023 Rumma & Ko Ltd
+# Copyright 2023-2025 Rumma & Ko Ltd
 # License: GNU Affero General Public License v3 (see file COPYING for details)
 
-from lino import logger
 from lino.core.renderer import add_user_language
-from lino.modlib.bootstrap5.renderer import Renderer
+from lino.core.renderer import HtmlRenderer
 
+from lino.modlib.publisher.mixins import Publishable
+
+
+class Renderer(HtmlRenderer):
+
+    tableattrs = {"class": "table table-hover table-striped table-condensed"}
+    cellattrs = dict(align="left", valign="top")
+
+    can_auth = False
 
-class Renderer(Renderer):
     def __init__(self, front_end):
         super().__init__(front_end)
         dr = front_end.site.kernel.default_renderer
         for k in ("row_action_button", "get_detail_url"):
             setattr(self, k, getattr(dr, k))
 
-    def get_request_url(self, ar, *args, **kwargs):
-        obj = ar.selected_rows[0]
-        return self.obj2url(ar, obj, **kwargs)
-        # return obj.publisher_url(ar, **kwargs)
-
     def obj2url(self, ar, obj, **kwargs):
+        if not isinstance(obj, Publishable):
+            return super().obj2url(ar, obj, **kwargs)
         # if ar.actor is None or not isinstance(obj, ar.actor.model):
         add_user_language(kwargs, ar)
-        if isinstance(obj, self.front_end.site.models.publisher.Page) and obj.ref == 'index':
-            return self.front_end.buildurl(**kwargs)
+        # if isinstance(obj, self.front_end.site.models.publisher.Page) and obj.ref == 'index':
+        if isinstance(obj, self.front_end.site.models.publisher.Page) and obj.parent is None:
+            if obj.publisher_tree.ref is not None:
+                if obj.publisher_tree.ref == 'index':
+                    return self.front_end.buildurl(**kwargs)
+                return self.front_end.buildurl(obj.publisher_tree.ref, **kwargs)
         # if obj.ref:
         #     return self.front_end.buildurl(obj.ref, **kwargs)
         loc = obj.__class__._lino_publisher_location
@@ -43,4 +51,12 @@ class Renderer(Renderer):
             # publisher view,
             return None
         return self.front_end.site.kernel.default_renderer.obj2url(ar, obj, **kwargs)
-        # return super().obj2url(ar, obj, **kwargs)
+
+    def get_home_url(self, ar, *args, **kw):
+        add_user_language(kw, ar)
+        return self.front_end.build_plain_url(*args, **kw)
+
+    def get_request_url(self, ar, *args, **kwargs):
+        obj = ar.selected_rows[0]
+        return self.obj2url(ar, obj, **kwargs)
+        # return obj.publisher_url(ar, **kwargs)