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

mojo/apps/docit/services/docit.py

@@ -0,0 +1,315 @@
+from mojo.helpers import logit
+from ..models import Book, Page, PageRevision, Asset
+
+
+class DocItService:
+    """
+    Business logic service for DocIt operations
+
+    Handles complex operations that span multiple models or contain
+    business logic that doesn't belong in individual model methods.
+    """
+
+    @staticmethod
+    def create_book_with_homepage(title, description, group, user, homepage_title="Home"):
+        """
+        Create a new book with an initial homepage
+
+        This is a common pattern where new books should have at least one page
+        """
+        try:
+            # Create the book
+            book = Book.objects.create(
+                title=title,
+                description=description,
+                group=group,
+                user=user,
+                created_by=user,
+                modified_by=user
+            )
+
+            # Create the homepage
+            homepage = Page.objects.create(
+                book=book,
+                title=homepage_title,
+                content=f"# {homepage_title}\n\nWelcome to {title}.",
+                order_priority=1000,  # High priority to appear first
+                user=user,
+                created_by=user,
+                modified_by=user
+            )
+
+            # Create initial revision
+            homepage.create_revision(
+                user=user,
+                change_summary="Initial page creation"
+            )
+
+            logit.info(f"Created new book '{title}' with homepage for user {user.username}")
+
+            return book, homepage
+
+        except Exception as e:
+            logit.error(f"Failed to create book '{title}': {str(e)}")
+            raise
+
+    @staticmethod
+    def move_page(page, new_parent=None, new_position=None):
+        """
+        Move a page to a new location in the hierarchy
+
+        Handles validation and maintains data integrity
+        """
+        try:
+            old_parent = page.parent
+            old_path = page.full_path
+
+            # Validate the move
+            if new_parent and new_parent.book != page.book:
+                raise ValueError(f"Cannot move page to a different book: from '{page.book.id}' to '{new_parent.book.id}'")
+
+            if new_parent and page._would_create_cycle(new_parent):
+                raise ValueError("Move would create circular reference")
+
+            # Update the page
+            page.parent = new_parent
+
+            if new_position is not None:
+                page.order_priority = new_position
+
+            page.save()
+
+            new_path = page.full_path
+            logit.info(f"Moved page '{page.title}' from '{old_path}' to '{new_path}'")
+
+            return page
+
+        except Exception as e:
+            logit.error(f"Failed to move page '{page.title}': {str(e)}")
+            raise
+
+    @staticmethod
+    def duplicate_page(page, new_title, new_parent=None, include_children=False, user=None):
+        """
+        Create a duplicate of a page, optionally with its children
+        """
+        try:
+            # Create the duplicate
+            duplicate = Page.objects.create(
+                book=page.book,
+                parent=new_parent or page.parent,
+                title=new_title,
+                content=page.content,
+                order_priority=page.order_priority,
+                metadata=page.metadata.copy(),
+                is_published=False,  # Start as draft
+                user=page.user,
+                created_by=user or page.created_by,
+                modified_by=user or page.modified_by
+            )
+
+            # Create initial revision for the duplicate
+            duplicate.create_revision(
+                user=user or page.created_by,
+                change_summary=f"Duplicated from '{page.title}'"
+            )
+
+            # Duplicate children if requested
+            if include_children:
+                for child in page.get_all_children(include_unpublished=True):
+                    DocItService.duplicate_page(
+                        page=child,
+                        new_title=child.title,
+                        new_parent=duplicate,
+                        include_children=True,  # Recursive
+                        user=user
+                    )
+
+            logit.info(f"Duplicated page '{page.title}' as '{new_title}' (children: {include_children})")
+
+            return duplicate
+
+        except Exception as e:
+            logit.error(f"Failed to duplicate page '{page.title}': {str(e)}")
+            raise
+
+    @staticmethod
+    def bulk_update_page_status(pages, is_published, user):
+        """
+        Bulk update publication status for multiple pages
+        """
+        try:
+            updated_count = 0
+
+            for page in pages:
+                if page.is_published != is_published:
+                    page.is_published = is_published
+                    page.modified_by = user
+                    page.save()
+                    updated_count += 1
+
+            status = "published" if is_published else "unpublished"
+            logit.info(f"Bulk updated {updated_count} pages to {status} by {user.username}")
+
+            return updated_count
+
+        except Exception as e:
+            logit.error(f"Failed to bulk update page status: {str(e)}")
+            raise
+
+    @staticmethod
+    def get_book_structure(book, include_unpublished=False):
+        """
+        Get the complete hierarchical structure of a book
+
+        Returns a nested dictionary representing the page tree
+        """
+        def build_tree(pages, parent_id=None):
+            tree = []
+            for page in pages:
+                if page.parent_id == parent_id:
+                    page_data = {
+                        'id': page.id,
+                        'title': page.title,
+                        'slug': page.slug,
+                        'is_published': page.is_published,
+                        'order_priority': page.order_priority,
+                        'children': build_tree(pages, page.id)
+                    }
+                    tree.append(page_data)
+            return tree
+
+        try:
+            queryset = book.pages.all()
+            if not include_unpublished:
+                queryset = queryset.filter(is_published=True)
+
+            pages = list(queryset.order_by('-order_priority', 'title'))
+            structure = build_tree(pages)
+
+            logit.debug(f"Generated structure for book '{book.title}' with {len(pages)} pages")
+
+            return structure
+
+        except Exception as e:
+            logit.error(f"Failed to get book structure for '{book.title}': {str(e)}")
+            raise
+
+    @staticmethod
+    def organize_assets(book, asset_ids_in_order):
+        """
+        Reorder assets within a book based on provided ID list
+        """
+        try:
+            assets = Asset.objects.filter(book=book, id__in=asset_ids_in_order)
+
+            updated_count = 0
+            for index, asset_id in enumerate(asset_ids_in_order):
+                asset = assets.filter(id=asset_id).first()
+                if asset:
+                    new_priority = len(asset_ids_in_order) - index  # Higher index = higher priority
+                    if asset.order_priority != new_priority:
+                        asset.order_priority = new_priority
+                        asset.save()
+                        updated_count += 1
+
+            logit.info(f"Reorganized {updated_count} assets in book '{book.title}'")
+
+            return updated_count
+
+        except Exception as e:
+            logit.error(f"Failed to organize assets for book '{book.title}': {str(e)}")
+            raise
+
+    @staticmethod
+    def cleanup_orphaned_revisions(max_revisions_per_page=50):
+        """
+        Clean up old revisions across all pages to prevent database bloat
+        """
+        try:
+            total_cleaned = 0
+
+            # Get all pages that have more than the max revisions
+            for page in Page.objects.all():
+                revision_count = page.revisions.count()
+
+                if revision_count > max_revisions_per_page:
+                    cleaned = PageRevision.cleanup_old_revisions(page, max_revisions_per_page)
+                    total_cleaned += cleaned
+
+            if total_cleaned > 0:
+                logit.info(f"Cleaned up {total_cleaned} old page revisions")
+
+            return total_cleaned
+
+        except Exception as e:
+            logit.error(f"Failed to cleanup orphaned revisions: {str(e)}")
+            raise
+
+    @staticmethod
+    def get_book_statistics(book):
+        """
+        Get comprehensive statistics for a book
+        """
+        try:
+            stats = {
+                'total_pages': book.get_page_count(),
+                'published_pages': book.pages.filter(is_published=True).count(),
+                'draft_pages': book.pages.filter(is_published=False).count(),
+                'total_assets': book.get_asset_count(),
+                'image_assets': book.assets.filter(file__category='image').count(),
+                'document_assets': book.assets.filter(file__category='document').count(),
+                'total_revisions': PageRevision.objects.filter(page__book=book).count(),
+                'root_pages': book.get_root_pages(published_only=False).count(),
+                'max_depth': 0
+            }
+
+            # Calculate maximum page depth
+            for page in book.pages.all():
+                depth = page.get_depth()
+                if depth > stats['max_depth']:
+                    stats['max_depth'] = depth
+
+            logit.debug(f"Generated statistics for book '{book.title}'")
+
+            return stats
+
+        except Exception as e:
+            logit.error(f"Failed to get statistics for book '{book.title}': {str(e)}")
+            raise
+
+    @staticmethod
+    def validate_book_integrity(book):
+        """
+        Validate the integrity of a book and its pages
+
+        Returns a list of issues found
+        """
+        issues = []
+
+        try:
+            # Check for circular references in page hierarchy
+            for page in book.pages.all():
+                try:
+                    _ = page.full_path  # This will fail if there's a cycle
+                except RecursionError:
+                    issues.append(f"Circular reference detected in page hierarchy: {page.title}")
+
+            # Check for orphaned assets (assets without files)
+            orphaned_assets = book.assets.filter(file__isnull=True)
+            if orphaned_assets.exists():
+                issues.append(f"Found {orphaned_assets.count()} orphaned assets without files")
+
+            # Check for pages with same slug
+            slugs = book.pages.values_list('slug', flat=True)
+            duplicate_slugs = [slug for slug in set(slugs) if slugs.count(slug) > 1]
+            if duplicate_slugs:
+                issues.append(f"Duplicate page slugs found: {duplicate_slugs}")
+
+            logit.info(f"Book integrity check for '{book.title}' found {len(issues)} issues")
+
+            return issues
+
+        except Exception as e:
+            logit.error(f"Failed to validate book integrity for '{book.title}': {str(e)}")
+            raise

