sboulahtit/orion
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
2ce19e66b1ab2ccdab476b633e11dd153b120a46
orion/app/modules/cms/services/content_page_service.py
Samir Boulahtit 2ce19e66b1 feat: implement self-contained module architecture (Phase 1 & 2) 
Phase 1 - Foundation:
- Add app/modules/contracts/ with Protocol definitions for cross-module
  communication (ServiceProtocol, ContentServiceProtocol, MediaServiceProtocol)
- Enhance app/modules/base.py ModuleDefinition with self-contained module
  support (is_self_contained, services_path, models_path, etc.)
- Update app/templates_config.py with multi-directory template loading
  using Jinja2 ChoiceLoader for module templates

Phase 2 - CMS Pilot Module:
- Migrate CMS service to app/modules/cms/services/content_page_service.py
- Create app/modules/cms/exceptions.py with CMS-specific exceptions
- Configure app/modules/cms/models/ to re-export ContentPage from canonical
  location (models.database) to avoid circular imports
- Update cms_module definition with is_self_contained=True and paths
- Add backwards compatibility shims with deprecation warnings:
  - app/services/content_page_service.py -> app.modules.cms.services
  - app/exceptions/content_page.py -> app.modules.cms.exceptions

Note: SQLAlchemy models remain in models/database/ as the canonical location
to avoid circular imports at startup time. Module model packages re-export
from the canonical location.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-26 21:35:36 +01:00

1003 lines
32 KiB
Python
Raw Blame History

