tessl/pypi-django-cms

Lean enterprise content management powered by Django.

—

Pending

Overview

Eval results

Files

Page and Content Management

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

Django CMS provides comprehensive page management functionality for creating, organizing, and managing hierarchical content structures with full multi-language support and versioning capabilities.

Capabilities

Page Creation and Management

Create and manage CMS pages with hierarchical structure, template assignment, and comprehensive configuration options.

def create_page(
    title,
    template, 
    language,
    menu_title=None,
    slug=None,
    apphook=None,
    apphook_namespace=None,
    redirect=None,
    meta_description=None,
    created_by="python-api",
    parent=None,
    publication_date=None,
    publication_end_date=None,
    in_navigation=False,
    soft_root=False,
    reverse_id=None,
    navigation_extenders=None,
    published=None,
    site=None,
    login_required=False,
    limit_visibility_in_menu=None,
    position="last-child",
    overwrite_url=None,
    xframe_options=None
):
    """
    Create a new CMS page.
    
    Args:
        title (str): Page title
        template (str): Template identifier
        language (str): Language code
        menu_title (str, optional): Navigation menu title
        slug (str, optional): URL slug, auto-generated if None
        apphook (str|CMSApp, optional): Application hook configuration
        apphook_namespace (str, optional): App hook namespace
        redirect (str, optional): Redirect URL
        meta_description (str, optional): SEO meta description
        created_by (str): Creator identifier
        parent (Page, optional): Parent page for hierarchy
        publication_date (datetime, optional): Publication start date
        publication_end_date (datetime, optional): Publication end date
        in_navigation (bool): Include in navigation menus
        soft_root (bool): Act as navigation root
        reverse_id (str, optional): Unique reverse ID for lookups
        navigation_extenders (str, optional): Navigation extender class
        published (bool, optional): Publish immediately
        site (Site, optional): Django site, uses current if None
        login_required (bool): Require login to view page
        limit_visibility_in_menu (int, optional): Menu visibility limit
        position (str): Position relative to siblings
        overwrite_url (str, optional): Custom URL override
        xframe_options (int, optional): X-Frame-Options header setting
        
    Returns:
        Page: Created page instance
    """

def get_page_draft(page):
    """
    Get the draft version of a page.
    
    Args:
        page (Page): Page instance
        
    Returns:
        Page: Draft version of the page
    """

Page Content Management

Manage versioned page content with language-specific data and publishing workflow.

def create_page_content(
    language,
    title,
    page,
    slug=None,
    path=None,
    redirect=None,
    in_navigation=True,
    limit_visibility_in_menu=None,
    **kwargs
):
    """
    Create page content for specific language.
    
    Args:
        language (str): Language code
        title (str): Content title
        page (Page): Target page
        slug (str, optional): URL slug
        path (str, optional): Full URL path
        redirect (str, optional): Redirect URL
        in_navigation (bool): Show in navigation
        limit_visibility_in_menu (int, optional): Menu visibility limit
        
    Returns:
        PageContent: Created page content instance
    """

def create_title(title, language, page, slug=None, path=None):  
    """
    Create page title (deprecated - use create_page_content).
    
    Args:
        title (str): Page title
        language (str): Language code  
        page (Page): Target page
        slug (str, optional): URL slug
        path (str, optional): URL path
        
    Returns:
        PageContent: Page content instance
    """

Publishing and Workflow

Note: Publishing functionality has been removed from Django CMS core in version 4+. For publishing capabilities, use additional packages like djangocms-versioning.

The core API no longer includes publish_page or publish_pages functions. These functions now only emit warnings and do not perform any publishing operations.

Multi-language Content Management

Handle content translation and cross-language operations.

def copy_plugins_to_language(page, source_language, target_language, only_empty=True):
    """
    Copy page plugins between languages.
    
    Args:
        page (Page): Target page
        source_language (str): Source language code
        target_language (str): Target language code
        only_empty (bool): Only copy to empty placeholders
        
    Returns:
        bool: Success status
    """

Usage Examples

Creating a Page Hierarchy

from cms.api import create_page

# Create parent page
home_page = create_page(
    title="Home",
    template="homepage.html",
    language="en",
    slug="",  # Root page
    published=True,
    in_navigation=True
)

# Create child page
about_page = create_page(
    title="About Us", 
    template="page.html",
    language="en",
    parent=home_page,
    published=True
)

# Create grandchild page
team_page = create_page(
    title="Our Team",
    template="page.html", 
    language="en",
    parent=about_page,
    reverse_id="team"  # For easy lookups
)

Multi-language Page Setup

# Create English page
page = create_page(
    title="Welcome",
    template="page.html",
    language="en",
    slug="welcome"
)

# Add German translation
german_content = create_page_content(
    page=page,
    language="de", 
    title="Willkommen",
    slug="willkommen"
)

# Add French translation  
french_content = create_page_content(
    page=page,
    language="fr",
    title="Bienvenue", 
    slug="bienvenue"
)

# Note: Publishing has been removed from core Django CMS.
# Use djangocms-versioning or similar packages for publishing functionality.

Working with Page Models

from cms.models import Page, PageContent

# Get page by reverse ID
page = Page.objects.get(reverse_id="team")

# Get all page content versions
content_versions = page.pagecontent_set.all()

# Get specific language content
english_content = page.get_content_obj(language="en")

# Check if page is published
is_published = page.is_published("en")

# Get page URL
page_url = page.get_absolute_url(language="en")

Types

class Page:
    """
    Core page model with hierarchical structure.
    
    Attributes:
        node: TreeNode for hierarchy management
        reverse_id: Optional unique identifier
        navigation_extenders: Navigation extension class
        is_home: Whether this is the site home page
        application_urls: App hook configuration
        application_namespace: App namespace
    """
    
    def get_absolute_url(self, language=None): 
        """Get page URL for language."""
        
    def get_content_obj(self, language=None, fallback=True):
        """Get PageContent for language."""
        
    def is_published(self, language): 
        """Check if page is published in language."""
        
    def get_placeholders(self, language): 
        """Get page placeholders for language."""

class PageContent:
    """
    Language-specific page content with versioning.
    
    Attributes:
        page: Associated Page instance
        language: Language code
        title: Page title
        slug: URL slug
        path: Full URL path
        redirect: Redirect URL
        in_navigation: Navigation visibility
        limit_visibility_in_menu: Menu visibility limit
        meta_description: SEO meta description
        page_title: HTML page title
        menu_title: Navigation menu title
    """
    
    def get_absolute_url(self): 
        """Get content URL."""
        
    def get_placeholders(self): 
        """Get associated placeholders."""

Install with Tessl CLI