mojo/apps/docit/services/markdown.py

@@ -0,0 +1,44 @@
+import mistune
+from pygments import highlight
+from pygments.lexers import get_lexer_by_name
+from pygments.styles import get_style_by_name
+from pygments.formatters import HtmlFormatter
+
+
+class HighlightRenderer(mistune.HTMLRenderer):
+    def block_code(self, code, info=None):
+        if not info:
+            return f'\n<pre>{mistune.escape(code)}</pre>\n'
+        lexer = get_lexer_by_name(info, stripall=True)
+        formatter = HtmlFormatter(
+            linenos=False,
+            cssclass="highlight",
+            style=get_style_by_name("monokai")
+        )
+        return highlight(code, lexer, formatter)
+
+class MarkdownRenderer:
+    _renderer = None
+
+    def __init__(self):
+        if not self._renderer:
+            self._initialize_renderer()
+
+    def _initialize_renderer(self):
+        # plugins = self._discover_plugins()
+        self._renderer = mistune.create_markdown(
+            renderer=HighlightRenderer(escape=False),
+            escape=False,
+            hard_wrap=True,
+            plugins=[]
+        )
+
+    def _discover_plugins(self):
+        # from mojo.apps.docit.markdown_plugins import syntax_highlight
+        plugins = [
+            'table', 'url', 'task_list',
+            'footnotes', 'abbr', 'mark', 'math']
+        return plugins
+
+    def render(self, markdown_text):
+        return self._renderer(markdown_text)

