feat: complete monorepo structure with frontend and shared resources

- Add complete backend/ directory with full Django application
- Add frontend/ directory with Vite + TypeScript setup ready for Next.js
- Add comprehensive shared/ directory with:
  - Complete documentation and memory-bank archives
  - Media files and avatars (letters, park/ride images)
  - Deployment scripts and automation tools
  - Shared types and utilities
- Add architecture/ directory with migration guides
- Configure pnpm workspace for monorepo development
- Update .gitignore to exclude .django_tailwind_cli/ build artifacts
- Preserve all historical documentation in shared/docs/memory-bank/
- Set up proper structure for full-stack development with shared resources

backend/apps/moderation/services.py

@@ -0,0 +1,230 @@
+"""
+Services for moderation functionality.
+Following Django styleguide pattern for business logic encapsulation.
+"""
+
+from typing import Optional, Dict, Any, Union
+from django.db import transaction
+from django.utils import timezone
+from django.contrib.auth.models import User
+from django.db.models import QuerySet
+
+from .models import EditSubmission
+
+
+class ModerationService:
+    """Service for handling content moderation workflows."""
+
+    @staticmethod
+    def approve_submission(
+        *, submission_id: int, moderator: User, notes: Optional[str] = None
+    ) -> Union[object, None]:
+        """
+        Approve a content submission and apply changes.
+
+        Args:
+            submission_id: ID of the submission to approve
+            moderator: User performing the approval
+            notes: Optional notes about the approval
+
+        Returns:
+            The created/updated object or None if approval failed
+
+        Raises:
+            EditSubmission.DoesNotExist: If submission doesn't exist
+            ValidationError: If submission data is invalid
+            ValueError: If submission cannot be processed
+        """
+        with transaction.atomic():
+            submission = EditSubmission.objects.select_for_update().get(
+                id=submission_id
+            )
+
+            if submission.status != "PENDING":
+                raise ValueError(f"Submission {submission_id} is not pending approval")
+
+            try:
+                # Call the model's approve method which handles the business
+                # logic
+                obj = submission.approve(moderator)
+
+                # Add moderator notes if provided
+                if notes:
+                    if submission.notes:
+                        submission.notes += f"\n[Moderator]: {notes}"
+                    else:
+                        submission.notes = f"[Moderator]: {notes}"
+                    submission.save()
+
+                return obj
+
+            except Exception as e:
+                # Mark as rejected on any error
+                submission.status = "REJECTED"
+                submission.handled_by = moderator
+                submission.handled_at = timezone.now()
+                submission.notes = f"Approval failed: {str(e)}"
+                submission.save()
+                raise
+
+    @staticmethod
+    def reject_submission(
+        *, submission_id: int, moderator: User, reason: str
+    ) -> EditSubmission:
+        """
+        Reject a content submission.
+
+        Args:
+            submission_id: ID of the submission to reject
+            moderator: User performing the rejection
+            reason: Reason for rejection
+
+        Returns:
+            Updated submission object
+
+        Raises:
+            EditSubmission.DoesNotExist: If submission doesn't exist
+            ValueError: If submission cannot be rejected
+        """
+        with transaction.atomic():
+            submission = EditSubmission.objects.select_for_update().get(
+                id=submission_id
+            )
+
+            if submission.status != "PENDING":
+                raise ValueError(f"Submission {submission_id} is not pending review")
+
+            submission.status = "REJECTED"
+            submission.handled_by = moderator
+            submission.handled_at = timezone.now()
+            submission.notes = f"Rejected: {reason}"
+
+            # Call full_clean before saving - CRITICAL STYLEGUIDE FIX
+            submission.full_clean()
+            submission.save()
+
+            return submission
+
+    @staticmethod
+    def create_edit_submission(
+        *,
+        content_object: object,
+        changes: Dict[str, Any],
+        submitter: User,
+        submission_type: str = "UPDATE",
+        notes: Optional[str] = None,
+    ) -> EditSubmission:
+        """
+        Create a new edit submission for moderation.
+
+        Args:
+            content_object: The object being edited
+            changes: Dictionary of field changes
+            submitter: User submitting the changes
+            submission_type: Type of submission ("CREATE" or "UPDATE")
+            notes: Optional notes about the submission
+
+        Returns:
+            Created EditSubmission object
+
+        Raises:
+            ValidationError: If submission data is invalid
+        """
+        submission = EditSubmission(
+            content_object=content_object,
+            changes=changes,
+            submitted_by=submitter,
+            submission_type=submission_type,
+            notes=notes or "",
+        )
+
+        # Call full_clean before saving - CRITICAL STYLEGUIDE FIX
+        submission.full_clean()
+        submission.save()
+
+        return submission
+
+    @staticmethod
+    def update_submission_changes(
+        *,
+        submission_id: int,
+        moderator_changes: Dict[str, Any],
+        moderator: User,
+    ) -> EditSubmission:
+        """
+        Update submission with moderator changes before approval.
+
+        Args:
+            submission_id: ID of the submission to update
+            moderator_changes: Dictionary of moderator modifications
+            moderator: User making the changes
+
+        Returns:
+            Updated submission object
+
+        Raises:
+            EditSubmission.DoesNotExist: If submission doesn't exist
+            ValueError: If submission cannot be modified
+        """
+        with transaction.atomic():
+            submission = EditSubmission.objects.select_for_update().get(
+                id=submission_id
+            )
+
+            if submission.status != "PENDING":
+                raise ValueError(f"Submission {submission_id} is not pending review")
+
+            submission.moderator_changes = moderator_changes
+
+            # Add note about moderator changes
+            note = f"[Moderator changes by {moderator.username}]"
+            if submission.notes:
+                submission.notes += f"\n{note}"
+            else:
+                submission.notes = note
+
+            # Call full_clean before saving - CRITICAL STYLEGUIDE FIX
+            submission.full_clean()
+            submission.save()
+
+            return submission
+
+    @staticmethod
+    def get_pending_submissions_for_moderator(
+        *,
+        moderator: User,
+        content_type: Optional[str] = None,
+        limit: Optional[int] = None,
+    ) -> QuerySet:
+        """
+        Get pending submissions for a moderator to review.
+
+        Args:
+            moderator: The moderator user
+            content_type: Optional filter by content type
+            limit: Maximum number of submissions to return
+
+        Returns:
+            QuerySet of pending submissions
+        """
+        from .selectors import pending_submissions_for_review
+
+        return pending_submissions_for_review(content_type=content_type, limit=limit)
+
+    @staticmethod
+    def get_submission_statistics(
+        *, days: int = 30, moderator: Optional[User] = None
+    ) -> Dict[str, Any]:
+        """
+        Get moderation statistics for a time period.
+
+        Args:
+            days: Number of days to analyze
+            moderator: Optional filter by specific moderator
+
+        Returns:
+            Dictionary containing moderation statistics
+        """
+        from .selectors import moderation_statistics_summary
+
+        return moderation_statistics_summary(days=days, moderator=moderator)