Add slots to components

Author: fsbraun

djangocms_frontend/contrib/component/cms_plugins.py

@@ -2,6 +2,9 @@
 
 from .models import components
 
-for _, plugin in components._registry.values():
+for _, plugin, slot_plugins in components._registry.values():
     globals()[plugin.__name__] = plugin
     plugin_pool.register_plugin(plugin)
+    for slot_plugin in slot_plugins:
+        globals()[slot_plugin.__name__] = slot_plugin
+        plugin_pool.register_plugin(slot_plugin)

djangocms_frontend/contrib/component/components.py

@@ -1,5 +1,7 @@
 import importlib
 
+from cms.api import add_plugin
+from cms.plugin_base import CMSPluginBase
 from django import forms
 from django.utils.module_loading import autodiscover_modules
 from django.utils.translation import gettext_lazy as _
@@ -22,6 +24,9 @@ def _get_mixin_classes(mixins: list, suffix: str = "") -> list[type]:
 
 class CMSFrontendComponent(forms.Form):
     """Base class for frontend components:"""
+
+    slot_template = "djangocms_frontend/slot.html"
+
     @classmethod
     def admin_form_factory(cls, **kwargs) -> type:
         mixins = getattr(cls._component_meta, "mixins", [])
@@ -48,6 +53,13 @@ def admin_form_factory(cls, **kwargs) -> type:
             },
         )
 
+    @classmethod
+    def get_slot_plugins(cls) -> dict[str:str]:
+        slots : list[tuple[str, str]] = getattr(cls._component_meta, "slots", [])
+        return {
+            f"{cls.__name__}{slot[0].capitalize()}Plugin": slot[1] for slot in slots
+        }
+
     @classmethod
     def plugin_model_factory(cls) -> type:
         model_class = type(
@@ -72,6 +84,7 @@ def plugin_model_factory(cls) -> type:
     @classmethod
     def plugin_factory(cls) -> type:
         mixins = getattr(cls._component_meta, "mixins", [])
+        slots = cls.get_slot_plugins()
         mixins = _get_mixin_classes(mixins)
 
         return type(
@@ -85,14 +98,35 @@ def plugin_factory(cls) -> type:
                 "module": getattr(cls._component_meta, "module", _("Component")),
                 "model": cls.plugin_model_factory(),
                 "form": cls.admin_form_factory(),
-                "allow_children": getattr(cls._component_meta, "allow_children", False),
-                "child_classes": getattr(cls._component_meta, "child_classes", []),
+                "allow_children": getattr(cls._component_meta, "allow_children", False) or slots,
+                "child_classes": getattr(cls._component_meta, "child_classes", []) + list(slots.keys()),
                 "render_template": getattr(cls._component_meta, "render_template", CMSUIPlugin.render_template),
                 "fieldsets": getattr(cls, "fieldsets", cls._generate_fieldset()),
                 "change_form_template": "djangocms_frontend/admin/base.html",
+                "slots": slots,
+                "render": cls.render_slot_context,
+                "save_model": cls.save_model,
             },
         )
 
+    @classmethod
+    def slot_plugin_factory(cls) -> list[type]:
+        slots = cls.get_slot_plugins()
+        return [
+            type(
+                slot,
+                (CMSPluginBase,),
+                {
+                    "name": slot_name,
+                    "module": getattr(cls._component_meta, "module", _("Component")),
+                    "allow_children": True,
+                    "parent_classes": cls.__name__ + "Plugin",
+                    "render_template": cls.slot_template,
+                },
+            )
+            for slot, slot_name in slots.items()
+        ]
+
     @classmethod
     @property
     def _component_meta(cls) -> type | None:
@@ -107,13 +141,27 @@ def _generate_fieldset(cls):
     def get_short_description(self) -> str:
         return ""
 
+    def save_model(self, request, obj, form, change):
+        super(CMSUIPlugin, self).save_model(request, obj, form, change)
+        if not change:
+            for slot in self.slots.keys():
+                add_plugin(obj.placeholder, slot, obj.language, target=obj)
+
+    def render_slot_context(self, context, instance, placeholder):
+        context["instance"] = instance
+        return context
+
 
 class Components:
     _registry: dict = {}
     _discovered: bool = False
 
     def register(self, component):
-        self._registry[component.__name__] = (component.plugin_model_factory(), component.plugin_factory())
+        self._registry[component.__name__] = (
+            component.plugin_model_factory(),
+            component.plugin_factory(),
+            component.slot_plugin_factory(),
+        )
         return component
 
 

djangocms_frontend/contrib/component/models.py

@@ -3,5 +3,5 @@
 # Register all component models for Django
 # Component models are unmanaged and do not create migrations
 
-for model, _ in components._registry.values():
+for model, *_ in components._registry.values():
     globals()[model.__name__] = model

djangocms_frontend/templatetags/frontend.py

@@ -1,7 +1,7 @@
 import json
 
 from classytags.arguments import Argument, MultiKeywordArgument
-from classytags.core import Options
+from classytags.core import Options, Tag
 from classytags.helpers import AsTag
 from cms.templatetags.cms_tags import render_plugin
 from django import template
@@ -113,11 +113,35 @@ def user_message(context, message):
     return {}
 
 
+@register.tag
+class SlotTag(Tag):
+    name = "slot"
+    options = Options(
+        Argument("slot_name", required=True),
+        blocks=[("endslot", "nodelist")],
+    )
+
+    def render_tag(self, context, slot_name, nodelist):
+        return ""
+
+
 class DummyPlugin:
-    def __init__(self, nodelist):
+    def __init__(self, nodelist, plugin_type, slot_name: str | None = None) -> "DummyPlugin":
         self.nodelist = nodelist
