django-nativemojo 0.1.15__py3-none-any.whl → 0.1.17__py3-none-any.whl

mojo/apps/docit/models/page.py

@@ -0,0 +1,319 @@
+from django.db import models
+from django.utils.text import slugify
+from mojo.models import MojoModel
+from mojo.helpers import logit
+
+
+class Page(models.Model, MojoModel):
+    """
+    Individual documentation page within a book
+
+    Pages can be organized hierarchically with parent-child relationships
+    and support version control through PageRevision records.
+    """
+
+    # Relationships
+    book = models.ForeignKey(
+        'docit.Book',
+        on_delete=models.CASCADE,
+        related_name='pages',
+        help_text="Book this page belongs to"
+    )
+    parent = models.ForeignKey(
+        'self',
+        null=True,
+        blank=True,
+        on_delete=models.CASCADE,
+        related_name='children',
+        help_text="Parent page for hierarchical organization"
+    )
+
+    # Basic fields
+    title = models.CharField(
+        max_length=200,
+        help_text="Page title"
+    )
+    slug = models.SlugField(
+        max_length=200,
+        db_index=True,
+        help_text="URL-friendly identifier (unique within book)"
+    )
+    content = models.TextField(
+        help_text="Raw markdown content"
+    )
+
+    # Ordering and metadata
+    order_priority = models.IntegerField(
+        default=0,
+        db_index=True,
+        help_text="Higher values appear first in listings"
+    )
+    metadata = models.JSONField(
+        default=dict,
+        help_text="Frontmatter and additional page metadata"
+    )
+
+    # Status
+    is_published = models.BooleanField(
+        default=True,
+        db_index=True,
+        help_text="Whether this page is published and visible"
+    )
+
+    # Ownership and tracking (inherits from book permissions)
+    user = models.ForeignKey(
+        'account.User',
+        on_delete=models.PROTECT,
+        help_text="Page owner (inherited from book for permissions)"
+    )
+    created_by = models.ForeignKey(
+        'account.User',
+        on_delete=models.PROTECT,
+        related_name='created_pages',
+        help_text="User who created this page"
+    )
+    modified_by = models.ForeignKey(
+        'account.User',
+        on_delete=models.PROTECT,
+        related_name='modified_pages',
+        null=True,
+        default=None,
+        help_text="User who last modified this page"
+    )
+
+    # Standard MOJO timestamps
+    created = models.DateTimeField(
+        auto_now_add=True,
+        editable=False,
+        db_index=True
+    )
+    modified = models.DateTimeField(
+        auto_now=True,
+        db_index=True
+    )
+
+    class Meta:
+        ordering = ['-order_priority', 'title']
+        verbose_name = 'Page'
+        verbose_name_plural = 'Pages'
+        # Ensure slug is unique within a book
+        unique_together = ['book', 'slug']
+
+    class RestMeta:
+        VIEW_PERMS = ['all']
+        SAVE_PERMS = ['manage_docit', 'owner']
+        DELETE_PERMS = ['manage_docit', 'owner']
+        CREATED_BY_OWNER_FIELD = 'created_by'
+        UPDATED_BY_OWNER_FIELD = 'modified_by'
+        GRAPHS = {
+            'default': {
+                "graphs": {
+                    "user": "basic",
+                    "book": "default",
+                    "created_by": "basic",
+                    "modified_by": "basic"
+                }
+            },
+            'detail': {
+                "fields": [
+                    'id', 'title', 'slug', 'content', 'order_priority',
+                    'metadata', 'is_published', 'created', 'modified',
+                    'book', 'parent'
+                ],
+                "graphs": {
+                    "user": "basic",
+                    "book": "default",
+                    "created_by": "basic",
+                    "modified_by": "basic"
+                }
+            },
+            'list': {
+                "fields": [
+                    'id', 'title', 'slug', 'is_published', 'order_priority', "metadata"
+                ],
+                "graphs": {
+                    # "user": "basic",
+                    "book": "default",
+                    # "created_by": "basic",
+                    "modified_by": "basic"
+                }
+            },
+            'content_only': {
+                "fields": [
+                'id', 'title', 'content'
+                ],
+            },
+            'html': {
+                "fields": [
+                    'id', 'title', 'slug', 'order_priority',
+                    'metadata', 'is_published', 'created', 'modified',
+                ],
+                "extra": ["html"],
+                "graphs": {
+                    "modified_by": "basic"
+                }
+            },
+            'tree': {
+                "fields": [
+                'id', 'title', 'slug', 'order_priority', 'parent', 'children'
+                ],
+            }
+        }
+
+    def __str__(self):
+        return f"{self.book.title} / {self.title}"
+
+    def save(self, *args, **kwargs):
+        """Override save to auto-generate slug, validate hierarchy, and log operations"""
+
+        # Auto-generate slug from title if not provided
+        if not self.slug:
+            self.slug = slugify(self.title.replace('_', '-'))
+
+            # Handle duplicate slugs within the same book
+            counter = 1
+            original_slug = self.slug
+            while Page.objects.filter(
+                book=self.book,
+                slug=self.slug
+            ).exclude(pk=self.pk).exists():
+                self.slug = f"{original_slug}-{counter}"
+                counter += 1
+
+        if (not hasattr(self, "user") or self.user is None) and self.created_by:
+            self.user = self.created_by
+
+        # Validate parent relationship (prevent circular references)
+        if self.parent:
+            if self.parent == self:
+                raise ValueError("A page cannot be its own parent")
+
+            if self.pk and self._would_create_cycle(self.parent):
+                raise ValueError("Parent relationship would create a circular reference")
+
+            # Ensure parent belongs to same book
+            if self.parent.book != self.book:
+                raise ValueError("Parent page must belong to the same book")
+
+        # Inherit user from book if not set
+        if not self.user_id and self.book_id:
+            self.user = self.book.user
+
+        # Log the operation
+        if self.pk:
+            logit.info(f"Updating page: {self.title} in book {self.book.title} (ID: {self.pk})")
+        else:
+            logit.info(f"Creating new page: {self.title} in book {self.book.title}")
+
+        super().save(*args, **kwargs)
+
+    def delete(self, *args, **kwargs):
+        """Override delete to log the operation"""
+        logit.info(f"Deleting page: {self.title} from book {self.book.title} (ID: {self.pk})")
+        super().delete(*args, **kwargs)
+
+    def _would_create_cycle(self, potential_parent):
+        """Check if setting potential_parent as parent would create a cycle"""
+        current = potential_parent
+        while current:
+            if current == self:
+                return True
+            current = current.parent
+        return False
+
+    @property
+    def full_path(self):
+        """Return hierarchical path like: parent/child/grandchild"""
+        if self.parent:
+            return f"{self.parent.full_path}/{self.slug}"
+        return self.slug
+
+    @property
+    def html(self):
+        """
+        Renders the Markdown content of the page to HTML.
+        """
+        from mojo.apps.docit.services.markdown import MarkdownRenderer
+        renderer = MarkdownRenderer()
+        rendered_html = renderer.render(self.content)
+        return rendered_html
+
+    @property
+    def ast(self):
+        """
+        Return AST representation of page content
+
+        This will be implemented in Phase 2 with markdown processing
+        """
+        return None
+
+    def get_children(self):
+        """Get direct child pages (published only by default)"""
+        return self.children.filter(is_published=True).order_by('-order_priority', 'title')
+
+    def get_all_children(self, include_unpublished=False):
+        """Get direct child pages with option to include unpublished"""
+        queryset = self.children.all()
+        if not include_unpublished:
+            queryset = queryset.filter(is_published=True)
+        return queryset.order_by('-order_priority', 'title')
+
+    def get_descendants(self):
+        """Get all descendant pages (recursive, published only)"""
+        descendants = []
+        for child in self.get_children():
+            descendants.append(child)
+            descendants.extend(child.get_descendants())
+        return descendants
+
+    def get_ancestors(self):
+        """Get all ancestor pages from root to immediate parent"""
+        ancestors = []
+        current = self.parent
+        while current:
+            ancestors.insert(0, current)  # Insert at beginning for correct order
+            current = current.parent
+        return ancestors
+
+    def get_breadcrumbs(self):
+        """Get breadcrumb trail including this page"""
+        breadcrumbs = self.get_ancestors()
+        breadcrumbs.append(self)
+        return breadcrumbs
+
+    def get_depth(self):
+        """Get the depth level in the hierarchy (0 for root pages)"""
+        depth = 0
+        current = self.parent
+        while current:
+            depth += 1
+            current = current.parent
+        return depth
+
+    def create_revision(self, user, change_summary=""):
+        """Create a new revision record for this page"""
+        from .page_revision import PageRevision
+
+        # Get the next version number
+        last_revision = self.revisions.order_by('-version').first()
+        next_version = (last_revision.version + 1) if last_revision else 1
+
+        revision = PageRevision.objects.create(
+            page=self,
+            content=self.content,
+            version=next_version,
+            change_summary=change_summary,
+            created_by=user,
+            user=self.user
+        )
+
+        logit.info(f"Created revision v{next_version} for page: {self.title}")
+        return revision
+
+    def get_latest_revision(self):
+        """Get the most recent revision"""
+        return self.revisions.order_by('-version').first()
+
+    def get_revision_count(self):
+        """Get total number of revisions for this page"""
+        return self.revisions.count()

