tessl/pypi-django-cms

Lean enterprise content management powered by Django.

—

Pending

Overview

Eval results

Files

Plugin System

Name: tessl/pypi-django-cms
Author: tessl

Django CMS features an extensible plugin architecture that allows modular content components to be inserted into placeholders, with support for custom plugin development, nested plugins, and comprehensive plugin management.

Capabilities

Plugin Management

Add, configure, and manage plugins within placeholders with full control over positioning and hierarchy.

def add_plugin(
    placeholder,
    plugin_type,
    language, 
    position="last-child",
    target=None,
    **data
):
    """
    Add a plugin to a placeholder.
    
    Args:
        placeholder (Placeholder): Target placeholder
        plugin_type (str): Plugin type identifier
        language (str): Language code
        position (str): Position relative to target ("first-child", "last-child", "left", "right")
        target (CMSPlugin, optional): Reference plugin for positioning
        **data: Plugin-specific configuration data
        
    Returns:
        CMSPlugin: Created plugin instance
    """

Plugin Base Classes

Foundation classes for developing custom plugins with admin integration, rendering, and configuration.

class CMSPluginBase:
    """
    Base class for all CMS plugins.
    
    Attributes:
        model: Plugin model class
        name: Human-readable plugin name
        render_template: Template for frontend rendering
        admin_preview: Show preview in admin
        allow_children: Allow child plugins
        child_classes: Allowed child plugin types
        parent_classes: Allowed parent plugin types
        require_parent: Require parent plugin
        text_enabled: Enable text plugin features
        cache: Enable plugin caching
    """
    
    def render(self, context, instance, placeholder):
        """Render plugin content."""
        
    def get_render_template(self, context, instance, placeholder):
        """Get template for rendering."""
        
    def get_form(self, request, obj=None, **kwargs):
        """Get admin form for plugin."""
        
    def save_model(self, request, obj, form, change):
        """Save plugin instance."""

class CMSPluginBaseMetaclass:
    """Metaclass for automatic plugin registration."""

class PluginMenuItem:
    """Configuration for plugin menu items."""

Plugin Models

Core models for plugin data storage and hierarchy management.

class CMSPlugin:
    """
    Base model for all plugin instances.
    
    Attributes:
        placeholder: Associated placeholder
        parent: Parent plugin for nesting
        position: Position within placeholder
        language: Language code
        plugin_type: Plugin type identifier
        creation_date: Creation timestamp
        changed_date: Last modification timestamp
        numchild: Number of child plugins
        depth: Nesting depth level
        path: Tree path for hierarchy
    """
    
    def get_plugin_class(self):
        """Get plugin class instance."""
        
    def get_plugin_instance(self, admin=None):
        """Get downcasted plugin instance."""
        
    def get_bound_plugin(self):
        """Get bound plugin with class."""
        
    def copy_relations(self, old_instance):
        """Copy plugin relationships."""

class AliasPlugin:
    """Plugin for referencing other plugins."""
    
class PlaceholderPlugin: 
    """Plugin containing nested placeholder."""

Plugin Pool Management

Global registry for plugin types and plugin discovery.

class PluginPool:
    """Global plugin registry and management."""
    
    def register_plugin(self, plugin_class):
        """Register a plugin class."""
        
    def unregister_plugin(self, plugin_class):
        """Unregister a plugin class."""
        
    def get_all_plugins(self, placeholder=None, page=None, setting_key="plugins"):
        """Get available plugins for context."""
        
    def get_text_enabled_plugins(self, placeholder, page):
        """Get text-enabled plugins."""

# Global plugin pool instance
plugin_pool = PluginPool()

Usage Examples

Adding Plugins to Pages

from cms.api import create_page, add_plugin
from cms.models import Placeholder

# Create a page
page = create_page(
    title="Sample Page",
    template="page.html", 
    language="en"
)

# Get a placeholder
placeholder = page.get_placeholders("en").get(slot="content")

# Add a text plugin
text_plugin = add_plugin(
    placeholder=placeholder,
    plugin_type="TextPlugin",
    language="en",
    body="<h1>Welcome!</h1><p>This is sample content.</p>"
)

# Add an image plugin after the text
image_plugin = add_plugin(
    placeholder=placeholder, 
    plugin_type="PicturePlugin",
    language="en",
    position="right",
    target=text_plugin,
    picture="/path/to/image.jpg",
    alt_text="Sample image"
)

# Add a nested plugin structure
container_plugin = add_plugin(
    placeholder=placeholder,
    plugin_type="MultiColumnPlugin", 
    language="en"
)

column_plugin = add_plugin(
    placeholder=placeholder,
    plugin_type="ColumnPlugin",
    language="en", 
    parent=container_plugin,
    width="50%"
)

Custom Plugin Development

from cms.plugin_base import CMSPluginBase
from cms.plugin_pool import plugin_pool
from django import forms
from django.db import models

# Plugin model
class CallToActionPlugin(models.Model):
    title = models.CharField(max_length=100)
    description = models.TextField()
    button_text = models.CharField(max_length=50)
    button_url = models.URLField()
    
    def __str__(self):
        return self.title

# Plugin class
@plugin_pool.register_plugin
class CallToActionPluginPublisher(CMSPluginBase):
    model = CallToActionPlugin
    name = "Call to Action"
    render_template = "plugins/call_to_action.html"
    cache = True
    
    fieldsets = (
        ('Content', {
            'fields': ('title', 'description')
        }),
        ('Button', {
            'fields': ('button_text', 'button_url')
        }),
    )
    
    def render(self, context, instance, placeholder):
        context['instance'] = instance
        return context

Working with Plugin Hierarchy

from cms.models import CMSPlugin
from cms.utils.plugins import copy_plugins_to_placeholder

# Get all plugins in a placeholder
plugins = CMSPlugin.objects.filter(
    placeholder=placeholder,
    language="en"
).order_by('path')

# Get root level plugins only
root_plugins = plugins.filter(parent=None)

# Get child plugins of a specific plugin  
child_plugins = plugins.filter(parent=parent_plugin)

# Copy plugins to another placeholder
copy_plugins_to_placeholder(
    plugins=plugins,
    placeholder=target_placeholder,
    language="en"
)

# Move plugin to different position
plugin.move(target_plugin, position="right")
plugin.save()

Plugin Utilities

from cms.utils.plugins import (
    get_bound_plugins,
    has_reached_plugin_limit,
    get_plugin_class
)

# Get plugin instances with their classes
bound_plugins = get_bound_plugins(plugins)

# Check plugin limits
can_add = not has_reached_plugin_limit(
    placeholder=placeholder,
    plugin_type="TextPlugin", 
    language="en",
    template="page.html"
)

# Get plugin class by type
plugin_class = get_plugin_class("TextPlugin")

Types

class Placeholder:
    """
    Container for plugins within templates.
    
    Attributes:
        slot: Placeholder name/identifier
        default_width: Default width for plugins
        locked: Whether placeholder is locked
    """
    
    def get_plugins(self, language=None):
        """Get plugins for language."""
        
    def get_label(self):
        """Get placeholder display label."""
        
    def is_editable(self, request):
        """Check if placeholder is editable."""

class PlaceholderReference:
    """Reference to placeholder for generic relationships."""

Install with Tessl CLI