+        self.plugin_type = (f"{plugin_type}{slot_name.capitalize()}Plugin") if slot_name else "DummyPlugin"
+        if slot_name is None:
+            self.parse_slots(nodelist, plugin_type)
         super().__init__()
 
+    def parse_slots(self, nodelist, plugin_type):
+        self.slots = [self]
+        for node in nodelist:
+            if isinstance(node, SlotTag):
+                self.slots.append(DummyPlugin(node.nodelist, plugin_type, node.kwargs.get("slot_name")))
+
+    def get_instances(self):
+        return self.slots
+
 
 class Plugin(AsTag):
     name = "plugin"
@@ -134,9 +158,9 @@ def message(self, message):
 
     def get_value(self, context, name, kwargs, nodelist):
         if name not in plugin_tag_pool:
-            return self.message(f"Plugin \"{name}\" not found in pool for plugins usable with {{% plugin %}}")
+            return self.message(f'Plugin "{name}" not found in pool for plugins usable with {{% plugin %}}')
         context.push()
-        instance = (plugin_tag_pool[name]["defaults"])
+        instance = plugin_tag_pool[name]["defaults"]
         plugin_class = plugin_tag_pool[name]["class"]
         if issubclass(plugin_class, CMSUIPlugin):
             #
@@ -148,29 +172,70 @@ def get_value(self, context, name, kwargs, nodelist):
         # Call render method of plugin
         context = plugin_class().render(context, context["instance"], None)
         # Replace inner plugins with the nodelist, i.e. the content within the plugin tag
-        context["instance"].child_plugin_instances = [DummyPlugin(nodelist)]
+        context["instance"].child_plugin_instances = DummyPlugin(
+            nodelist, context["instance"].plugin_type
+        ).get_instances()
         # ... and redner
         result = plugin_tag_pool[name]["template"].render(context.flatten())
         context.pop()
         return result
 
 
-register.tag(Plugin.name, Plugin)
+class RenderChildPluginsTag(Tag):
+    """
+    This template node is used to render child plugins of a plugin
+    instance. It allows for selection of certain plugin types.
 
+    e.g.: {% childplugins instance %}
 
-@register.simple_tag(takes_context=True)
-def render_child_plugins(context, instance, plugin_type=None):
-    """Renders the child plugins of a plugin instance"""
-    if not instance.child_plugin_instances:
-        return ""
-    context.push()
-    context["parent"] = instance
-    result = ""
-    for child in instance.child_plugin_instances:
-        if isinstance(child, DummyPlugin):
-            result += child.nodelist.render(context)
-        else:
-            if plugin_type and child.plugin_type == plugin_type:
-                result += render_plugin(context, child)
-    context.pop()
-    return result if result else getattr(instance, "simple_content", "")
+    {% childplugins instance "LinkPlugin" %}
+
+    {% placeholder "footer" inherit or %}
+        <a href="/about/">About us</a>
+    {% endplaceholder %}
+
+    Keyword arguments:
+    name -- the name of the placeholder
+    inherit -- optional argument which if given will result in inheriting
+        the content of the placeholder with the same name on parent pages
+    or -- optional argument which if given will make the template tag a block
+        tag whose content is shown if the placeholder is empty
+    """
+
+    name = "childplugins"
+    options = Options(
+        # PlaceholderOptions parses until the "endchildplugins" tag is found if
+        # the "or" option is given
+        Argument("instance", required=True),
+        Argument("plugin_type", required=False),
+        blocks=[("endchildplugins", "nodelist")],
+    )
+
+    def render_tag(self, context, instance, plugin_type, nodelist):
+        context.push()
+        context["parent"] = instance
+        content = ""
+        if plugin_type and not plugin_type.endswith("Plugin"):
+            plugin_type = f"{instance.__class__.__name__}{plugin_type.capitalize()}Plugin"
+        for node in nodelist:
+            print(type(node), getattr(node, "args", None), getattr(node, "kwargs", None), plugin_type)
+        for child in instance.child_plugin_instances:
+            if not plugin_type or child.plugin_type == plugin_type:
+                if isinstance(child, DummyPlugin):
+                    content += child.nodelist.render(context)
+                else:
+                    for grand_child in child.child_plugin_instances:
+                        content += render_plugin(context, grand_child)
+        content = content or getattr(instance, "simple_content", "")
+        print(f"{content.strip()=}")
+
+        if not content.strip() and nodelist:
+            # "or" parameter given
+            return nodelist.render(context)
+
+        context.pop()
+        return content
+
+
+register.tag(Plugin.name, Plugin)
+register.tag(RenderChildPluginsTag.name, RenderChildPluginsTag)

tests/test_plugin_tag.py

@@ -74,7 +74,7 @@ def test_complex_tags(self):
 
         self.assertInHTML(expected_result, result)
 
-    def test_link_component(self):
+    def test_link_plugin(self):
         template = django_engine.from_string("""{% load frontend %}
             {% plugin "link" name="Click" external_link="/" link_type="btn" link_context="primary" link_outline=False %}
                 Click me!
@@ -88,7 +88,7 @@ def test_link_component(self):
         self.assertInHTML(expected_result, result)
 
     @override_settings(DEBUG=True)
-    def test_non_existing_component(self):
+    def test_non_existing_plugin(self):
         template = django_engine.from_string("""{% load frontend %}
             {% plugin "nonexisting" %}
                 This should not be rendered.
@@ -100,7 +100,7 @@ def test_non_existing_component(self):
 
         self.assertEqual(expected_result.strip(), result.strip())
 
-    def test_non_frontend_component(self):
+    def test_non_frontend_plugin(self):
         template = django_engine.from_string("""{% load frontend %}
             {% plugin "text" body="<p>my text</p>" %}
                 This should not be rendered.