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

lino/modlib/publisher/models.py

@@ -1,58 +1,64 @@
 # -*- coding: UTF-8 -*-
-# Copyright 2012-2024 Rumma & Ko Ltd
+# Copyright 2012-2025 Rumma & Ko Ltd
 # License: GNU Affero General Public License v3 (see file COPYING for details)
 
 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 pgettext_lazy
-
-from django.utils import translation
-from django.conf import settings
-
-try:
-    from lorem import get_paragraph
-except ImportError:
-    lorem = None
-
-# from django.utils.translation import get_language
-from django.utils.html import mark_safe
-
+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.core import constants
+# from lino.utils import mti
+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 import mixins
+# from lino.utils.mldbc.fields import LanguageField
 from lino.mixins import Hierarchical, Sequenced, Referrable
-
 # from lino.modlib.summaries.mixins import Summarized
-from lino.modlib.office.roles import OfficeUser
 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.mixins.polymorphic import Polymorphic
-from lino_xl.lib.topics.mixins import Taggable
 from lino.modlib.users.mixins import PrivacyRelevant
-# from .utils import render_node
+from lino_xl.lib.topics.mixins import Taggable
 
-from lino.api import rt, dd
-from .choicelists import PublishingStates, PageFillers, SpecialPages
+from .choicelists import PublishingStates, SpecialPages
 from .mixins import Publishable
 from .ui import *
 
-# class Node(Referrable, Hierarchical, Sequenced, Previewable, Publishable, Commentable):
-# Polymorphic,
+
+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  # PrivacyRelevant
+    Taggable
 ):
     class Meta:
         verbose_name = _("Page")
@@ -62,30 +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, verbose_name=_("Previous page")
-    )
+        "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()
@@ -102,22 +99,27 @@ class Page(
     def get_node_info(self, ar):
         return ""
 
-    # def full_clean(self):
-    #     self.page_type = self.mti_child().get_page_type()
-    #     super().full_clean()
+    def is_public(self):
+        return not self.publisher_tree.private
 
     def mti_child(self):
         #     if self.page_type:
         #         return mti.get_child(self, self.page_type.nodes_table.model) or self
         return self
 
+    def walk(self):
+        yield self
+        for c in self.children.all():
+            for i in c.walk():
+                yield i
+
     # def as_summary_row(self, ar, **kwargs):
     #     return ar.obj2htmls(self, **kwargs)
 
     # 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:
@@ -128,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)))
@@ -144,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))
@@ -181,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:
@@ -198,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
@@ -246,77 +257,20 @@ class Page(
             return
         return "".join(ar.row_as_page(self))
 
-    # @classmethod
-    # def get_publisher_pages(cls, pv):
-    #     root = cls.objects.get(parent__isnull=True)
-
-    # def compute_summary_values(self):
-    #     def walk(node, prev=None):
-    #         if node.page_type is not None:
-    #             node.set_prev(prev)
-    #             prev = node
-    #         for c in node.children.all():
-    #             prev = walk(c, prev)
-    #         return prev
-    #     root = self.get_ancestor()
-    #     last = walk(root)
-    #     root.set_prev(last)
-
-    # from pprint import pprint
-    # pprint(self.whole_tree())
-
-    # def get_sidebar_caption(self):
-    #     if self.title:
-    #         return self.title
-    #     if self.ref:
-    #         return self.ref
-    #     return str(self.id)
-    #
-    #     #~ if self.ref or self.parent:
-    #         #~ return self.ref
-    #     #~ return unicode(_('Home'))
-
-    # def get_sidebar_item(self, request, other):
-    #     kw = dict()
-    #     add_user_language(kw, request)
-    #     url = self.get_absolute_url(**kw)
-    #     a = E.a(self.get_sidebar_caption(), href=url)
-    #     if self == other:
-    #         return E.li(a, **{'class':'active'})
-    #     return E.li(a)
-    #
-    # def get_sidebar_html(self, request):
-    #     items = []
-    #     #~ loop over top-level nodes
-    #     for n in self.__class__.objects.filter(parent__isnull=True).order_by('seqno'):
-    #         #~ items += [li for li in n.get_sidebar_items(request,self)]
-    #         items.append(n.get_sidebar_item(request, self))
-    #         if self.is_parented(n):
-    #             children = []
-    #             for ch in n.children.order_by('seqno'):
-    #                 children.append(ch.get_sidebar_item(request, self))
-    #             if len(children):
-    #                 items.append(E.ul(*children, **{'class':'nav nav-list'}))
-    #
-    #     e = E.ul(*items, **{'class':'nav nav-list'})
-    #     return tostring_pretty(e)
-    #
-    # def get_sidebar_menu(self, request):
-    #     qs = self.__class__.objects.filter(parent__isnull=True, language=get_language())
-    #     #~ qs = self.children.all()
-    #     yield ('/', 'index', str(_('Home')))
-    #         #~ yield ('/downloads/', 'downloads', 'Downloads')
-    #     #~ yield ('/about', 'about', 'About')
-    #     #~ if qs is not None:
-    #     for obj in qs.order_by("seqno"):
-    #         if obj.ref and obj.title:
-    #             yield ('/' + obj.ref, obj.ref, obj.title)
-    #         #~ else:
-    #             #~ yield ('/','index',obj.title)
-
-    def set_previous_page(self, prev):
+    def full_clean(self):
+        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, tree):
+        save = False
         if self.previous_page != prev:
             self.previous_page = prev