# app/modules/cms/services/content_page_service.py
"""
Content Page Service
Business logic for managing content pages with three-tier hierarchy:
1. Platform Marketing Pages (is_platform_page=True, vendor_id=NULL)
- Platform's own pages (homepage, pricing, about)
- Describe the platform/business offering itself
2. Vendor Default Pages (is_platform_page=False, vendor_id=NULL)
- Fallback pages for vendors who haven't customized
- About Us, Shipping Policy, Return Policy, etc.
3. Vendor Override/Custom Pages (is_platform_page=False, vendor_id=set)
- Vendor-specific customizations
- Either overrides a default or is a completely custom page
Lookup Strategy for Vendor Storefronts:
1. Check for vendor override (platform_id + vendor_id + slug + published)
2. If not found, check for vendor default (platform_id + vendor_id=NULL + is_platform_page=False + slug)
3. If neither exists, return None/404
"""
import logging
from datetime import UTC, datetime
from sqlalchemy import and_
from sqlalchemy.orm import Session
from app.modules.cms.exceptions import (
ContentPageNotFoundException,
UnauthorizedContentPageAccessException,
)
# Import from canonical location to avoid circular imports
from models.database.content_page import ContentPage
logger = logging.getLogger(__name__)
class ContentPageService:
"""Service for content page operations with multi-platform support."""
# =========================================================================
# Three-Tier Resolution Methods (for vendor storefronts)
# =========================================================================
@staticmethod
def get_page_for_vendor(
db: Session,
platform_id: int,
slug: str,
vendor_id: int | None = None,
include_unpublished: bool = False,
) -> ContentPage | None:
"""
Get content page with three-tier resolution.
Resolution order:
1. Vendor override (platform_id + vendor_id + slug)
2. Vendor default (platform_id + vendor_id=NULL + is_platform_page=False + slug)
Args:
db: Database session
platform_id: Platform ID (required for multi-platform support)
slug: Page slug (about, faq, contact, etc.)
vendor_id: Vendor ID (None for defaults only)
include_unpublished: Include draft pages (for preview)
Returns:
ContentPage or None
"""
base_filters = [
ContentPage.platform_id == platform_id,
ContentPage.slug == slug,
]
if not include_unpublished:
base_filters.append(ContentPage.is_published == True)
# Tier 1: Try vendor-specific override first
if vendor_id:
vendor_page = (
db.query(ContentPage)
.filter(and_(ContentPage.vendor_id == vendor_id, *base_filters))
.first()
)
if vendor_page:
logger.debug(
f"[CMS] Found vendor override: {slug} for vendor_id={vendor_id}, platform_id={platform_id}"
)
return vendor_page
# Tier 2: Fallback to vendor default (not platform page)
vendor_default_page = (
db.query(ContentPage)
.filter(
and_(
ContentPage.vendor_id == None,
ContentPage.is_platform_page == False,
*base_filters,
)
)
.first()
)
if vendor_default_page:
logger.debug(f"[CMS] Using vendor default page: {slug} for platform_id={platform_id}")
return vendor_default_page
logger.debug(f"[CMS] No page found for slug: {slug}, platform_id={platform_id}")
return None
@staticmethod
def get_platform_page(
db: Session,
platform_id: int,
slug: str,
include_unpublished: bool = False,
) -> ContentPage | None:
"""
Get a platform marketing page.
Platform marketing pages are pages that describe the platform itself
(homepage, pricing, about, features, etc.).
Args:
db: Database session
platform_id: Platform ID
slug: Page slug
include_unpublished: Include draft pages
Returns:
ContentPage or None
"""
filters = [
ContentPage.platform_id == platform_id,
ContentPage.slug == slug,
ContentPage.vendor_id == None,
ContentPage.is_platform_page == True,
]
if not include_unpublished:
filters.append(ContentPage.is_published == True)
page = db.query(ContentPage).filter(and_(*filters)).first()
if page:
logger.debug(f"[CMS] Found platform page: {slug} for platform_id={platform_id}")
else:
logger.debug(f"[CMS] No platform page found: {slug} for platform_id={platform_id}")
return page
@staticmethod
def list_pages_for_vendor(
db: Session,
platform_id: int,
vendor_id: int | None = None,
include_unpublished: bool = False,
footer_only: bool = False,
header_only: bool = False,
legal_only: bool = False,
) -> list[ContentPage]:
"""
List all available pages for a vendor storefront.
Merges vendor overrides with vendor defaults, prioritizing overrides.
Does NOT include platform marketing pages.
Args:
db: Database session
platform_id: Platform ID
vendor_id: Vendor ID (None for vendor defaults only)
include_unpublished: Include draft pages
footer_only: Only pages marked for footer display
header_only: Only pages marked for header display
legal_only: Only pages marked for legal/bottom bar display
Returns:
List of ContentPage objects
"""
base_filters = [ContentPage.platform_id == platform_id]
if not include_unpublished:
base_filters.append(ContentPage.is_published == True)
if footer_only:
base_filters.append(ContentPage.show_in_footer == True)
if header_only:
base_filters.append(ContentPage.show_in_header == True)
if legal_only:
base_filters.append(ContentPage.show_in_legal == True)
# Get vendor-specific pages
vendor_pages = []
if vendor_id:
vendor_pages = (
db.query(ContentPage)
.filter(and_(ContentPage.vendor_id == vendor_id, *base_filters))
.order_by(ContentPage.display_order, ContentPage.title)
.all()
)
# Get vendor defaults (not platform marketing pages)
vendor_default_pages = (
db.query(ContentPage)
.filter(
and_(
ContentPage.vendor_id == None,
ContentPage.is_platform_page == False,
*base_filters,
)
)
.order_by(ContentPage.display_order, ContentPage.title)
.all()
)
# Merge: vendor overrides take precedence
vendor_slugs = {page.slug for page in vendor_pages}
all_pages = vendor_pages + [
page for page in vendor_default_pages if page.slug not in vendor_slugs
]
# Sort by display_order
all_pages.sort(key=lambda p: (p.display_order, p.title))
return all_pages
@staticmethod
def list_platform_pages(
db: Session,
platform_id: int,
include_unpublished: bool = False,
footer_only: bool = False,
header_only: bool = False,
) -> list[ContentPage]:
"""
List platform marketing pages.
Args:
db: Database session
platform_id: Platform ID
include_unpublished: Include draft pages
footer_only: Only pages marked for footer display
header_only: Only pages marked for header display
Returns:
List of platform marketing ContentPage objects
"""
filters = [
ContentPage.platform_id == platform_id,
ContentPage.vendor_id == None,
ContentPage.is_platform_page == True,
]
if not include_unpublished:
filters.append(ContentPage.is_published == True)
if footer_only:
filters.append(ContentPage.show_in_footer == True)
if header_only:
filters.append(ContentPage.show_in_header == True)
return (
db.query(ContentPage)
.filter(and_(*filters))
.order_by(ContentPage.display_order, ContentPage.title)
.all()
)
@staticmethod
def list_vendor_defaults(
db: Session,
platform_id: int,
include_unpublished: bool = False,
) -> list[ContentPage]:
"""
List vendor default pages (fallbacks for vendors who haven't customized).
Args:
db: Database session
platform_id: Platform ID
include_unpublished: Include draft pages
Returns:
List of vendor default ContentPage objects
"""
filters = [
ContentPage.platform_id == platform_id,
ContentPage.vendor_id == None,
ContentPage.is_platform_page == False,
]
if not include_unpublished:
filters.append(ContentPage.is_published == True)
return (
db.query(ContentPage)
.filter(and_(*filters))
.order_by(ContentPage.display_order, ContentPage.title)
.all()
)
@staticmethod
def list_all_platform_pages(
db: Session,
include_unpublished: bool = False,
) -> list[ContentPage]:
"""
List all platform marketing pages across all platforms (for admin use).
Args:
db: Database session
include_unpublished: Include draft pages
Returns:
List of all platform marketing ContentPage objects
"""
filters = [
ContentPage.vendor_id.is_(None),
ContentPage.is_platform_page.is_(True),
]
if not include_unpublished:
filters.append(ContentPage.is_published.is_(True))
return (
db.query(ContentPage)
.filter(and_(*filters))
.order_by(ContentPage.platform_id, ContentPage.display_order, ContentPage.title)
.all()
)
@staticmethod
def list_all_vendor_defaults(
db: Session,
include_unpublished: bool = False,
) -> list[ContentPage]:
"""
List all vendor default pages across all platforms (for admin use).
Args:
db: Database session
include_unpublished: Include draft pages
Returns:
List of all vendor default ContentPage objects
"""
filters = [
ContentPage.vendor_id.is_(None),
ContentPage.is_platform_page.is_(False),
]
if not include_unpublished:
filters.append(ContentPage.is_published.is_(True))
return (
db.query(ContentPage)
.filter(and_(*filters))
.order_by(ContentPage.platform_id, ContentPage.display_order, ContentPage.title)
.all()
)
# =========================================================================
# CRUD Methods
# =========================================================================
@staticmethod
def create_page(
db: Session,
platform_id: int,
slug: str,
title: str,
content: str,
vendor_id: int | None = None,
is_platform_page: bool = False,
content_format: str = "html",
template: str = "default",
meta_description: str | None = None,
meta_keywords: str | None = None,
is_published: bool = False,
show_in_footer: bool = True,
show_in_header: bool = False,
show_in_legal: bool = False,
display_order: int = 0,
created_by: int | None = None,
) -> ContentPage:
"""
Create a new content page.
Args:
db: Database session
platform_id: Platform ID (required)
slug: URL-safe identifier
title: Page title
content: HTML or Markdown content
vendor_id: Vendor ID (None for platform/default pages)
is_platform_page: True for platform marketing pages
content_format: "html" or "markdown"
template: Template name for landing pages
meta_description: SEO description
meta_keywords: SEO keywords
is_published: Publish immediately
show_in_footer: Show in footer navigation
show_in_header: Show in header navigation
show_in_legal: Show in legal/bottom bar navigation
display_order: Sort order
created_by: User ID who created it
Returns:
Created ContentPage
"""
page = ContentPage(
platform_id=platform_id,
vendor_id=vendor_id,
is_platform_page=is_platform_page,
slug=slug,
title=title,
content=content,
content_format=content_format,
template=template,
meta_description=meta_description,
meta_keywords=meta_keywords,
is_published=is_published,
published_at=datetime.now(UTC) if is_published else None,
show_in_footer=show_in_footer,
show_in_header=show_in_header,
show_in_legal=show_in_legal,
display_order=display_order,
created_by=created_by,
updated_by=created_by,
)
db.add(page)
db.flush()
db.refresh(page)
page_type = "platform" if is_platform_page else ("vendor" if vendor_id else "default")
logger.info(
f"[CMS] Created {page_type} page: {slug} (platform_id={platform_id}, vendor_id={vendor_id}, id={page.id})"
)
return page
@staticmethod
def update_page(
db: Session,
page_id: int,
title: str | None = None,
content: str | None = None,
content_format: str | None = None,
template: str | None = None,
meta_description: str | None = None,
meta_keywords: str | None = None,
is_published: bool | None = None,
show_in_footer: bool | None = None,
show_in_header: bool | None = None,
show_in_legal: bool | None = None,
display_order: int | None = None,
updated_by: int | None = None,
) -> ContentPage | None:
"""
Update an existing content page.
Args:
db: Database session
page_id: Page ID
... other fields
Returns:
Updated ContentPage or None if not found
"""
page = db.query(ContentPage).filter(ContentPage.id == page_id).first()
if not page:
logger.warning(f"[CMS] Content page not found: id={page_id}")
return None
# Update fields if provided
if title is not None:
page.title = title
if content is not None:
page.content = content
if content_format is not None:
page.content_format = content_format
if template is not None:
page.template = template
if meta_description is not None:
page.meta_description = meta_description
if meta_keywords is not None:
page.meta_keywords = meta_keywords
if is_published is not None:
page.is_published = is_published
if is_published and not page.published_at:
page.published_at = datetime.now(UTC)
if show_in_footer is not None:
page.show_in_footer = show_in_footer
if show_in_header is not None:
page.show_in_header = show_in_header
if show_in_legal is not None:
page.show_in_legal = show_in_legal
if display_order is not None:
page.display_order = display_order
if updated_by is not None:
page.updated_by = updated_by
db.flush()
db.refresh(page)
logger.info(f"[CMS] Updated content page: id={page_id}, slug={page.slug}")
return page
@staticmethod
def delete_page(db: Session, page_id: int) -> bool:
"""
Delete a content page.
Args:
db: Database session
page_id: Page ID
Returns:
True if deleted, False if not found
"""
page = db.query(ContentPage).filter(ContentPage.id == page_id).first()
if not page:
logger.warning(f"[CMS] Content page not found for deletion: id={page_id}")
return False
db.delete(page)
logger.info(f"[CMS] Deleted content page: id={page_id}, slug={page.slug}")
return True
@staticmethod
def get_page_by_id(db: Session, page_id: int) -> ContentPage | None:
"""Get content page by ID."""
return db.query(ContentPage).filter(ContentPage.id == page_id).first()
@staticmethod
def get_page_by_id_or_raise(db: Session, page_id: int) -> ContentPage:
"""
Get content page by ID or raise ContentPageNotFoundException.
"""
page = db.query(ContentPage).filter(ContentPage.id == page_id).first()
if not page:
raise ContentPageNotFoundException(identifier=page_id)
return page
@staticmethod
def get_page_for_vendor_or_raise(
db: Session,
platform_id: int,
slug: str,
vendor_id: int | None = None,
include_unpublished: bool = False,
) -> ContentPage:
"""
Get content page for a vendor with three-tier resolution.
Raises ContentPageNotFoundException if not found.
"""
page = ContentPageService.get_page_for_vendor(
db,
platform_id=platform_id,
slug=slug,
vendor_id=vendor_id,
include_unpublished=include_unpublished,
)
if not page:
raise ContentPageNotFoundException(identifier=slug)
return page
@staticmethod
def get_platform_page_or_raise(
db: Session,
platform_id: int,
slug: str,
include_unpublished: bool = False,
) -> ContentPage:
"""
Get platform marketing page or raise ContentPageNotFoundException.
"""
page = ContentPageService.get_platform_page(
db,
platform_id=platform_id,
slug=slug,
include_unpublished=include_unpublished,
)
if not page:
raise ContentPageNotFoundException(identifier=slug)
return page
# =========================================================================
# Vendor Page Management (with ownership checks)
# =========================================================================
@staticmethod
def update_vendor_page(
db: Session,
page_id: int,
vendor_id: int,
title: str | None = None,
content: str | None = None,
content_format: str | None = None,
meta_description: str | None = None,
meta_keywords: str | None = None,
is_published: bool | None = None,
show_in_footer: bool | None = None,
show_in_header: bool | None = None,
show_in_legal: bool | None = None,
display_order: int | None = None,
updated_by: int | None = None,
) -> ContentPage:
"""
Update a vendor-specific content page with ownership check.
Raises:
ContentPageNotFoundException: If page not found
UnauthorizedContentPageAccessException: If page doesn't belong to vendor
"""
page = ContentPageService.get_page_by_id_or_raise(db, page_id)
if page.vendor_id != vendor_id:
raise UnauthorizedContentPageAccessException(action="edit")
return ContentPageService.update_page(
db,
page_id=page_id,
title=title,
content=content,
content_format=content_format,
meta_description=meta_description,
meta_keywords=meta_keywords,
is_published=is_published,
show_in_footer=show_in_footer,
show_in_header=show_in_header,
show_in_legal=show_in_legal,
display_order=display_order,
updated_by=updated_by,
)
@staticmethod
def delete_vendor_page(db: Session, page_id: int, vendor_id: int) -> None:
"""
Delete a vendor-specific content page with ownership check.
Raises:
ContentPageNotFoundException: If page not found
UnauthorizedContentPageAccessException: If page doesn't belong to vendor
"""
page = ContentPageService.get_page_by_id_or_raise(db, page_id)
if page.vendor_id != vendor_id:
raise UnauthorizedContentPageAccessException(action="delete")
ContentPageService.delete_page(db, page_id)
@staticmethod
def create_vendor_override(
db: Session,
platform_id: int,
vendor_id: int,
slug: str,
title: str,
content: str,
content_format: str = "html",
meta_description: str | None = None,
meta_keywords: str | None = None,
is_published: bool = False,
show_in_footer: bool = True,
show_in_header: bool = False,
show_in_legal: bool = False,
display_order: int = 0,
created_by: int | None = None,
) -> ContentPage:
"""
Create a vendor override page (vendor-specific customization of a default).
Args:
db: Database session
platform_id: Platform ID
vendor_id: Vendor ID
slug: Page slug (typically matches a default page)
... other fields
Returns:
Created ContentPage
"""
return ContentPageService.create_page(
db,
platform_id=platform_id,
slug=slug,
title=title,
content=content,
vendor_id=vendor_id,
is_platform_page=False,
content_format=content_format,
meta_description=meta_description,
meta_keywords=meta_keywords,
is_published=is_published,
show_in_footer=show_in_footer,
show_in_header=show_in_header,
show_in_legal=show_in_legal,
display_order=display_order,
created_by=created_by,
)
@staticmethod
def revert_to_default(db: Session, page_id: int, vendor_id: int) -> None:
"""
Revert a vendor override to the default by deleting the override.
After deletion, the vendor storefront will use the vendor default page.
Raises:
ContentPageNotFoundException: If page not found
UnauthorizedContentPageAccessException: If page doesn't belong to vendor
"""
ContentPageService.delete_vendor_page(db, page_id, vendor_id)
# =========================================================================
# Admin Methods (for listing all pages)
# =========================================================================
@staticmethod
def list_all_pages(
db: Session,
platform_id: int | None = None,
vendor_id: int | None = None,
include_unpublished: bool = False,
page_tier: str | None = None,
) -> list[ContentPage]:
"""
List all content pages for admin management.
Args:
db: Database session
platform_id: Optional filter by platform ID
vendor_id: Optional filter by vendor ID
include_unpublished: Include draft pages
page_tier: Optional filter by tier ("platform", "vendor_default", "vendor_override")
Returns:
List of ContentPage objects
"""
filters = []
if platform_id:
filters.append(ContentPage.platform_id == platform_id)
if vendor_id is not None:
filters.append(ContentPage.vendor_id == vendor_id)
if not include_unpublished:
filters.append(ContentPage.is_published == True)
if page_tier == "platform":
filters.append(ContentPage.is_platform_page == True)
filters.append(ContentPage.vendor_id == None)
elif page_tier == "vendor_default":
filters.append(ContentPage.is_platform_page == False)
filters.append(ContentPage.vendor_id == None)
elif page_tier == "vendor_override":
filters.append(ContentPage.vendor_id != None)
return (
db.query(ContentPage)
.filter(and_(*filters) if filters else True)
.order_by(
ContentPage.platform_id,
ContentPage.vendor_id,
ContentPage.display_order,
ContentPage.title,
)
.all()
)
@staticmethod
def list_all_vendor_pages(
db: Session,
vendor_id: int,
platform_id: int | None = None,
include_unpublished: bool = False,
) -> list[ContentPage]:
"""
List only vendor-specific pages (overrides and custom pages).
Args:
db: Database session
vendor_id: Vendor ID
platform_id: Optional filter by platform
include_unpublished: Include draft pages
Returns:
List of vendor-specific ContentPage objects
"""
filters = [ContentPage.vendor_id == vendor_id]
if platform_id:
filters.append(ContentPage.platform_id == platform_id)
if not include_unpublished:
filters.append(ContentPage.is_published == True)
return (
db.query(ContentPage)
.filter(and_(*filters))
.order_by(ContentPage.display_order, ContentPage.title)
.all()
)
# =========================================================================
# Helper Methods for raising exceptions
# =========================================================================
@staticmethod
def update_page_or_raise(
db: Session,
page_id: int,
title: str | None = None,
content: str | None = None,
content_format: str | None = None,
template: str | None = None,
meta_description: str | None = None,
meta_keywords: str | None = None,
is_published: bool | None = None,
show_in_footer: bool | None = None,
show_in_header: bool | None = None,
show_in_legal: bool | None = None,
display_order: int | None = None,
updated_by: int | None = None,
) -> ContentPage:
"""
Update an existing content page or raise exception.
Raises:
ContentPageNotFoundException: If page not found
"""
page = ContentPageService.update_page(
db,
page_id=page_id,
title=title,
content=content,
content_format=content_format,
template=template,
meta_description=meta_description,
meta_keywords=meta_keywords,
is_published=is_published,
show_in_footer=show_in_footer,
show_in_header=show_in_header,
show_in_legal=show_in_legal,
display_order=display_order,
updated_by=updated_by,
)
if not page:
raise ContentPageNotFoundException(identifier=page_id)
return page
@staticmethod
def delete_page_or_raise(db: Session, page_id: int) -> None:
"""
Delete a content page or raise exception.
Raises:
ContentPageNotFoundException: If page not found
"""
success = ContentPageService.delete_page(db, page_id)
if not success:
raise ContentPageNotFoundException(identifier=page_id)
# =========================================================================
# Homepage Sections Management
# =========================================================================
@staticmethod
def update_homepage_sections(
db: Session,
page_id: int,
sections: dict,
updated_by: int | None = None,
) -> ContentPage:
"""
Update homepage sections with validation.
Args:
db: Database session
page_id: Content page ID
sections: Homepage sections dict (validated against HomepageSections schema)
updated_by: User ID making the update
Returns:
Updated ContentPage
Raises:
ContentPageNotFoundException: If page not found
ValidationError: If sections schema invalid
"""
from models.schema.homepage_sections import HomepageSections
page = ContentPageService.get_page_by_id_or_raise(db, page_id)
# Validate sections against schema
validated = HomepageSections(**sections)
# Update page
page.sections = validated.model_dump()
page.updated_by = updated_by
db.flush()
db.refresh(page)
logger.info(f"[CMS] Updated homepage sections for page_id={page_id}")
return page
@staticmethod
def update_single_section(
db: Session,
page_id: int,
section_name: str,
section_data: dict,
updated_by: int | None = None,
) -> ContentPage:
"""
Update a single section within homepage sections.
Args:
db: Database session
page_id: Content page ID
section_name: Section to update (hero, features, pricing, cta)
section_data: Section configuration dict
updated_by: User ID making the update
Returns:
Updated ContentPage
Raises:
ContentPageNotFoundException: If page not found
ValueError: If section name is invalid
"""
from models.schema.homepage_sections import (
HeroSection,
FeaturesSection,
PricingSection,
CTASection,
)
SECTION_SCHEMAS = {
"hero": HeroSection,
"features": FeaturesSection,
"pricing": PricingSection,
"cta": CTASection,
}
if section_name not in SECTION_SCHEMAS:
raise ValueError(f"Invalid section name: {section_name}. Must be one of: {list(SECTION_SCHEMAS.keys())}")
page = ContentPageService.get_page_by_id_or_raise(db, page_id)
# Validate section data against its schema
schema = SECTION_SCHEMAS[section_name]
validated_section = schema(**section_data)
# Initialize sections if needed
current_sections = page.sections or {}
current_sections[section_name] = validated_section.model_dump()
page.sections = current_sections
page.updated_by = updated_by
db.flush()
db.refresh(page)
logger.info(f"[CMS] Updated section '{section_name}' for page_id={page_id}")
return page
@staticmethod
def get_default_sections(languages: list[str] | None = None) -> dict:
"""
Get empty sections structure for new homepage.
Args:
languages: List of language codes from platform.supported_languages.
Defaults to ['fr', 'de', 'en'] if not provided.
Returns:
Empty sections dict with language placeholders
"""
from models.schema.homepage_sections import HomepageSections
if languages is None:
languages = ["fr", "de", "en"]
return HomepageSections.get_empty_structure(languages).model_dump()
# Singleton instance
content_page_service = ContentPageService()
Reference in New Issue View Git Blame Copy Permalink