mojo/apps/fileman/backends/s3.py

@@ -425,6 +425,21 @@ class S3StorageBackend(StorageBackend):
 
         return len(errors) == 0, errors
 
+    def test_connection(self):
+        try:
+            self.client.head_bucket(Bucket=self.bucket_name)
+            return True
+        except NoCredentialsError:
+            raise ValueError("Invalid AWS credentials")
+        except ClientError as e:
+            error_code = e.response['Error']['Code']
+            if error_code == '404':
+                raise ValueError(f"S3 bucket '{self.bucket_name}' does not exist")
+            elif error_code == '403':
+                raise ValueError(f"Access denied to S3 bucket '{self.bucket_name}'")
+            else:
+                raise ValueError(f"S3 connection error: {e}")
+
     def make_path_public(self):
         # Get the current bucket policy (if any)
         try:
@@ -488,3 +503,197 @@ class S3StorageBackend(StorageBackend):
                 self.client.download_fileobj(self.bucket_name, file_path, local_file)
         except ClientError as e:
             raise Exception(f"Failed to download file from S3: {e}")
+
+    # -------------------------------
+    # CORS MANAGEMENT FOR DIRECT UPLOADS
+    # -------------------------------
+    def get_cors_configuration(self) -> Optional[Dict[str, Any]]:
+        """
+        Return the current CORS configuration for the bucket, or None if not set.
+        """
+        try:
+            resp = self.client.get_bucket_cors(Bucket=self.bucket_name)
+            return resp
+        except ClientError as e:
+            if e.response.get("Error", {}).get("Code") == "NoSuchCORSConfiguration":
+                return None
+            raise
+
+    def _default_direct_upload_cors_rule(
+        self,
+        allowed_origins: List[str],
+        allowed_methods: Optional[List[str]] = None,
+        allowed_headers: Optional[List[str]] = None,
+        expose_headers: Optional[List[str]] = None,
+        max_age_seconds: int = 3000,
+    ) -> Dict[str, Any]:
+        """
+        Build a single CORS rule suitable for direct uploads via pre-signed PUT/POST.
+        Note: S3 CORS applies at the bucket level, not per-prefix. Access is still
+        enforced by IAM policies and the fact that we use pre-signed URLs.
+        """
+        if not allowed_origins or not any(str(o).strip() for o in allowed_origins):
+            raise ValueError("allowed_origins must contain at least one origin")
+        methods = allowed_methods or ["PUT", "HEAD"]
+        headers = allowed_headers or ["*"]  # simplest and safest for signed uploads
+        expose = expose_headers or ["ETag", "x-amz-request-id", "x-amz-id-2", "x-amz-version-id"]
+
+        return {
+            "CORSRules": [
+                {
+                    "AllowedOrigins": allowed_origins,
+                    "AllowedMethods": methods,
+                    "AllowedHeaders": headers,
+                    "ExposeHeaders": expose,
+                    "MaxAgeSeconds": max_age_seconds,
+                }
+            ]
+        }
+
+    def check_cors_configuration_for_direct_upload(
+        self,
+        allowed_origins: List[str],
+        required_methods: Optional[List[str]] = None,
+        required_headers: Optional[List[str]] = None,
+    ) -> Tuple[bool, List[str], Optional[Dict[str, Any]]]:
+        """
+        Validate current CORS config can support direct uploads from the given origins.
+
+        Returns:
+            (ok, issues, current_config)
+        """
+        if not allowed_origins or not any(str(o).strip() for o in allowed_origins):
+            raise ValueError("allowed_origins must contain at least one origin")
+        issues: List[str] = []
+        config = self.get_cors_configuration()
+        if config is None:
+            return False, ["No CORS configuration set on this bucket."], None
+
+        if required_methods is None:
+            required_methods = ["POST", "HEAD"] if self.server_side_encryption else ["PUT", "HEAD"]
+        required_methods = [m.upper() for m in required_methods]
+        # For PUT we often need Content-Type. For POST, headers are not required (fields are in the form).
+        # Using "*" for AllowedHeaders is the simplest and reduces edge cases.
+        if required_headers is None:
+            required_headers = [] if self.server_side_encryption else ["content-type"]
+        required_headers = [h.lower() for h in required_headers]
+
+        # Flatten rules
+        cors_rules: List[Dict[str, Any]] = config.get("CORSRules", [])
+
+        def origin_is_covered(origin: str) -> bool:
+            for rule in cors_rules:
+                origins = rule.get("AllowedOrigins", [])
+                if "*" in origins or origin in origins:
+                    # methods
+                    methods = [m.upper() for m in rule.get("AllowedMethods", [])]
+                    if not all(m in methods for m in required_methods):
+                        continue
+                    # headers
+                    hdrs = [h.lower() for h in rule.get("AllowedHeaders", [])]
+                    if "*" in hdrs:
+                        return True
+                    if not all(h in hdrs for h in required_headers):
+                        continue
+                    return True
+            return False
+
+        for origin in allowed_origins:
+            if not origin_is_covered(origin):
+                issues.append(f"Origin not covered for direct upload: {origin}")
+
+        return (len(issues) == 0), issues, config
+
+    def update_cors_configuration_for_direct_upload(
+        self,
+        allowed_origins: List[str],
+        allowed_methods: Optional[List[str]] = None,
+        allowed_headers: Optional[List[str]] = None,
+        expose_headers: Optional[List[str]] = None,
+        max_age_seconds: int = 3000,
+        merge: bool = True,
+    ) -> Dict[str, Any]:
+        """
+        Ensure CORS allows direct uploads from allowed_origins.
+        If merge=True, append our rule to any existing rules instead of replacing.
+        """
+        # Validate input
+        if not allowed_origins or not any(str(o).strip() for o in allowed_origins):
+            raise ValueError("allowed_origins must contain at least one origin")
+        # If current config already satisfies requirements, do nothing
+        ok, issues, current = self.check_cors_configuration_for_direct_upload(
+            allowed_origins=allowed_origins,
+            required_methods=allowed_methods,
+            required_headers=allowed_headers,
+        )
+        if ok:
+            return {
+                "changed": False,
+                "message": "Existing CORS configuration already supports direct uploads.",
+                "issues": [],
+                "applied_configuration": current,
+            }
+
+        new_rule_config = self._default_direct_upload_cors_rule(
+            allowed_origins=allowed_origins,
+            allowed_methods=allowed_methods or (["POST", "HEAD"] if self.server_side_encryption else ["PUT", "HEAD"]),
+            allowed_headers=allowed_headers or ["*"],
+            expose_headers=expose_headers,
+            max_age_seconds=max_age_seconds,
+        )
+
+        if merge and current:
+            merged = dict(CORSRules=[*current.get("CORSRules", []), *new_rule_config["CORSRules"]])
+            self.client.put_bucket_cors(Bucket=self.bucket_name, CORSConfiguration=merged)
+            applied = merged
+        else:
+            # Replace entirely with our single rule
+            self.client.put_bucket_cors(Bucket=self.bucket_name, CORSConfiguration=new_rule_config)
+            applied = new_rule_config
+
+        return {
+            "changed": True,
+            "message": "CORS configuration updated to support direct uploads.",
+            "issues": issues,
+            "applied_configuration": applied,
+        }
+
+    def ensure_cors_for_direct_upload(
+        self,
+        allowed_origins: List[str],
+        allowed_methods: Optional[List[str]] = None,
+        allowed_headers: Optional[List[str]] = None,
+        expose_headers: Optional[List[str]] = None,
+        max_age_seconds: int = 3000,
+        merge: bool = True,
+    ) -> Dict[str, Any]:
+        """
+        Convenience wrapper that checks and updates CORS as needed.
+
+        Example:
+            backend.ensure_cors_for_direct_upload(
+                ["http://localhost:3000", "https://your-prod-domain.com"]
+            )
+        """
+        if not allowed_origins or not any(str(o).strip() for o in allowed_origins):
+            raise ValueError("allowed_origins must contain at least one origin")
+        result = self.update_cors_configuration_for_direct_upload(
+            allowed_origins=allowed_origins,
+            allowed_methods=allowed_methods,
+            allowed_headers=allowed_headers,
+            expose_headers=expose_headers,
+            max_age_seconds=max_age_seconds,
+            merge=merge,
+        )
+        # Re-check to confirm
+        ok, issues, current = self.check_cors_configuration_for_direct_upload(
+            allowed_origins=allowed_origins,
+            required_methods=allowed_methods,
+            required_headers=allowed_headers,
+        )
+        result.update({
+            "verified": ok,
+            "post_update_issues": issues,
+            "current_configuration": current,
+        })
+        return result