+            save = True
+        if self.publisher_tree != tree:
+            self.publisher_tree = tree
+            save = True
+        if save:
             self.save()
 
     def get_prev_link(self, ar, text="◄"):  # "◄" 0x25c4
@@ -339,18 +293,6 @@ class Page(
         # url = ar.obj2url(next_node.mti_child())
         # return """<a href="{}">{}</a>""".format(url, text)
 
-    @classmethod
-    def get_publisher_pages(cls):
-        def walk(page, prev=None):
-            yield page
-            for c in page.children.all():
-                for i in walk(c):
-                    yield i
-
-        for root in cls.objects.filter(parent__isnull=True):
-            for i in walk(root):
-                yield i
-
     @classmethod
     def get_dashboard_objects(cls, user):
         # print("20210114 get_dashboard_objects()", get_language())
@@ -367,80 +309,41 @@ 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")
 
-# class Translation(dd.Model):
-#     class Meta:
-#         verbose_name = _("Page translation")
-#         verbose_name_plural = _("Page translations")
-#
-#     parent = dd.ForeignKey(
-#         'publisher.Page',
-#         verbose_name=_("Translated from..."),
-#         related_name='translated_from')
-#     child = dd.ForeignKey(
-#         'publisher.Page',
-#         blank=True, null=True,
-#         verbose_name=_("Translated to..."),
-#         related_name='translated_to')
-#     language = dd.LanguageField()
-
 
 @schedule_daily()
 def update_publisher_pages(ar):
     # BaseRequest(parent=ar).run(settings.SITE.site_config.check_all_summaries)
     # rt.login().run(settings.SITE.site_config.check_all_summaries)
-    Page = settings.SITE.models.publisher.Page
+    Page = rt.models.publisher.Page
     # for pv in PublisherViews.get_list_items():
     # for m in rt.models_by_base(Published, toplevel_only=True):
-    prev = None
     count = 0
     ar.logger.info("Update publisher pages...")
 
-    for obj in Page.get_publisher_pages():
-        obj.set_previous_page(prev)
-        prev = obj
-        count += 1
+    for root in Page.objects.filter(parent__isnull=True):
+        prev = None
+        for obj in root.walk():
+            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):
+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]
@@ -451,31 +354,32 @@ def make_demo_pages(pages_desc):
     for lng in settings.SITE.languages:
         counter = {None: 0}
         # count = 0
-        home_page = Page.objects.get(
-            special_page=SpecialPages.home, language=lng.django_code)
+        # home_page = Page.objects.get(
+        #     special_page=SpecialPages.home, language=lng.django_code)
 
         with translation.override(lng.django_code):
 
-            def make_pages(pages, parent=None):
+            # def make_pages(pages, parent=None):
+            def make_pages(pages, parent=None, root_ref=None):
                 for page in pages:
                     if len(page) != 3:
                         raise Exception(f"Oops {page}")
                     title, body, children = page
-                    kwargs = dict(title=title)
+                    # 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='index')
-                        continue  # home page is created by SpecialPages
+                    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(parent=parent, **kwargs)
+                    obj = Page(**kwargs)
                     yield obj
                     if not lng.suffix:
                         parent_nodes.append(obj)
@@ -483,4 +387,5 @@ def make_demo_pages(pages_desc):
                     # print("20230324", title, kwargs)
                     yield make_pages(children, obj)
 
-            yield make_pages(pages_desc, parent=home_page)
+            # yield make_pages(pages_desc, parent=home_page)
+            yield make_pages(pages_desc, None, root_ref)

lino/modlib/publisher/renderer.py

@@ -1,31 +1,43 @@
 # -*- 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.bootstrap3.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':
+        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
         if loc is None:
             # logger.warning("No location for %s", obj.__class__)
             return None
-        add_user_language(kwargs, ar)
         return self.front_end.buildurl(loc, str(obj.pk), **kwargs)
         # for i in PublisherViews.get_list_items():
         #     if isinstance(obj, i.table_class.model):
@@ -39,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)