mojo/apps/docit/models/page_revision.py

@@ -0,0 +1,203 @@
+from django.db import models
+from mojo.models import MojoModel
+from mojo.helpers import logit
+
+
+class PageRevision(models.Model, MojoModel):
+    """
+    Version history for pages
+
+    Each revision captures a snapshot of page content at a point in time,
+    providing a complete audit trail and version control system.
+    """
+
+    # Relationships
+    page = models.ForeignKey(
+        'docit.Page',
+        on_delete=models.CASCADE,
+        related_name='revisions',
+        help_text="Page this revision belongs to"
+    )
+
+    # Content snapshot
+    content = models.TextField(
+        help_text="Markdown content snapshot at time of revision"
+    )
+
+    # Version tracking
+    version = models.IntegerField(
+        db_index=True,
+        help_text="Sequential version number for this page"
+    )
+
+    # Optional metadata
+    change_summary = models.CharField(
+        max_length=200,
+        blank=True,
+        help_text="Brief description of changes made in this revision"
+    )
+
+    # Ownership and tracking (inherits from page/book permissions)
+    user = models.ForeignKey(
+        'account.User',
+        on_delete=models.PROTECT,
+        help_text="User for permission inheritance (from page/book)"
+    )
+    created_by = models.ForeignKey(
+        'account.User',
+        on_delete=models.PROTECT,
+        related_name='created_revisions',
+        help_text="User who created this revision"
+    )
+
+    # Standard MOJO timestamps
+    created = models.DateTimeField(
+        auto_now_add=True,
+        editable=False,
+        db_index=True
+    )
+    modified = models.DateTimeField(
+        auto_now=True,
+        db_index=True
+    )
+
+    class Meta:
+        ordering = ['-version']
+        verbose_name = 'Page Revision'
+        verbose_name_plural = 'Page Revisions'
+        # Ensure version is unique within a page
+        unique_together = ['page', 'version']
+
+    class RestMeta:
+        VIEW_PERMS = ['all']
+        SAVE_PERMS = ['manage_docit', 'owner']
+        DELETE_PERMS = ['manage_docit', 'owner']
+
+        GRAPHS = {
+            'default': {
+                "fields": [
+                    'id', 'version', 'change_summary', 'created'
+                ],
+            },
+            'detail': {
+                "fields": [
+                    'id', 'content', 'version', 'change_summary',
+                    'created', 'page', 'created_by'
+                ],
+            },
+            'list': {
+                "fields": [
+                    'id', 'version', 'change_summary', 'created'
+                ],
+            },
+            'content_only': {
+                "fields": [
+                    'id', 'version', 'content'
+                ],
+            }
+        }
+
+    def __str__(self):
+        return f"{self.page.title} v{self.version}"
+
+    def save(self, *args, **kwargs):
+        """Override save to validate version and log operations"""
+
+        # Auto-assign version number if not provided
+        if not self.version:
+            last_revision = PageRevision.objects.filter(
+                page=self.page
+            ).order_by('-version').first()
+
+            self.version = (last_revision.version + 1) if last_revision else 1
+
+        # Inherit user from page if not set
+        if not self.user_id and self.page_id:
+            self.user = self.page.user
+
+        # Log the operation
+        if self.pk:
+            logit.info(f"Updating revision v{self.version} for page: {self.page.title} (ID: {self.pk})")
+        else:
+            logit.info(f"Creating revision v{self.version} for page: {self.page.title}")
+
+        super().save(*args, **kwargs)
+
+    def delete(self, *args, **kwargs):
+        """Override delete to log the operation"""
+        logit.warn(f"Deleting revision v{self.version} for page: {self.page.title} (ID: {self.pk})")
+        super().delete(*args, **kwargs)
+
+    @property
+    def is_latest(self):
+        """Check if this is the latest revision for the page"""
+        latest = PageRevision.objects.filter(
+            page=self.page
+        ).order_by('-version').first()
+
+        return latest and latest.id == self.id
+
+    def get_content_diff(self, other_revision=None):
+        """
+        Get content difference between this revision and another
+
+        This will be implemented in Phase 2 with proper diff functionality
+        """
+        return None
+
+    def get_previous_revision(self):
+        """Get the revision immediately before this one"""
+        return PageRevision.objects.filter(
+            page=self.page,
+            version__lt=self.version
+        ).order_by('-version').first()
+
+    def get_next_revision(self):
+        """Get the revision immediately after this one"""
+        return PageRevision.objects.filter(
+            page=self.page,
+            version__gt=self.version
+        ).order_by('version').first()
+
+    def restore_to_page(self, user):
+        """
+        Restore this revision's content to the current page
+
+        This creates a new revision with the restored content.
+        """
+        # Update the page content
+        self.page.content = self.content
+        self.page.modified_by = user
+        self.page.save()
+
+        # Create a new revision to track the restoration
+        new_revision = self.page.create_revision(
+            user=user,
+            change_summary=f"Restored from v{self.version}"
+        )
+
+        logit.info(f"Restored page '{self.page.title}' to revision v{self.version}")
+        return new_revision
+
+    def get_age_since_created(self):
+        """Get time elapsed since this revision was created"""
+        from django.utils import timezone
+        return timezone.now() - self.created
+
+    @classmethod
+    def cleanup_old_revisions(cls, page, keep_count=50):
+        """
+        Clean up old revisions, keeping only the most recent ones
+
+        This is a utility method for revision management
+        """
+        revisions = cls.objects.filter(page=page).order_by('-version')
+
+        if revisions.count() > keep_count:
+            old_revisions = revisions[keep_count:]
+            count = len(old_revisions)
+
+            for revision in old_revisions:
+                revision.delete()
+
+            logit.info(f"Cleaned up {count} old revisions for page: {page.title}")