mojo/apps/fileman/models/file.py

@@ -24,6 +24,7 @@ class File(models.Model, MojoModel):
         DEFAULT_SORT = "-created"
         VIEW_PERMS = ["view_fileman", "manage_files"]
         SEARCH_FIELDS = ["filename", "content_type"]
+        POST_SAVE_ACTIONS = ["action"]
         SEARCH_TERMS = [
             "filename",  "content_type",
             ("group", "group__name"),
@@ -43,7 +44,7 @@ class File(models.Model, MojoModel):
             },
             "basic": {
                 "fields": ["id", "filename", "content_type", "category"],
-                "extra": ["url", "renditions"],
+                "extra": ["url", "thumbnail"],
             },
             "default": {
                 "extra": ["url", "renditions"],
@@ -291,6 +292,16 @@ class File(models.Model, MojoModel):
     def url(self):
         return self.generate_download_url()
 
+    @property
+    def thumbnail(self):
+        r = self.get_rendition_by_role('thumbnail')
+        if r:
+            return r.url
+        return None
+
+    def get_rendition_by_role(self, role):
+        return self.file_renditions.filter(role=role).first()
+
     def generate_download_url(self):
         if self.download_url:
             return self.download_url
@@ -299,13 +310,13 @@ class File(models.Model, MojoModel):
             return self.download_url
         return self.file_manager.backend.get_url(self.storage_file_path, self.get_setting("urls_expire_in", 3600))
 
-    def set_action(self, action):
+    def on_action_action(self, action):
         if action == "mark_as_completed":
-            self.mark_as_completed()
+            self.mark_as_completed(commit=True)
         elif action == "mark_as_failed":
-            self.mark_as_failed()
+            self.mark_as_failed(commit=True)
         elif action == "mark_as_uploading":
-            self.mark_as_uploading()
+            self.mark_as_uploading(commit=True)
 
     def set_filename(self, filename):
         self.filename = filename
@@ -421,17 +432,42 @@ class File(models.Model, MojoModel):
     def on_rest_related_save(cls, related_instance, related_field_name, field_value, current_instance=None):
         # this allows us to handle json posts with inline base64 file data
         if isinstance(field_value, str):
-            # assume base64 encoded data
-            file_bytes = base64.b64decode(field_value)
-            mime_type = magic.from_buffer(file_bytes, mime=True)
-            ext = mimetypes.guess_extension(mime_type)
+            mime_type = None
+            b64_data = field_value
+
+            # Check for and parse Data URL scheme (e.g., "data:image/png;base64,iVBOR...")
+            if field_value.startswith('data:') and ',' in field_value:
+                header, b64_data = field_value.split(',', 1)
+                mime_type = header.split(';')[0].split(':')[1]
+
+            # Fix incorrect padding, which can occur with base64 strings from web clients
+            missing_padding = len(b64_data) % 4
+            if missing_padding:
+                b64_data += '=' * (4 - missing_padding)
+
+            try:
+                file_bytes = base64.b64decode(b64_data)
+            except (TypeError, base64.binascii.Error):
+                # If decoding fails, it's not a valid base64 string.
+                # In a real app, you might want to raise a validation error here.
+                return
+
+            # If mime_type wasn't in the data URL, detect it with python-magic
+            if not mime_type:
+                mime_type = magic.from_buffer(file_bytes, mime=True)
+
+            # Safely guess the extension, defaulting to an empty string if unknown
+            ext = mimetypes.guess_extension(mime_type) or ''
+
             file_obj = io.BytesIO(file_bytes)
             file_obj.name = f"{related_field_name}{ext}"
             file_obj.content_type = mime_type
             file_obj.size = len(file_bytes)
+
             # now we need to upload the file
             instance = cls.create_from_file(file_obj, file_obj.name)
             setattr(related_instance, related_field_name, instance)
+
         elif isinstance(field_value, int):
             # assume file id
             instance = File.objects.get(id=field_value)