mojo/apps/docit/rest/__init__.py

@@ -0,0 +1,10 @@
+"""
+DocIt REST Handlers
+
+Import all REST endpoint handlers to register them with Django-MOJO
+"""
+
+from .book import *
+from .page import *
+from .page_revision import *
+from .asset import *

mojo/apps/docit/rest/asset.py

@@ -0,0 +1,17 @@
+import mojo.decorators as md
+from ..models import Asset
+
+
+@md.URL('book/asset')
+@md.URL('book/asset/<int:pk>')
+def on_book_asset(request, pk=None):
+    """
+    Standard CRUD endpoints for Asset model
+
+    GET /api/docit/book/asset - List book assets
+    POST /api/docit/book/asset - Create new book asset
+    GET /api/docit/book/asset/<id> - Get single book asset
+    PUT /api/docit/book/asset/<id> - Update book asset
+    DELETE /api/docit/book/asset/<id> - Delete book asset
+    """
+    return Asset.on_rest_request(request, pk)

mojo/apps/docit/rest/book.py

@@ -0,0 +1,22 @@
+import mojo.decorators as md
+from ..models import Book
+
+
+@md.URL('book')
+@md.URL('book/<int:pk>')
+def on_book(request, pk=None):
+    """
+    Standard CRUD endpoints for Book model
+
+    GET /api/docit/book - List books
+    POST /api/docit/book - Create new book
+    GET /api/docit/book/<id> - Get single book
+    PUT /api/docit/book/<id> - Update book
+    DELETE /api/docit/book/<id> - Delete book
+    """
+    return Book.on_rest_request(request, pk)
+
+
+@md.URL('book/slug/<str:slug>')
+def on_book_by_slug(request, slug=None):
+    return Book.objects.get(slug=slug).on_rest_get(request)

mojo/apps/docit/rest/page.py

@@ -0,0 +1,22 @@
+import mojo.decorators as md
+from ..models import Page
+
+
+@md.URL('page')
+@md.URL('page/<int:pk>')
+def on_page(request, pk=None):
+    """
+    Standard CRUD endpoints for Page model
+
+    GET /api/docit/page - List pages
+    POST /api/docit/page - Create new page
+    GET /api/docit/page/<id> - Get single page
+    PUT /api/docit/page/<id> - Update page
+    DELETE /api/docit/page/<id> - Delete page
+    """
+    return Page.on_rest_request(request, pk)
+
+
+@md.URL('page/slug/<str:slug>')
+def on_page_by_slug(request, slug=None):
+    return Page.objects.get(slug=slug).on_rest_get(request)

mojo/apps/docit/rest/page_revision.py

@@ -0,0 +1,17 @@
+import mojo.decorators as md
+from ..models import PageRevision
+
+
+@md.URL('page/revision')
+@md.URL('page/revision/<int:pk>')
+def on_page_revision(request, pk=None):
+    """
+    Standard CRUD endpoints for PageRevision model
+
+    GET /api/docit/page/revision - List page revisions
+    POST /api/docit/page/revision - Create new page revision
+    GET /api/docit/page/revision/<id> - Get single page revision
+    PUT /api/docit/page/revision/<id> - Update page revision
+    DELETE /api/docit/page/revision/<id> - Delete page revision
+    """
+    return PageRevision.on_rest_request(request, pk)

mojo/apps/docit/services/__init__.py

@@ -0,0 +1,11 @@
+"""
+DocIt Services
+
+Export business logic services for clean imports
+"""
+
+from .docit import DocItService
+
+__all__ = [
+    'DocItService'
+]