feat: major API restructure and Vue.js frontend integration

- Centralize API endpoints in dedicated api app with v1 versioning
- Remove individual API modules from parks and rides apps
- Add event tracking system with analytics functionality
- Integrate Vue.js frontend with Tailwind CSS v4 and TypeScript
- Add comprehensive database migrations for event tracking
- Implement user authentication and social provider setup
- Add API schema documentation and serializers
- Configure development environment with shared scripts
- Update project structure for monorepo with frontend/backend separation

backend/apps/accounts/admin.py

@@ -2,7 +2,14 @@ from django.contrib import admin
 from django.contrib.auth.admin import UserAdmin
 from django.utils.html import format_html
 from django.contrib.auth.models import Group
-from .models import User, UserProfile, EmailVerification, TopList, TopListItem
+from .models import (
+    User,
+    UserProfile,
+    EmailVerification,
+    PasswordReset,
+    TopList,
+    TopListItem,
+)
 
 
 class UserProfileInline(admin.StackedInline):
@@ -280,3 +287,74 @@ class TopListItemAdmin(admin.ModelAdmin):
         ("List Information", {"fields": ("top_list", "rank")}),
         ("Item Details", {"fields": ("content_type", "object_id", "notes")}),
     )
+
+
+@admin.register(PasswordReset)
+class PasswordResetAdmin(admin.ModelAdmin):
+    """Admin interface for password reset tokens"""
+
+    list_display = (
+        "user",
+        "created_at",
+        "expires_at",
+        "is_expired",
+        "used",
+    )
+    list_filter = (
+        "used",
+        "created_at",
+        "expires_at",
+    )
+    search_fields = (
+        "user__username",
+        "user__email",
+        "token",
+    )
+    readonly_fields = (
+        "token",
+        "created_at",
+        "expires_at",
+    )
+    date_hierarchy = "created_at"
+    ordering = ("-created_at",)
+
+    fieldsets = (
+        (
+            "Reset Details",
+            {
+                "fields": (
+                    "user",
+                    "token",
+                    "used",
+                )
+            },
+        ),
+        (
+            "Timing",
+            {
+                "fields": (
+                    "created_at",
+                    "expires_at",
+                )
+            },
+        ),
+    )
+
+    @admin.display(description="Status", boolean=True)
+    def is_expired(self, obj):
+        """Display expiration status with color coding"""
+        from django.utils import timezone
+
+        if obj.used:
+            return format_html('<span style="color: blue;">Used</span>')
+        elif timezone.now() > obj.expires_at:
+            return format_html('<span style="color: red;">Expired</span>')
+        return format_html('<span style="color: green;">Valid</span>')
+
+    def has_add_permission(self, request):
+        """Disable manual creation of password reset tokens"""
+        return False
+
+    def has_change_permission(self, request, obj=None):
+        """Allow viewing but restrict editing of password reset tokens"""
+        return getattr(request.user, "is_superuser", False)

backend/apps/accounts/management/commands/setup_social_providers.py

@@ -0,0 +1,51 @@
+from django.core.management.base import BaseCommand
+from allauth.socialaccount.models import SocialApp
+from django.contrib.sites.models import Site
+
+
+class Command(BaseCommand):
+    help = 'Set up social authentication providers for development'
+
+    def handle(self, *args, **options):
+        # Get the current site
+        site = Site.objects.get_current()
+        self.stdout.write(f'Setting up social providers for site: {site}')
+
+        # Clear existing social apps to avoid duplicates
+        deleted_count = SocialApp.objects.all().delete()[0]
+        self.stdout.write(f'Cleared {deleted_count} existing social apps')
+
+        # Create Google social app
+        google_app = SocialApp.objects.create(
+            provider='google',
+            name='Google',
+            client_id='demo-google-client-id.apps.googleusercontent.com',
+            secret='demo-google-client-secret',
+            key='',
+        )
+        google_app.sites.add(site)
+        self.stdout.write(
+            self.style.SUCCESS('✅ Created Google social app')
+        )
+
+        # Create Discord social app
+        discord_app = SocialApp.objects.create(
+            provider='discord',
+            name='Discord',
+            client_id='demo-discord-client-id',
+            secret='demo-discord-client-secret',
+            key='',
+        )
+        discord_app.sites.add(site)
+        self.stdout.write(
+            self.style.SUCCESS('✅ Created Discord social app')
+        )
+
+        # List all social apps
+        self.stdout.write('\nConfigured social apps:')
+        for app in SocialApp.objects.all():
+            self.stdout.write(f'- {app.name} ({app.provider}): {app.client_id}')
+
+        self.stdout.write(
+            self.style.SUCCESS(f'\nTotal social apps: {SocialApp.objects.count()}')
+        )

backend/apps/accounts/migrations/0002_remove_toplistevent_pgh_context_and_more.py

@@ -0,0 +1,64 @@
+# Generated by Django 5.2.5 on 2025-08-24 18:23
+
+import pgtrigger.migrations
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("accounts", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name="toplistevent",
+            name="pgh_context",
+        ),
+        migrations.RemoveField(
+            model_name="toplistevent",
+            name="pgh_obj",
+        ),
+        migrations.RemoveField(
+            model_name="toplistevent",
+            name="user",
+        ),
+        migrations.RemoveField(
+            model_name="toplistitemevent",
+            name="content_type",
+        ),
+        migrations.RemoveField(
+            model_name="toplistitemevent",
+            name="pgh_context",
+        ),
+        migrations.RemoveField(
+            model_name="toplistitemevent",
+            name="pgh_obj",
+        ),
+        migrations.RemoveField(
+            model_name="toplistitemevent",
+            name="top_list",
+        ),
+        pgtrigger.migrations.RemoveTrigger(
+            model_name="toplist",
+            name="insert_insert",
+        ),
+        pgtrigger.migrations.RemoveTrigger(
+            model_name="toplist",
+            name="update_update",
+        ),
+        pgtrigger.migrations.RemoveTrigger(
+            model_name="toplistitem",
+            name="insert_insert",
+        ),
+        pgtrigger.migrations.RemoveTrigger(
+            model_name="toplistitem",
+            name="update_update",
+        ),
+        migrations.DeleteModel(
+            name="TopListEvent",
+        ),
+        migrations.DeleteModel(
+            name="TopListItemEvent",
+        ),
+    ]

backend/apps/accounts/migrations/0003_emailverificationevent_passwordresetevent_userevent_and_more.py

@@ -0,0 +1,439 @@
+# Generated by Django 5.2.5 on 2025-08-24 19:11
+
+import django.contrib.auth.validators
+import django.db.models.deletion
+import django.utils.timezone
+import pgtrigger.compiler
+import pgtrigger.migrations
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("accounts", "0002_remove_toplistevent_pgh_context_and_more"),
+        ("pghistory", "0007_auto_20250421_0444"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="EmailVerificationEvent",
+            fields=[
+                ("pgh_id", models.AutoField(primary_key=True, serialize=False)),
+                ("pgh_created_at", models.DateTimeField(auto_now_add=True)),
+                ("pgh_label", models.TextField(help_text="The event label.")),
+                ("id", models.BigIntegerField()),
+                ("token", models.CharField(max_length=64)),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("last_sent", models.DateTimeField(auto_now_add=True)),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+        migrations.CreateModel(
+            name="PasswordResetEvent",
+            fields=[
+                ("pgh_id", models.AutoField(primary_key=True, serialize=False)),
+                ("pgh_created_at", models.DateTimeField(auto_now_add=True)),
+                ("pgh_label", models.TextField(help_text="The event label.")),
+                ("id", models.BigIntegerField()),
+                ("token", models.CharField(max_length=64)),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("expires_at", models.DateTimeField()),
+                ("used", models.BooleanField(default=False)),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+        migrations.CreateModel(
+            name="UserEvent",
+            fields=[
+                ("pgh_id", models.AutoField(primary_key=True, serialize=False)),
+                ("pgh_created_at", models.DateTimeField(auto_now_add=True)),
+                ("pgh_label", models.TextField(help_text="The event label.")),
+                ("id", models.BigIntegerField()),
+                ("password", models.CharField(max_length=128, verbose_name="password")),
+                (
+                    "last_login",
+                    models.DateTimeField(
+                        blank=True, null=True, verbose_name="last login"
+                    ),
+                ),
+                (
+                    "is_superuser",
+                    models.BooleanField(
+                        default=False,
+                        help_text="Designates that this user has all permissions without explicitly assigning them.",
+                        verbose_name="superuser status",
+                    ),
+                ),
+                (
+                    "username",
+                    models.CharField(
+                        error_messages={
+                            "unique": "A user with that username already exists."
+                        },
+                        help_text="Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only.",
+                        max_length=150,
+                        validators=[
+                            django.contrib.auth.validators.UnicodeUsernameValidator()
+                        ],
+                        verbose_name="username",
+                    ),
+                ),
+                (
+                    "first_name",
+                    models.CharField(
+                        blank=True, max_length=150, verbose_name="first name"
+                    ),
+                ),
+                (
+                    "last_name",
+                    models.CharField(
+                        blank=True, max_length=150, verbose_name="last name"
+                    ),
+                ),
+                (
+                    "email",
+                    models.EmailField(
+                        blank=True, max_length=254, verbose_name="email address"
+                    ),
+                ),
+                (
+                    "is_staff",
+                    models.BooleanField(
+                        default=False,
+                        help_text="Designates whether the user can log into this admin site.",
+                        verbose_name="staff status",
+                    ),
+                ),
+                (
+                    "is_active",
+                    models.BooleanField(
+                        default=True,
+                        help_text="Designates whether this user should be treated as active. Unselect this instead of deleting accounts.",
+                        verbose_name="active",
+                    ),
+                ),
+                (
+                    "date_joined",
+                    models.DateTimeField(
+                        default=django.utils.timezone.now, verbose_name="date joined"
+                    ),
+                ),
+                (
+                    "user_id",
+                    models.CharField(
+                        editable=False,
+                        help_text="Unique identifier for this user that remains constant even if the username changes",
+                        max_length=10,
+                    ),
+                ),
+                (
+                    "role",
+                    models.CharField(
+                        choices=[
+                            ("USER", "User"),
+                            ("MODERATOR", "Moderator"),
+                            ("ADMIN", "Admin"),
+                            ("SUPERUSER", "Superuser"),
+                        ],
+                        default="USER",
+                        max_length=10,
+                    ),
+                ),
+                ("is_banned", models.BooleanField(default=False)),
+                ("ban_reason", models.TextField(blank=True)),
+                ("ban_date", models.DateTimeField(blank=True, null=True)),
+                (
+                    "pending_email",
+                    models.EmailField(blank=True, max_length=254, null=True),
+                ),
+                (
+                    "theme_preference",
+                    models.CharField(
+                        choices=[("light", "Light"), ("dark", "Dark")],
+                        default="light",
+                        max_length=5,
+                    ),
+                ),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+        migrations.CreateModel(
+            name="UserProfileEvent",
+            fields=[
+                ("pgh_id", models.AutoField(primary_key=True, serialize=False)),
+                ("pgh_created_at", models.DateTimeField(auto_now_add=True)),
+                ("pgh_label", models.TextField(help_text="The event label.")),
+                ("id", models.BigIntegerField()),
+                (
+                    "profile_id",
+                    models.CharField(
+                        editable=False,
+                        help_text="Unique identifier for this profile that remains constant",
+                        max_length=10,
+                    ),
+                ),
+                (
+                    "display_name",
+                    models.CharField(
+                        help_text="This is the name that will be displayed on the site",
+                        max_length=50,
+                    ),
+                ),
+                ("avatar", models.ImageField(blank=True, upload_to="avatars/")),
+                ("pronouns", models.CharField(blank=True, max_length=50)),
+                ("bio", models.TextField(blank=True, max_length=500)),
+                ("twitter", models.URLField(blank=True)),
+                ("instagram", models.URLField(blank=True)),
+                ("youtube", models.URLField(blank=True)),
+                ("discord", models.CharField(blank=True, max_length=100)),
+                ("coaster_credits", models.IntegerField(default=0)),
+                ("dark_ride_credits", models.IntegerField(default=0)),
+                ("flat_ride_credits", models.IntegerField(default=0)),
+                ("water_ride_credits", models.IntegerField(default=0)),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="emailverification",
+            trigger=pgtrigger.compiler.Trigger(
+                name="insert_insert",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    func='INSERT INTO "accounts_emailverificationevent" ("created_at", "id", "last_sent", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "token", "user_id") VALUES (NEW."created_at", NEW."id", NEW."last_sent", _pgh_attach_context(), NOW(), \'insert\', NEW."id", NEW."token", NEW."user_id"); RETURN NULL;',
+                    hash="c485bf0cd5bea8a05ef2d4ae309b60eff42abd84",
+                    operation="INSERT",
+                    pgid="pgtrigger_insert_insert_53748",
+                    table="accounts_emailverification",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="emailverification",
+            trigger=pgtrigger.compiler.Trigger(
+                name="update_update",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    condition="WHEN (OLD.* IS DISTINCT FROM NEW.*)",
+                    func='INSERT INTO "accounts_emailverificationevent" ("created_at", "id", "last_sent", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "token", "user_id") VALUES (NEW."created_at", NEW."id", NEW."last_sent", _pgh_attach_context(), NOW(), \'update\', NEW."id", NEW."token", NEW."user_id"); RETURN NULL;',
+                    hash="c20942bdc0713db74310da8da8c3138ca4c3bba9",
+                    operation="UPDATE",
+                    pgid="pgtrigger_update_update_7a2a8",
+                    table="accounts_emailverification",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="passwordreset",
+            trigger=pgtrigger.compiler.Trigger(
+                name="insert_insert",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    func='INSERT INTO "accounts_passwordresetevent" ("created_at", "expires_at", "id", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "token", "used", "user_id") VALUES (NEW."created_at", NEW."expires_at", NEW."id", _pgh_attach_context(), NOW(), \'insert\', NEW."id", NEW."token", NEW."used", NEW."user_id"); RETURN NULL;',
+                    hash="496ac059671b25460cdf2ca20d0e43b14d417a26",
+                    operation="INSERT",
+                    pgid="pgtrigger_insert_insert_d2b72",
+                    table="accounts_passwordreset",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="passwordreset",
+            trigger=pgtrigger.compiler.Trigger(
+                name="update_update",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    condition="WHEN (OLD.* IS DISTINCT FROM NEW.*)",
+                    func='INSERT INTO "accounts_passwordresetevent" ("created_at", "expires_at", "id", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "token", "used", "user_id") VALUES (NEW."created_at", NEW."expires_at", NEW."id", _pgh_attach_context(), NOW(), \'update\', NEW."id", NEW."token", NEW."used", NEW."user_id"); RETURN NULL;',
+                    hash="c40acc416f85287b4a6fcc06724626707df90016",
+                    operation="UPDATE",
+                    pgid="pgtrigger_update_update_526d2",
+                    table="accounts_passwordreset",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="user",
+            trigger=pgtrigger.compiler.Trigger(
+                name="insert_insert",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    func='INSERT INTO "accounts_userevent" ("ban_date", "ban_reason", "date_joined", "email", "first_name", "id", "is_active", "is_banned", "is_staff", "is_superuser", "last_login", "last_name", "password", "pending_email", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "role", "theme_preference", "user_id", "username") VALUES (NEW."ban_date", NEW."ban_reason", NEW."date_joined", NEW."email", NEW."first_name", NEW."id", NEW."is_active", NEW."is_banned", NEW."is_staff", NEW."is_superuser", NEW."last_login", NEW."last_name", NEW."password", NEW."pending_email", _pgh_attach_context(), NOW(), \'insert\', NEW."id", NEW."role", NEW."theme_preference", NEW."user_id", NEW."username"); RETURN NULL;',
+                    hash="b6992f02a4c1135fef9527e3f1ed330e2e626267",
+                    operation="INSERT",
+                    pgid="pgtrigger_insert_insert_3867c",
+                    table="accounts_user",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="user",
+            trigger=pgtrigger.compiler.Trigger(
+                name="update_update",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    condition="WHEN (OLD.* IS DISTINCT FROM NEW.*)",
+                    func='INSERT INTO "accounts_userevent" ("ban_date", "ban_reason", "date_joined", "email", "first_name", "id", "is_active", "is_banned", "is_staff", "is_superuser", "last_login", "last_name", "password", "pending_email", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "role", "theme_preference", "user_id", "username") VALUES (NEW."ban_date", NEW."ban_reason", NEW."date_joined", NEW."email", NEW."first_name", NEW."id", NEW."is_active", NEW."is_banned", NEW."is_staff", NEW."is_superuser", NEW."last_login", NEW."last_name", NEW."password", NEW."pending_email", _pgh_attach_context(), NOW(), \'update\', NEW."id", NEW."role", NEW."theme_preference", NEW."user_id", NEW."username"); RETURN NULL;',
+                    hash="6c3271b9f184dc137da7b9e42b0ae9f72d47c9c2",
+                    operation="UPDATE",
+                    pgid="pgtrigger_update_update_0e890",
+                    table="accounts_user",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="userprofile",
+            trigger=pgtrigger.compiler.Trigger(
+                name="insert_insert",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    func='INSERT INTO "accounts_userprofileevent" ("avatar", "bio", "coaster_credits", "dark_ride_credits", "discord", "display_name", "flat_ride_credits", "id", "instagram", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "profile_id", "pronouns", "twitter", "user_id", "water_ride_credits", "youtube") VALUES (NEW."avatar", NEW."bio", NEW."coaster_credits", NEW."dark_ride_credits", NEW."discord", NEW."display_name", NEW."flat_ride_credits", NEW."id", NEW."instagram", _pgh_attach_context(), NOW(), \'insert\', NEW."id", NEW."profile_id", NEW."pronouns", NEW."twitter", NEW."user_id", NEW."water_ride_credits", NEW."youtube"); RETURN NULL;',
+                    hash="af6a89f13ff879d978a1154bbcf4664de0fcf913",
+                    operation="INSERT",
+                    pgid="pgtrigger_insert_insert_c09d7",
+                    table="accounts_userprofile",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="userprofile",
+            trigger=pgtrigger.compiler.Trigger(
+                name="update_update",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    condition="WHEN (OLD.* IS DISTINCT FROM NEW.*)",
+                    func='INSERT INTO "accounts_userprofileevent" ("avatar", "bio", "coaster_credits", "dark_ride_credits", "discord", "display_name", "flat_ride_credits", "id", "instagram", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "profile_id", "pronouns", "twitter", "user_id", "water_ride_credits", "youtube") VALUES (NEW."avatar", NEW."bio", NEW."coaster_credits", NEW."dark_ride_credits", NEW."discord", NEW."display_name", NEW."flat_ride_credits", NEW."id", NEW."instagram", _pgh_attach_context(), NOW(), \'update\', NEW."id", NEW."profile_id", NEW."pronouns", NEW."twitter", NEW."user_id", NEW."water_ride_credits", NEW."youtube"); RETURN NULL;',
+                    hash="37e99b5cc374ec0a3fc44d2482b411cba63fa84d",
+                    operation="UPDATE",
+                    pgid="pgtrigger_update_update_87ef6",
+                    table="accounts_userprofile",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        migrations.AddField(
+            model_name="emailverificationevent",
+            name="pgh_context",
+            field=models.ForeignKey(
+                db_constraint=False,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                to="pghistory.context",
+            ),
+        ),
+        migrations.AddField(
+            model_name="emailverificationevent",
+            name="pgh_obj",
+            field=models.ForeignKey(
+                db_constraint=False,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="events",
+                to="accounts.emailverification",
+            ),
+        ),
+        migrations.AddField(
+            model_name="emailverificationevent",
+            name="user",
+            field=models.ForeignKey(
+                db_constraint=False,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                related_query_name="+",
+                to=settings.AUTH_USER_MODEL,
+            ),
+        ),
+        migrations.AddField(
+            model_name="passwordresetevent",
+            name="pgh_context",
+            field=models.ForeignKey(
+                db_constraint=False,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                to="pghistory.context",
+            ),
+        ),
+        migrations.AddField(
+            model_name="passwordresetevent",
+            name="pgh_obj",
+            field=models.ForeignKey(
+                db_constraint=False,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="events",
+                to="accounts.passwordreset",
+            ),
+        ),
+        migrations.AddField(
+            model_name="passwordresetevent",
+            name="user",
+            field=models.ForeignKey(
+                db_constraint=False,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                related_query_name="+",
+                to=settings.AUTH_USER_MODEL,
+            ),
+        ),
+        migrations.AddField(
+            model_name="userevent",
+            name="pgh_context",
+            field=models.ForeignKey(
+                db_constraint=False,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                to="pghistory.context",
+            ),
+        ),
+        migrations.AddField(
+            model_name="userevent",
+            name="pgh_obj",
+            field=models.ForeignKey(
+                db_constraint=False,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="events",
+                to=settings.AUTH_USER_MODEL,
+            ),
+        ),
+        migrations.AddField(
+            model_name="userprofileevent",
+            name="pgh_context",
+            field=models.ForeignKey(
+                db_constraint=False,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                to="pghistory.context",
+            ),
+        ),
+        migrations.AddField(
+            model_name="userprofileevent",
+            name="pgh_obj",
+            field=models.ForeignKey(
+                db_constraint=False,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="events",
+                to="accounts.userprofile",
+            ),
+        ),
+        migrations.AddField(
+            model_name="userprofileevent",
+            name="user",
+            field=models.ForeignKey(
+                db_constraint=False,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                related_query_name="+",
+                to=settings.AUTH_USER_MODEL,
+            ),
+        ),
+    ]

backend/apps/accounts/models.py

@@ -5,8 +5,7 @@ from django.utils.translation import gettext_lazy as _
 import os
 import secrets
 from apps.core.history import TrackedModel
-
-# import pghistory
+import pghistory
 
 
 def generate_random_id(model_class, id_field):
@@ -23,6 +22,7 @@ def generate_random_id(model_class, id_field):
             return new_id
 
 
+@pghistory.track()
 class User(AbstractUser):
     class Roles(models.TextChoices):
         USER = "USER", _("User")
@@ -79,6 +79,7 @@ class User(AbstractUser):
         super().save(*args, **kwargs)
 
 
+@pghistory.track()
 class UserProfile(models.Model):
     # Read-only ID
     profile_id = models.CharField(
@@ -137,6 +138,7 @@ class UserProfile(models.Model):
         return self.display_name
 
 
+@pghistory.track()
 class EmailVerification(models.Model):
     user = models.OneToOneField(User, on_delete=models.CASCADE)
     token = models.CharField(max_length=64, unique=True)
@@ -151,6 +153,7 @@ class EmailVerification(models.Model):
         verbose_name_plural = "Email Verifications"
 
 
+@pghistory.track()
 class PasswordReset(models.Model):
     user = models.ForeignKey(User, on_delete=models.CASCADE)
     token = models.CharField(max_length=64)

backend/apps/accounts/serializers.py

@@ -0,0 +1,246 @@
+from rest_framework import serializers
+from django.contrib.auth import get_user_model
+from django.contrib.auth.password_validation import validate_password
+from django.core.exceptions import ValidationError
+from django.utils.crypto import get_random_string
+from django.utils import timezone
+from datetime import timedelta
+from django.contrib.sites.shortcuts import get_current_site
+from .models import User, PasswordReset
+from apps.email_service.services import EmailService
+from django.template.loader import render_to_string
+
+UserModel = get_user_model()
+
+
+class UserSerializer(serializers.ModelSerializer):
+    """
+    User serializer for API responses
+    """
+    avatar_url = serializers.SerializerMethodField()
+
+    class Meta:
+        model = User
+        fields = [
+            'id', 'username', 'email', 'first_name', 'last_name',
+            'date_joined', 'is_active', 'avatar_url'
+        ]
+        read_only_fields = ['id', 'date_joined', 'is_active']
+
+    def get_avatar_url(self, obj):
+        """Get user avatar URL"""
+        if hasattr(obj, 'profile') and obj.profile.avatar:
+            return obj.profile.avatar.url
+        return None
+
+
+class LoginSerializer(serializers.Serializer):
+    """
+    Serializer for user login
+    """
+    username = serializers.CharField(
+        max_length=254,
+        help_text="Username or email address"
+    )
+    password = serializers.CharField(
+        max_length=128,
+        style={'input_type': 'password'},
+        trim_whitespace=False
+    )
+
+    def validate(self, attrs):
+        username = attrs.get('username')
+        password = attrs.get('password')
+
+        if username and password:
+            return attrs
+
+        raise serializers.ValidationError(
+            'Must include username/email and password.'
+        )
+
+
+class SignupSerializer(serializers.ModelSerializer):
+    """
+    Serializer for user registration
+    """
+    password = serializers.CharField(
+        write_only=True,
+        validators=[validate_password],
+        style={'input_type': 'password'}
+    )
+    password_confirm = serializers.CharField(
+        write_only=True,
+        style={'input_type': 'password'}
+    )
+
+    class Meta:
+        model = User
+        fields = [
+            'username', 'email', 'first_name', 'last_name',
+            'password', 'password_confirm'
+        ]
+        extra_kwargs = {
+            'password': {'write_only': True},
+            'email': {'required': True},
+        }
+
+    def validate_email(self, value):
+        """Validate email is unique"""
+        if UserModel.objects.filter(email=value).exists():
+            raise serializers.ValidationError(
+                "A user with this email already exists."
+            )
+        return value
+
+    def validate_username(self, value):
+        """Validate username is unique"""
+        if UserModel.objects.filter(username=value).exists():
+            raise serializers.ValidationError(
+                "A user with this username already exists."
+            )
+        return value
+
+    def validate(self, attrs):
+        """Validate passwords match"""
+        password = attrs.get('password')
+        password_confirm = attrs.get('password_confirm')
+
+        if password != password_confirm:
+            raise serializers.ValidationError({
+                'password_confirm': 'Passwords do not match.'
+            })
+
+        return attrs
+
+    def create(self, validated_data):
+        """Create user with validated data"""
+        validated_data.pop('password_confirm', None)
+        password = validated_data.pop('password')
+
+        user = UserModel.objects.create(
+            **validated_data
+        )
+        user.set_password(password)
+        user.save()
+
+        return user
+
+
+class PasswordResetSerializer(serializers.Serializer):
+    """
+    Serializer for password reset request
+    """
+    email = serializers.EmailField()
+
+    def validate_email(self, value):
+        """Validate email exists"""
+        try:
+            user = UserModel.objects.get(email=value)
+            self.user = user
+            return value
+        except UserModel.DoesNotExist:
+            # Don't reveal if email exists or not for security
+            return value
+
+    def save(self, **kwargs):
+        """Send password reset email if user exists"""
+        if hasattr(self, 'user'):
+            # Create password reset token
+            token = get_random_string(64)
+            PasswordReset.objects.update_or_create(
+                user=self.user,
+                defaults={
+                    'token': token,
+                    'expires_at': timezone.now() + timedelta(hours=24),
+                    'used': False
+                }
+            )
+
+            # Send reset email
+            request = self.context.get('request')
+            if request:
+                site = get_current_site(request)
+                reset_url = f"{request.scheme}://{site.domain}/reset-password/{token}/"
+
+                context = {
+                    'user': self.user,
+                    'reset_url': reset_url,
+                    'site_name': site.name,
+                }
+
+                email_html = render_to_string(
+                    'accounts/email/password_reset.html',
+                    context
+                )
+
+                EmailService.send_email(
+                    to=getattr(self.user, 'email', None),
+                    subject="Reset your password",
+                    text=f"Click the link to reset your password: {reset_url}",
+                    site=site,
+                    html=email_html,
+                )
+
+
+class PasswordChangeSerializer(serializers.Serializer):
+    """
+    Serializer for password change
+    """
+    old_password = serializers.CharField(
+        max_length=128,
+        style={'input_type': 'password'}
+    )
+    new_password = serializers.CharField(
+        max_length=128,
+        validators=[validate_password],
+        style={'input_type': 'password'}
+    )
+    new_password_confirm = serializers.CharField(
+        max_length=128,
+        style={'input_type': 'password'}
+    )
+
+    def validate_old_password(self, value):
+        """Validate old password is correct"""
+        user = self.context['request'].user
+        if not user.check_password(value):
+            raise serializers.ValidationError(
+                'Old password is incorrect.'
+            )
+        return value
+
+    def validate(self, attrs):
+        """Validate new passwords match"""
+        new_password = attrs.get('new_password')
+        new_password_confirm = attrs.get('new_password_confirm')
+
+        if new_password != new_password_confirm:
+            raise serializers.ValidationError({
+                'new_password_confirm': 'New passwords do not match.'
+            })
+
+        return attrs
+
+    def save(self, **kwargs):
+        """Change user password"""
+        user = self.context['request'].user
+        new_password = self.initial_data.get(
+            'new_password') if self.initial_data else None
+
+        if new_password is None:
+            raise serializers.ValidationError('New password is required.')
+
+        user.set_password(new_password)
+        user.save()
+
+        return user
+
+
+class SocialProviderSerializer(serializers.Serializer):
+    """
+    Serializer for social authentication providers
+    """
+    id = serializers.CharField()
+    name = serializers.CharField()
+    login_url = serializers.URLField()

backend/apps/api/__init__.py

@@ -0,0 +1,5 @@
+"""
+Consolidated API app for ThrillWiki.
+
+This app provides a unified, versioned API interface for all ThrillWiki resources.
+"""

backend/apps/api/apps.py

@@ -0,0 +1,17 @@
+"""Django app configuration for the consolidated API."""
+
+from django.apps import AppConfig
+
+
+class ApiConfig(AppConfig):
+    """Configuration for the consolidated API app."""
+
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "apps.api"
+
+    def ready(self):
+        """Import schema extensions when app is ready."""
+        try:
+            import apps.api.v1.schema  # noqa: F401
+        except ImportError:
+            pass

backend/apps/api/v1/__init__.py

@@ -0,0 +1,6 @@
+"""
+ThrillWiki API v1.
+
+This module provides the version 1 REST API for ThrillWiki, consolidating
+all endpoints under a unified, well-documented API structure.
+"""

backend/apps/api/v1/schema.py

@@ -0,0 +1,334 @@
+"""
+Schema extensions and customizations for drf-spectacular.
+
+This module provides custom extensions to improve OpenAPI schema generation
+for the ThrillWiki API, including better documentation and examples.
+"""
+
+from drf_spectacular.openapi import AutoSchema
+from drf_spectacular.utils import OpenApiExample
+from drf_spectacular.types import OpenApiTypes
+
+
+# Custom examples for common serializers
+
+PARK_EXAMPLE = {
+    "id": 1,
+    "name": "Cedar Point",
+    "slug": "cedar-point",
+    "description": "The Roller Coaster Capital of the World",
+    "status": "OPERATING",
+    "opening_date": "1870-07-04",
+    "closing_date": None,
+    "location": {
+        "latitude": 41.4793,
+        "longitude": -82.6833,
+        "city": "Sandusky",
+        "state": "Ohio",
+        "country": "United States",
+        "formatted_address": "Sandusky, OH, United States",
+    },
+    "operator": {
+        "id": 1,
+        "name": "Cedar Fair",
+        "slug": "cedar-fair",
+        "roles": ["OPERATOR", "PROPERTY_OWNER"],
+    },
+    "property_owner": {
+        "id": 1,
+        "name": "Cedar Fair",
+        "slug": "cedar-fair",
+        "roles": ["OPERATOR", "PROPERTY_OWNER"],
+    },
+    "area_count": 15,
+    "ride_count": 70,
+    "operating_rides_count": 68,
+    "roller_coaster_count": 17,
+}
+
+RIDE_EXAMPLE = {
+    "id": 1,
+    "name": "Steel Vengeance",
+    "slug": "steel-vengeance",
+    "description": "A hybrid wooden/steel roller coaster",
+    "category": "ROLLER_COASTER",
+    "status": "OPERATING",
+    "opening_date": "2018-05-05",
+    "closing_date": None,
+    "park": {"id": 1, "name": "Cedar Point", "slug": "cedar-point"},
+    "manufacturer": {
+        "id": 1,
+        "name": "Rocky Mountain Construction",
+        "slug": "rmc",
+        "roles": ["MANUFACTURER"],
+    },
+    "designer": {
+        "id": 1,
+        "name": "Rocky Mountain Construction",
+        "slug": "rmc",
+        "roles": ["DESIGNER"],
+    },
+    "height_feet": 205,
+    "length_feet": 5740,
+    "speed_mph": 74,
+    "inversions": 4,
+    "duration_seconds": 150,
+    "capacity_per_hour": 1200,
+    "minimum_height_inches": 48,
+    "maximum_height_inches": None,
+}
+
+COMPANY_EXAMPLE = {
+    "id": 1,
+    "name": "Cedar Fair",
+    "slug": "cedar-fair",
+    "roles": ["OPERATOR", "PROPERTY_OWNER"],
+}
+
+LOCATION_EXAMPLE = {
+    "latitude": 41.4793,
+    "longitude": -82.6833,
+    "city": "Sandusky",
+    "state": "Ohio",
+    "country": "United States",
+    "formatted_address": "Sandusky, OH, United States",
+}
+
+HISTORY_EVENT_EXAMPLE = {
+    "id": "12345678-1234-5678-9012-123456789012",
+    "pgh_created_at": "2024-01-15T14:30:00Z",
+    "pgh_label": "updated",
+    "pgh_model": "parks.park",
+    "pgh_obj_id": 1,
+    "pgh_context": {
+        "user_id": 42,
+        "request_id": "req_abc123",
+        "ip_address": "192.168.1.100",
+    },
+    "changed_fields": ["name", "description"],
+    "field_changes": {
+        "name": {"old_value": "Cedar Point Amusement Park", "new_value": "Cedar Point"},
+        "description": {
+            "old_value": "America's Roller Coast",
+            "new_value": "The Roller Coaster Capital of the World",
+        },
+    },
+}
+
+PARK_HISTORY_EXAMPLE = {
+    "park": PARK_EXAMPLE,
+    "current_state": PARK_EXAMPLE,
+    "summary": {
+        "total_events": 25,
+        "first_recorded": "2023-01-01T00:00:00Z",
+        "last_modified": "2024-01-15T14:30:00Z",
+        "significant_changes": [
+            {
+                "date": "2024-01-15T14:30:00Z",
+                "event_type": "updated",
+                "description": "Name and description updated",
+            },
+            {
+                "date": "2023-06-01T10:00:00Z",
+                "event_type": "updated",
+                "description": "Operating status changed",
+            },
+        ],
+    },
+    "events": [HISTORY_EVENT_EXAMPLE],
+}
+
+UNIFIED_HISTORY_TIMELINE_EXAMPLE = {
+    "summary": {
+        "total_events": 1250,
+        "events_returned": 100,
+        "event_type_breakdown": {"created": 45, "updated": 180, "deleted": 5},
+        "model_type_breakdown": {
+            "parks.park": 75,
+            "rides.ride": 120,
+            "companies.operator": 15,
+            "companies.manufacturer": 25,
+            "accounts.user": 30,
+        },
+        "time_range": {
+            "earliest": "2023-01-01T00:00:00Z",
+            "latest": "2024-01-15T14:30:00Z",
+        },
+    },
+    "events": [
+        {
+            "id": "event_001",
+            "pgh_created_at": "2024-01-15T14:30:00Z",
+            "pgh_label": "updated",
+            "pgh_model": "parks.park",
+            "pgh_obj_id": 1,
+            "entity_name": "Cedar Point",
+            "entity_slug": "cedar-point",
+            "change_significance": "minor",
+            "change_summary": "Park description updated",
+        },
+        {
+            "id": "event_002",
+            "pgh_created_at": "2024-01-15T12:00:00Z",
+            "pgh_label": "created",
+            "pgh_model": "rides.ride",
+            "pgh_obj_id": 100,
+            "entity_name": "New Roller Coaster",
+            "entity_slug": "new-roller-coaster",
+            "change_significance": "major",
+            "change_summary": "New ride added to park",
+        },
+    ],
+}
+
+
+# OpenAPI schema customizations
+
+
+def custom_preprocessing_hook(endpoints):
+    """
+    Custom preprocessing hook to modify endpoints before schema generation.
+
+    This can be used to filter out certain endpoints, modify their metadata,
+    or add custom documentation.
+    """
+    # Filter out any endpoints we don't want in the public API
+    filtered = []
+    for path, path_regex, method, callback in endpoints:
+        # Skip internal or debug endpoints
+        if "/debug/" not in path and "/internal/" not in path:
+            filtered.append((path, path_regex, method, callback))
+
+    return filtered
+
+
+def custom_postprocessing_hook(result, generator, request, public):
+    """
+    Custom postprocessing hook to modify the generated schema.
+
+    This can be used to add custom metadata, modify response schemas,
+    or enhance the overall API documentation.
+    """
+    # Add custom info to the schema
+    if "info" in result:
+        result["info"]["contact"] = {
+            "name": "ThrillWiki API Support",
+            "email": "api@thrillwiki.com",
+            "url": "https://thrillwiki.com/support",
+        }
+
+        result["info"]["license"] = {
+            "name": "MIT",
+            "url": "https://opensource.org/licenses/MIT",
+        }
+
+    # Add custom tags with descriptions
+    if "tags" not in result:
+        result["tags"] = []
+
+    result["tags"].extend(
+        [
+            {
+                "name": "Parks",
+                "description": "Operations related to theme parks, including CRUD operations and statistics",
+            },
+            {
+                "name": "Rides",
+                "description": "Operations related to rides and attractions within theme parks",
+            },
+            {
+                "name": "History",
+                "description": "Historical change tracking for all entities, providing complete audit trails and version history",
+                "externalDocs": {
+                    "description": "Learn more about pghistory",
+                    "url": "https://django-pghistory.readthedocs.io/",
+                },
+            },
+            {
+                "name": "Statistics",
+                "description": "Statistical endpoints providing aggregated data and insights",
+            },
+            {
+                "name": "Reviews",
+                "description": "User reviews and ratings for parks and rides",
+            },
+            {
+                "name": "Authentication",
+                "description": "User authentication and account management endpoints",
+            },
+            {
+                "name": "Health",
+                "description": "System health checks and monitoring endpoints",
+            },
+            {
+                "name": "Recent Changes",
+                "description": "Endpoints for accessing recently changed entities by type and change category",
+            },
+        ]
+    )
+
+    # Add custom servers if not present
+    if "servers" not in result:
+        result["servers"] = [
+            {
+                "url": "https://api.thrillwiki.com/v1",
+                "description": "Production server",
+            },
+            {
+                "url": "https://staging-api.thrillwiki.com/v1",
+                "description": "Staging server",
+            },
+            {
+                "url": "http://localhost:8000/api/v1",
+                "description": "Development server",
+            },
+        ]
+
+    return result
+
+
+# Custom AutoSchema class for enhanced documentation
+class ThrillWikiAutoSchema(AutoSchema):
+    """
+    Custom AutoSchema class that provides enhanced documentation
+    for ThrillWiki API endpoints.
+    """
+
+    def get_operation_id(self):
+        """Generate meaningful operation IDs."""
+        if hasattr(self.view, "basename"):
+            basename = self.view.basename
+        else:
+            basename = getattr(self.view, "__class__", self.view).__name__.lower()
+            if basename.endswith("viewset"):
+                basename = basename[:-7]  # Remove 'viewset' suffix
+
+        action = self.method_mapping.get(self.method.lower(), self.method.lower())
+        return f"{basename}_{action}"
+
+    def get_tags(self):
+        """Generate tags based on the viewset."""
+        if hasattr(self.view, "basename"):
+            return [self.view.basename.title()]
+        return super().get_tags()
+
+    def get_summary(self):
+        """Generate summary from docstring or method name."""
+        summary = super().get_summary()
+        if summary:
+            return summary
+
+        # Generate from method and model
+        action = self.method_mapping.get(self.method.lower(), self.method.lower())
+        model_name = getattr(self.view, "basename", "resource")
+
+        action_map = {
+            "list": f"List {model_name}",
+            "create": f"Create {model_name}",
+            "retrieve": f"Get {model_name} details",
+            "update": f"Update {model_name}",
+            "partial_update": f"Partially update {model_name}",
+            "destroy": f"Delete {model_name}",
+        }
+
+        return action_map.get(action, f"{action.title()} {model_name}")

backend/apps/api/v1/urls.py

@@ -0,0 +1,142 @@
+"""
+URL configuration for ThrillWiki API v1.
+
+This module provides unified API routing following RESTful conventions
+and DRF Router patterns for automatic URL generation.
+"""
+
+from django.urls import path, include
+from rest_framework.routers import DefaultRouter
+from drf_spectacular.views import (
+    SpectacularAPIView,
+    SpectacularSwaggerView,
+    SpectacularRedocView,
+)
+
+from .viewsets import (
+    ParkViewSet,
+    RideViewSet,
+    ParkReadOnlyViewSet,
+    RideReadOnlyViewSet,
+    LoginAPIView,
+    SignupAPIView,
+    LogoutAPIView,
+    CurrentUserAPIView,
+    PasswordResetAPIView,
+    PasswordChangeAPIView,
+    SocialProvidersAPIView,
+    AuthStatusAPIView,
+    HealthCheckAPIView,
+    PerformanceMetricsAPIView,
+    SimpleHealthAPIView,
+    # History viewsets
+    ParkHistoryViewSet,
+    RideHistoryViewSet,
+    UnifiedHistoryViewSet,
+    # New comprehensive viewsets
+    ParkAreaViewSet,
+    ParkLocationViewSet,
+    CompanyViewSet,
+    RideModelViewSet,
+    RollerCoasterStatsViewSet,
+    RideLocationViewSet,
+    RideReviewViewSet,
+    UserProfileViewSet,
+    TopListViewSet,
+    TopListItemViewSet,
+)
+
+# Create the main API router
+router = DefaultRouter()
+
+# Register ViewSets with descriptive prefixes
+
+# Core models
+router.register(r"parks", ParkViewSet, basename="park")
+router.register(r"rides", RideViewSet, basename="ride")
+
+# Park-related models
+router.register(r"park-areas", ParkAreaViewSet, basename="park-area")
+router.register(r"park-locations", ParkLocationViewSet, basename="park-location")
+
+# Company models
+router.register(r"companies", CompanyViewSet, basename="company")
+
+# Ride-related models
+router.register(r"ride-models", RideModelViewSet, basename="ride-model")
+router.register(
+    r"roller-coaster-stats", RollerCoasterStatsViewSet, basename="roller-coaster-stats"
+)
+router.register(r"ride-locations", RideLocationViewSet, basename="ride-location")
+router.register(r"ride-reviews", RideReviewViewSet, basename="ride-review")
+
+# User-related models
+router.register(r"user-profiles", UserProfileViewSet, basename="user-profile")
+router.register(r"top-lists", TopListViewSet, basename="top-list")
+router.register(r"top-list-items", TopListItemViewSet, basename="top-list-item")
+
+# Register read-only endpoints for reference data
+router.register(r"ref/parks", ParkReadOnlyViewSet, basename="park-ref")
+router.register(r"ref/rides", RideReadOnlyViewSet, basename="ride-ref")
+
+app_name = "api_v1"
+
+urlpatterns = [
+    # API Documentation endpoints
+    path("schema/", SpectacularAPIView.as_view(), name="schema"),
+    path(
+        "docs/",
+        SpectacularSwaggerView.as_view(url_name="api_v1:schema"),
+        name="swagger-ui",
+    ),
+    path(
+        "redoc/", SpectacularRedocView.as_view(url_name="api_v1:schema"), name="redoc"
+    ),
+    # Authentication endpoints
+    path("auth/login/", LoginAPIView.as_view(), name="login"),
+    path("auth/signup/", SignupAPIView.as_view(), name="signup"),
+    path("auth/logout/", LogoutAPIView.as_view(), name="logout"),
+    path("auth/user/", CurrentUserAPIView.as_view(), name="current-user"),
+    path("auth/password/reset/", PasswordResetAPIView.as_view(), name="password-reset"),
+    path(
+        "auth/password/change/", PasswordChangeAPIView.as_view(), name="password-change"
+    ),
+    path("auth/providers/", SocialProvidersAPIView.as_view(), name="social-providers"),
+    path("auth/status/", AuthStatusAPIView.as_view(), name="auth-status"),
+    # Health check endpoints
+    path("health/", HealthCheckAPIView.as_view(), name="health-check"),
+    path("health/simple/", SimpleHealthAPIView.as_view(), name="simple-health"),
+    path(
+        "health/performance/",
+        PerformanceMetricsAPIView.as_view(),
+        name="performance-metrics",
+    ),
+    # History endpoints
+    path(
+        "history/timeline/",
+        UnifiedHistoryViewSet.as_view({"get": "list"}),
+        name="unified-history-timeline",
+    ),
+    path(
+        "parks/<str:park_slug>/history/",
+        ParkHistoryViewSet.as_view({"get": "list"}),
+        name="park-history-list",
+    ),
+    path(
+        "parks/<str:park_slug>/history/detail/",
+        ParkHistoryViewSet.as_view({"get": "retrieve"}),
+        name="park-history-detail",
+    ),
+    path(
+        "parks/<str:park_slug>/rides/<str:ride_slug>/history/",
+        RideHistoryViewSet.as_view({"get": "list"}),
+        name="ride-history-list",
+    ),
+    path(
+        "parks/<str:park_slug>/rides/<str:ride_slug>/history/detail/",
+        RideHistoryViewSet.as_view({"get": "retrieve"}),
+        name="ride-history-detail",
+    ),
+    # Include all router-generated URLs
+    path("", include(router.urls)),
+]

backend/apps/core/analytics.py

@@ -3,8 +3,11 @@ from django.contrib.contenttypes.fields import GenericForeignKey
 from django.contrib.contenttypes.models import ContentType
 from django.utils import timezone
 from django.db.models import Count
+from datetime import timedelta
+import pghistory
 
 
+@pghistory.track()
 class PageView(models.Model):
     content_type = models.ForeignKey(
         ContentType, on_delete=models.CASCADE, related_name="page_views"
@@ -35,7 +38,7 @@ class PageView(models.Model):
             QuerySet: The trending items ordered by view count
         """
         content_type = ContentType.objects.get_for_model(model_class)
-        cutoff = timezone.now() - timezone.timedelta(hours=hours)
+        cutoff = timezone.now() - timedelta(hours=hours)
 
         # Query through the ContentType relationship
         item_ids = (

backend/apps/core/migrations/0003_pageviewevent_slughistoryevent_and_more.py

@@ -0,0 +1,171 @@
+# Generated by Django 5.2.5 on 2025-08-24 19:25
+
+import django.db.models.deletion
+import pgtrigger.compiler
+import pgtrigger.migrations
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("contenttypes", "0002_remove_content_type_name"),
+        ("core", "0002_historicalslug_pageview"),
+        ("pghistory", "0007_auto_20250421_0444"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="PageViewEvent",
+            fields=[
+                ("pgh_id", models.AutoField(primary_key=True, serialize=False)),
+                ("pgh_created_at", models.DateTimeField(auto_now_add=True)),
+                ("pgh_label", models.TextField(help_text="The event label.")),
+                ("id", models.BigIntegerField()),
+                ("object_id", models.PositiveIntegerField()),
+                ("timestamp", models.DateTimeField(auto_now_add=True)),
+                ("ip_address", models.GenericIPAddressField()),
+                ("user_agent", models.CharField(blank=True, max_length=512)),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+        migrations.CreateModel(
+            name="SlugHistoryEvent",
+            fields=[
+                ("pgh_id", models.AutoField(primary_key=True, serialize=False)),
+                ("pgh_created_at", models.DateTimeField(auto_now_add=True)),
+                ("pgh_label", models.TextField(help_text="The event label.")),
+                ("id", models.BigIntegerField()),
+                ("object_id", models.CharField(max_length=50)),
+                ("old_slug", models.SlugField(db_index=False, max_length=200)),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="pageview",
+            trigger=pgtrigger.compiler.Trigger(
+                name="insert_insert",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    func='INSERT INTO "core_pageviewevent" ("content_type_id", "id", "ip_address", "object_id", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "timestamp", "user_agent") VALUES (NEW."content_type_id", NEW."id", NEW."ip_address", NEW."object_id", _pgh_attach_context(), NOW(), \'insert\', NEW."id", NEW."timestamp", NEW."user_agent"); RETURN NULL;',
+                    hash="1682d124ea3ba215e630c7cfcde929f7444cf247",
+                    operation="INSERT",
+                    pgid="pgtrigger_insert_insert_ee1e1",
+                    table="core_pageview",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="pageview",
+            trigger=pgtrigger.compiler.Trigger(
+                name="update_update",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    condition="WHEN (OLD.* IS DISTINCT FROM NEW.*)",
+                    func='INSERT INTO "core_pageviewevent" ("content_type_id", "id", "ip_address", "object_id", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "timestamp", "user_agent") VALUES (NEW."content_type_id", NEW."id", NEW."ip_address", NEW."object_id", _pgh_attach_context(), NOW(), \'update\', NEW."id", NEW."timestamp", NEW."user_agent"); RETURN NULL;',
+                    hash="4221b2dd6636cae454f8d69c0c1841c40c47e6a6",
+                    operation="UPDATE",
+                    pgid="pgtrigger_update_update_3c505",
+                    table="core_pageview",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="slughistory",
+            trigger=pgtrigger.compiler.Trigger(
+                name="insert_insert",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    func='INSERT INTO "core_slughistoryevent" ("content_type_id", "created_at", "id", "object_id", "old_slug", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id") VALUES (NEW."content_type_id", NEW."created_at", NEW."id", NEW."object_id", NEW."old_slug", _pgh_attach_context(), NOW(), \'insert\', NEW."id"); RETURN NULL;',
+                    hash="2a2a05025693c165b88e5eba7fcc23214749a78b",
+                    operation="INSERT",
+                    pgid="pgtrigger_insert_insert_3002a",
+                    table="core_slughistory",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="slughistory",
+            trigger=pgtrigger.compiler.Trigger(
+                name="update_update",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    condition="WHEN (OLD.* IS DISTINCT FROM NEW.*)",
+                    func='INSERT INTO "core_slughistoryevent" ("content_type_id", "created_at", "id", "object_id", "old_slug", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id") VALUES (NEW."content_type_id", NEW."created_at", NEW."id", NEW."object_id", NEW."old_slug", _pgh_attach_context(), NOW(), \'update\', NEW."id"); RETURN NULL;',
+                    hash="3ad197ccb6178668e762720341e45d3fd3216776",
+                    operation="UPDATE",
+                    pgid="pgtrigger_update_update_52030",
+                    table="core_slughistory",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        migrations.AddField(
+            model_name="pageviewevent",
+            name="content_type",
+            field=models.ForeignKey(
+                db_constraint=False,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                related_query_name="+",
+                to="contenttypes.contenttype",
+            ),
+        ),
+        migrations.AddField(
+            model_name="pageviewevent",
+            name="pgh_context",
+            field=models.ForeignKey(
+                db_constraint=False,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                to="pghistory.context",
+            ),
+        ),
+        migrations.AddField(
+            model_name="pageviewevent",
+            name="pgh_obj",
+            field=models.ForeignKey(
+                db_constraint=False,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="events",
+                to="core.pageview",
+            ),
+        ),
+        migrations.AddField(
+            model_name="slughistoryevent",
+            name="content_type",
+            field=models.ForeignKey(
+                db_constraint=False,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                related_query_name="+",
+                to="contenttypes.contenttype",
+            ),
+        ),
+        migrations.AddField(
+            model_name="slughistoryevent",
+            name="pgh_context",
+            field=models.ForeignKey(
+                db_constraint=False,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                to="pghistory.context",
+            ),
+        ),
+        migrations.AddField(
+            model_name="slughistoryevent",
+            name="pgh_obj",
+            field=models.ForeignKey(
+                db_constraint=False,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="events",
+                to="core.slughistory",
+            ),
+        ),
+    ]

backend/apps/core/models.py

@@ -3,8 +3,10 @@ from django.contrib.contenttypes.fields import GenericForeignKey
 from django.contrib.contenttypes.models import ContentType
 from django.utils.text import slugify
 from apps.core.history import TrackedModel
+import pghistory
 
 
+@pghistory.track()
 class SlugHistory(models.Model):
     """
     Model for tracking slug changes across all models that use slugs.
@@ -40,7 +42,7 @@ class SluggedModel(TrackedModel):
     name = models.CharField(max_length=200)
     slug = models.SlugField(max_length=200, unique=True)
 
-    class Meta:
+    class Meta(TrackedModel.Meta):
         abstract = True
 
     def save(self, *args, **kwargs):
@@ -83,16 +85,20 @@ class SluggedModel(TrackedModel):
             # Try to get by current slug first
             return cls.objects.get(slug=slug), False
         except cls.DoesNotExist:
-            # Check pghistory first
-            history_model = cls.get_history_model()
-            history_entry = (
-                history_model.objects.filter(slug=slug)
-                .order_by("-pgh_created_at")
-                .first()
-            )
+            # Check pghistory first if available
+            try:
+                import pghistory.models
 
-            if history_entry:
-                return cls.objects.get(id=history_entry.pgh_obj_id), True
+                history_entries = pghistory.models.Events.objects.filter(
+                    pgh_model=f"{cls._meta.app_label}.{cls._meta.model_name}", slug=slug
+                ).order_by("-pgh_created_at")
+
+                if history_entries:
+                    history_entry = history_entries.first()
+                    if history_entry:
+                        return cls.objects.get(id=history_entry.pgh_obj_id), True
+            except (ImportError, AttributeError):
+                pass
 
             # Try to find in manual slug history as fallback
             history = (
@@ -106,7 +112,7 @@ class SluggedModel(TrackedModel):
 
             if history:
                 return (
-                    cls.objects.get(**{cls.get_id_field_name(): history.object_id}),
+                    cls.objects.get(**{cls().get_id_field_name(): history.object_id}),
                     True,
                 )
 

backend/apps/core/views/health_views.py

@@ -1,273 +0,0 @@
-"""
-Enhanced health check views for API monitoring.
-"""
-
-import time
-from django.http import JsonResponse
-from django.utils import timezone
-from django.views import View
-from django.conf import settings
-from rest_framework.views import APIView
-from rest_framework.response import Response
-from rest_framework.permissions import AllowAny
-from health_check.views import MainView
-from apps.core.services.enhanced_cache_service import CacheMonitor
-from apps.core.utils.query_optimization import IndexAnalyzer
-
-
-class HealthCheckAPIView(APIView):
-    """
-    Enhanced API endpoint for health checks with detailed JSON response
-    """
-
-    permission_classes = [AllowAny]  # Public endpoint
-
-    def get(self, request):
-        """Return comprehensive health check information"""
-        start_time = time.time()
-
-        # Get basic health check results
-        main_view = MainView()
-        main_view.request = request
-
-        plugins = main_view.plugins
-        errors = main_view.errors
-
-        # Collect additional performance metrics
-        cache_monitor = CacheMonitor()
-        cache_stats = cache_monitor.get_cache_stats()
-
-        # Build comprehensive health data
-        health_data = {
-            "status": "healthy" if not errors else "unhealthy",
-            "timestamp": timezone.now().isoformat(),
-            "version": getattr(settings, "VERSION", "1.0.0"),
-            "environment": getattr(settings, "ENVIRONMENT", "development"),
-            "response_time_ms": 0,  # Will be calculated at the end
-            "checks": {},
-            "metrics": {
-                "cache": cache_stats,
-                "database": self._get_database_metrics(),
-                "system": self._get_system_metrics(),
-            },
-        }
-
-        # Process individual health checks
-        for plugin in plugins:
-            plugin_name = plugin.identifier()
-            plugin_errors = errors.get(plugin.__class__.__name__, [])
-
-            health_data["checks"][plugin_name] = {
-                "status": "healthy" if not plugin_errors else "unhealthy",
-                "critical": getattr(plugin, "critical_service", False),
-                "errors": [str(error) for error in plugin_errors],
-                "response_time_ms": getattr(plugin, "_response_time", None),
-            }
-
-        # Calculate total response time
-        health_data["response_time_ms"] = round((time.time() - start_time) * 1000, 2)
-
-        # Determine HTTP status code
-        status_code = 200
-        if errors:
-            # Check if any critical services are failing
-            critical_errors = any(
-                getattr(plugin, "critical_service", False)
-                for plugin in plugins
-                if errors.get(plugin.__class__.__name__)
-            )
-            status_code = 503 if critical_errors else 200
-
-        return Response(health_data, status=status_code)
-
-    def _get_database_metrics(self):
-        """Get database performance metrics"""
-        try:
-            from django.db import connection
-
-            # Get basic connection info
-            metrics = {
-                "vendor": connection.vendor,
-                "connection_status": "connected",
-            }
-
-            # Test query performance
-            start_time = time.time()
-            with connection.cursor() as cursor:
-                cursor.execute("SELECT 1")
-                cursor.fetchone()
-            query_time = (time.time() - start_time) * 1000
-
-            metrics["test_query_time_ms"] = round(query_time, 2)
-
-            # PostgreSQL specific metrics
-            if connection.vendor == "postgresql":
-                try:
-                    with connection.cursor() as cursor:
-                        cursor.execute(
-                            """
-                            SELECT
-                                numbackends as active_connections,
-                                xact_commit as transactions_committed,
-                                xact_rollback as transactions_rolled_back,
-                                blks_read as blocks_read,
-                                blks_hit as blocks_hit
-                            FROM pg_stat_database
-                            WHERE datname = current_database()
-                        """
-                        )
-                        row = cursor.fetchone()
-                        if row:
-                            metrics.update(
-                                {
-                                    "active_connections": row[0],
-                                    "transactions_committed": row[1],
-                                    "transactions_rolled_back": row[2],
-                                    "cache_hit_ratio": (
-                                        round(
-                                            (row[4] / (row[3] + row[4])) * 100,
-                                            2,
-                                        )
-                                        if (row[3] + row[4]) > 0
-                                        else 0
-                                    ),
-                                }
-                            )
-                except Exception:
-                    pass  # Skip advanced metrics if not available
-
-            return metrics
-
-        except Exception as e:
-            return {"connection_status": "error", "error": str(e)}
-
-    def _get_system_metrics(self):
-        """Get system performance metrics"""
-        metrics = {
-            "debug_mode": settings.DEBUG,
-            "allowed_hosts": (settings.ALLOWED_HOSTS if settings.DEBUG else ["hidden"]),
-        }
-
-        try:
-            import psutil
-
-            # Memory metrics
-            memory = psutil.virtual_memory()
-            metrics["memory"] = {
-                "total_mb": round(memory.total / 1024 / 1024, 2),
-                "available_mb": round(memory.available / 1024 / 1024, 2),
-                "percent_used": memory.percent,
-            }
-
-            # CPU metrics
-            metrics["cpu"] = {
-                "percent_used": psutil.cpu_percent(interval=0.1),
-                "core_count": psutil.cpu_count(),
-            }
-
-            # Disk metrics
-            disk = psutil.disk_usage("/")
-            metrics["disk"] = {
-                "total_gb": round(disk.total / 1024 / 1024 / 1024, 2),
-                "free_gb": round(disk.free / 1024 / 1024 / 1024, 2),
-                "percent_used": round((disk.used / disk.total) * 100, 2),
-            }
-
-        except ImportError:
-            metrics["system_monitoring"] = "psutil not available"
-        except Exception as e:
-            metrics["system_error"] = str(e)
-
-        return metrics
-
-
-class PerformanceMetricsView(APIView):
-    """
-    API view for performance metrics and database analysis
-    """
-
-    permission_classes = [AllowAny] if settings.DEBUG else []
-
-    def get(self, request):
-        """Return performance metrics and analysis"""
-        if not settings.DEBUG:
-            return Response({"error": "Only available in debug mode"}, status=403)
-
-        metrics = {
-            "timestamp": timezone.now().isoformat(),
-            "database_analysis": self._get_database_analysis(),
-            "cache_performance": self._get_cache_performance(),
-            "recent_slow_queries": self._get_slow_queries(),
-        }
-
-        return Response(metrics)
-
-    def _get_database_analysis(self):
-        """Analyze database performance"""
-        try:
-            from django.db import connection
-
-            analysis = {
-                "total_queries": len(connection.queries),
-                "query_analysis": IndexAnalyzer.analyze_slow_queries(0.05),
-            }
-
-            if connection.queries:
-                query_times = [float(q.get("time", 0)) for q in connection.queries]
-                analysis.update(
-                    {
-                        "total_query_time": sum(query_times),
-                        "average_query_time": sum(query_times) / len(query_times),
-                        "slowest_query_time": max(query_times),
-                        "fastest_query_time": min(query_times),
-                    }
-                )
-
-            return analysis
-
-        except Exception as e:
-            return {"error": str(e)}
-
-    def _get_cache_performance(self):
-        """Get cache performance metrics"""
-        try:
-            cache_monitor = CacheMonitor()
-            return cache_monitor.get_cache_stats()
-        except Exception as e:
-            return {"error": str(e)}
-
-    def _get_slow_queries(self):
-        """Get recent slow queries"""
-        try:
-            return IndexAnalyzer.analyze_slow_queries(0.1)  # 100ms threshold
-        except Exception as e:
-            return {"error": str(e)}
-
-
-class SimpleHealthView(View):
-    """
-    Simple health check endpoint for load balancers
-    """
-
-    def get(self, request):
-        """Return simple OK status"""
-        try:
-            # Basic database connectivity test
-            from django.db import connection
-
-            with connection.cursor() as cursor:
-                cursor.execute("SELECT 1")
-                cursor.fetchone()
-
-            return JsonResponse(
-                {"status": "ok", "timestamp": timezone.now().isoformat()}
-            )
-        except Exception as e:
-            return JsonResponse(
-                {
-                    "status": "error",
-                    "error": str(e),
-                    "timestamp": timezone.now().isoformat(),
-                },
-                status=503,
-            )

backend/apps/email_service/migrations/0002_remove_emailconfiguration_insert_insert_and_more.py

@@ -0,0 +1,52 @@
+# Generated by Django 5.2.5 on 2025-08-24 18:23
+
+import pgtrigger.compiler
+import pgtrigger.migrations
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("email_service", "0001_initial"),
+    ]
+
+    operations = [
+        pgtrigger.migrations.RemoveTrigger(
+            model_name="emailconfiguration",
+            name="insert_insert",
+        ),
+        pgtrigger.migrations.RemoveTrigger(
+            model_name="emailconfiguration",
+            name="update_update",
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="emailconfiguration",
+            trigger=pgtrigger.compiler.Trigger(
+                name="insert_insert",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    func='INSERT INTO "email_service_emailconfigurationevent" ("api_key", "created_at", "from_email", "from_name", "id", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "reply_to", "site_id", "updated_at") VALUES (NEW."api_key", NEW."created_at", NEW."from_email", NEW."from_name", NEW."id", _pgh_attach_context(), NOW(), \'insert\', NEW."id", NEW."reply_to", NEW."site_id", NEW."updated_at"); RETURN NULL;',
+                    hash="f19f3c7f7d904d5f850a2ff1e0bf1312e855c8c0",
+                    operation="INSERT",
+                    pgid="pgtrigger_insert_insert_08c59",
+                    table="email_service_emailconfiguration",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="emailconfiguration",
+            trigger=pgtrigger.compiler.Trigger(
+                name="update_update",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    condition="WHEN (OLD.* IS DISTINCT FROM NEW.*)",
+                    func='INSERT INTO "email_service_emailconfigurationevent" ("api_key", "created_at", "from_email", "from_name", "id", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "reply_to", "site_id", "updated_at") VALUES (NEW."api_key", NEW."created_at", NEW."from_email", NEW."from_name", NEW."id", _pgh_attach_context(), NOW(), \'update\', NEW."id", NEW."reply_to", NEW."site_id", NEW."updated_at"); RETURN NULL;',
+                    hash="e445521baf2cfb51379b2a6be550b4a638d60202",
+                    operation="UPDATE",
+                    pgid="pgtrigger_update_update_992a4",
+                    table="email_service_emailconfiguration",
+                    when="AFTER",
+                ),
+            ),
+        ),
+    ]

backend/apps/location/migrations/0003_remove_location_insert_insert_and_more.py

@@ -0,0 +1,52 @@
+# Generated by Django 5.2.5 on 2025-08-24 18:23
+
+import pgtrigger.compiler
+import pgtrigger.migrations
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("location", "0002_add_business_constraints"),
+    ]
+
+    operations = [
+        pgtrigger.migrations.RemoveTrigger(
+            model_name="location",
+            name="insert_insert",
+        ),
+        pgtrigger.migrations.RemoveTrigger(
+            model_name="location",
+            name="update_update",
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="location",
+            trigger=pgtrigger.compiler.Trigger(
+                name="insert_insert",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    func='INSERT INTO "location_locationevent" ("city", "content_type_id", "country", "created_at", "id", "latitude", "location_type", "longitude", "name", "object_id", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "point", "postal_code", "state", "street_address", "updated_at") VALUES (NEW."city", NEW."content_type_id", NEW."country", NEW."created_at", NEW."id", NEW."latitude", NEW."location_type", NEW."longitude", NEW."name", NEW."object_id", _pgh_attach_context(), NOW(), \'insert\', NEW."id", NEW."point", NEW."postal_code", NEW."state", NEW."street_address", NEW."updated_at"); RETURN NULL;',
+                    hash="8a8f00869cfcaa1a23ab29b3d855e83602172c67",
+                    operation="INSERT",
+                    pgid="pgtrigger_insert_insert_98cd4",
+                    table="location_location",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="location",
+            trigger=pgtrigger.compiler.Trigger(
+                name="update_update",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    condition="WHEN (OLD.* IS DISTINCT FROM NEW.*)",
+                    func='INSERT INTO "location_locationevent" ("city", "content_type_id", "country", "created_at", "id", "latitude", "location_type", "longitude", "name", "object_id", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "point", "postal_code", "state", "street_address", "updated_at") VALUES (NEW."city", NEW."content_type_id", NEW."country", NEW."created_at", NEW."id", NEW."latitude", NEW."location_type", NEW."longitude", NEW."name", NEW."object_id", _pgh_attach_context(), NOW(), \'update\', NEW."id", NEW."point", NEW."postal_code", NEW."state", NEW."street_address", NEW."updated_at"); RETURN NULL;',
+                    hash="f3378cb26a5d88aa82c8fae016d46037b530de90",
+                    operation="UPDATE",
+                    pgid="pgtrigger_update_update_471d2",
+                    table="location_location",
+                    when="AFTER",
+                ),
+            ),
+        ),
+    ]

backend/apps/moderation/migrations/0002_remove_editsubmission_insert_insert_and_more.py

@@ -0,0 +1,89 @@
+# Generated by Django 5.2.5 on 2025-08-24 18:23
+
+import pgtrigger.compiler
+import pgtrigger.migrations
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("moderation", "0001_initial"),
+    ]
+
+    operations = [
+        pgtrigger.migrations.RemoveTrigger(
+            model_name="editsubmission",
+            name="insert_insert",
+        ),
+        pgtrigger.migrations.RemoveTrigger(
+            model_name="editsubmission",
+            name="update_update",
+        ),
+        pgtrigger.migrations.RemoveTrigger(
+            model_name="photosubmission",
+            name="insert_insert",
+        ),
+        pgtrigger.migrations.RemoveTrigger(
+            model_name="photosubmission",
+            name="update_update",
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="editsubmission",
+            trigger=pgtrigger.compiler.Trigger(
+                name="insert_insert",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    func='INSERT INTO "moderation_editsubmissionevent" ("changes", "content_type_id", "created_at", "handled_at", "handled_by_id", "id", "moderator_changes", "notes", "object_id", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "reason", "source", "status", "submission_type", "updated_at", "user_id") VALUES (NEW."changes", NEW."content_type_id", NEW."created_at", NEW."handled_at", NEW."handled_by_id", NEW."id", NEW."moderator_changes", NEW."notes", NEW."object_id", _pgh_attach_context(), NOW(), \'insert\', NEW."id", NEW."reason", NEW."source", NEW."status", NEW."submission_type", NEW."updated_at", NEW."user_id"); RETURN NULL;',
+                    hash="0e394e419ba234dd23cb0f4f6567611ad71f2a38",
+                    operation="INSERT",
+                    pgid="pgtrigger_insert_insert_2c796",
+                    table="moderation_editsubmission",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="editsubmission",
+            trigger=pgtrigger.compiler.Trigger(
+                name="update_update",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    condition="WHEN (OLD.* IS DISTINCT FROM NEW.*)",
+                    func='INSERT INTO "moderation_editsubmissionevent" ("changes", "content_type_id", "created_at", "handled_at", "handled_by_id", "id", "moderator_changes", "notes", "object_id", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "reason", "source", "status", "submission_type", "updated_at", "user_id") VALUES (NEW."changes", NEW."content_type_id", NEW."created_at", NEW."handled_at", NEW."handled_by_id", NEW."id", NEW."moderator_changes", NEW."notes", NEW."object_id", _pgh_attach_context(), NOW(), \'update\', NEW."id", NEW."reason", NEW."source", NEW."status", NEW."submission_type", NEW."updated_at", NEW."user_id"); RETURN NULL;',
+                    hash="315b76df75a52d610d3d0857fd5821101e551410",
+                    operation="UPDATE",
+                    pgid="pgtrigger_update_update_ab38f",
+                    table="moderation_editsubmission",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="photosubmission",
+            trigger=pgtrigger.compiler.Trigger(
+                name="insert_insert",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    func='INSERT INTO "moderation_photosubmissionevent" ("caption", "content_type_id", "created_at", "date_taken", "handled_at", "handled_by_id", "id", "notes", "object_id", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "photo", "status", "updated_at", "user_id") VALUES (NEW."caption", NEW."content_type_id", NEW."created_at", NEW."date_taken", NEW."handled_at", NEW."handled_by_id", NEW."id", NEW."notes", NEW."object_id", _pgh_attach_context(), NOW(), \'insert\', NEW."id", NEW."photo", NEW."status", NEW."updated_at", NEW."user_id"); RETURN NULL;',
+                    hash="e967ea629575f6b26892db225b40add9a1558cfb",
+                    operation="INSERT",
+                    pgid="pgtrigger_insert_insert_62865",
+                    table="moderation_photosubmission",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="photosubmission",
+            trigger=pgtrigger.compiler.Trigger(
+                name="update_update",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    condition="WHEN (OLD.* IS DISTINCT FROM NEW.*)",
+                    func='INSERT INTO "moderation_photosubmissionevent" ("caption", "content_type_id", "created_at", "date_taken", "handled_at", "handled_by_id", "id", "notes", "object_id", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "photo", "status", "updated_at", "user_id") VALUES (NEW."caption", NEW."content_type_id", NEW."created_at", NEW."date_taken", NEW."handled_at", NEW."handled_by_id", NEW."id", NEW."notes", NEW."object_id", _pgh_attach_context(), NOW(), \'update\', NEW."id", NEW."photo", NEW."status", NEW."updated_at", NEW."user_id"); RETURN NULL;',
+                    hash="b7a97f4e8f90569a90fc4c35cc85e601ff25f0d9",
+                    operation="UPDATE",
+                    pgid="pgtrigger_update_update_9c311",
+                    table="moderation_photosubmission",
+                    when="AFTER",
+                ),
+            ),
+        ),
+    ]

backend/apps/parks/admin.py

@@ -1,6 +1,15 @@
 from django.contrib import admin
 from django.contrib.gis.admin import GISModelAdmin
-from .models import Park, ParkArea, ParkLocation, Company, CompanyHeadquarters
+from django.utils.html import format_html
+import pghistory.models
+from .models import (
+    Park,
+    ParkArea,
+    ParkLocation,
+    Company,
+    CompanyHeadquarters,
+    ParkReview,
+)
 
 
 class ParkLocationInline(admin.StackedInline):
@@ -79,16 +88,14 @@ class ParkLocationAdmin(GISModelAdmin):
         ),
     )
 
+    @admin.display(description="Latitude")
     def latitude(self, obj):
         return obj.latitude
 
-    latitude.short_description = "Latitude"
-
+    @admin.display(description="Longitude")
     def longitude(self, obj):
         return obj.longitude
 
-    longitude.short_description = "Longitude"
-
 
 class ParkAdmin(admin.ModelAdmin):
     list_display = (
@@ -112,12 +119,11 @@ class ParkAdmin(admin.ModelAdmin):
     prepopulated_fields = {"slug": ("name",)}
     inlines = [ParkLocationInline]
 
+    @admin.display(description="Location")
     def formatted_location(self, obj):
         """Display formatted location string"""
         return obj.formatted_location
 
-    formatted_location.short_description = "Location"
-
 
 class ParkAreaAdmin(admin.ModelAdmin):
     list_display = ("name", "park", "created_at", "updated_at")
@@ -200,19 +206,193 @@ class CompanyAdmin(admin.ModelAdmin):
     prepopulated_fields = {"slug": ("name",)}
     inlines = [CompanyHeadquartersInline]
 
+    @admin.display(description="Roles")
     def roles_display(self, obj):
         """Display roles as a formatted string"""
         return ", ".join(obj.roles) if obj.roles else "No roles"
 
-    roles_display.short_description = "Roles"
-
+    @admin.display(description="Headquarters")
     def headquarters_location(self, obj):
         """Display headquarters location if available"""
         if hasattr(obj, "headquarters"):
             return obj.headquarters.location_display
         return "No headquarters"
 
-    headquarters_location.short_description = "Headquarters"
+
+@admin.register(ParkReview)
+class ParkReviewAdmin(admin.ModelAdmin):
+    """Admin interface for park reviews"""
+
+    list_display = (
+        "park",
+        "user",
+        "rating",
+        "title",
+        "visit_date",
+        "is_published",
+        "created_at",
+        "moderation_status",
+    )
+    list_filter = (
+        "rating",
+        "is_published",
+        "visit_date",
+        "created_at",
+        "park",
+        "moderated_by",
+    )
+    search_fields = (
+        "title",
+        "content",
+        "user__username",
+        "park__name",
+    )
+    readonly_fields = ("created_at", "updated_at")
+    date_hierarchy = "created_at"
+    ordering = ("-created_at",)
+
+    fieldsets = (
+        (
+            "Review Details",
+            {
+                "fields": (
+                    "user",
+                    "park",
+                    "rating",
+                    "title",
+                    "content",
+                    "visit_date",
+                )
+            },
+        ),
+        (
+            "Publication Status",
+            {
+                "fields": ("is_published",),
+            },
+        ),
+        (
+            "Moderation",
+            {
+                "fields": (
+                    "moderated_by",
+                    "moderated_at",
+                    "moderation_notes",
+                ),
+                "classes": ("collapse",),
+            },
+        ),
+        (
+            "Metadata",
+            {
+                "fields": ("created_at", "updated_at"),
+                "classes": ("collapse",),
+            },
+        ),
+    )
+
+    @admin.display(description="Moderation Status", boolean=True)
+    def moderation_status(self, obj):
+        """Display moderation status with color coding"""
+        if obj.moderated_by:
+            return format_html(
+                '<span style="color: {};">{}</span>',
+                "green" if obj.is_published else "red",
+                "Approved" if obj.is_published else "Rejected",
+            )
+        return format_html('<span style="color: orange;">Pending</span>')
+
+    def save_model(self, request, obj, form, change):
+        """Auto-set moderation info when status changes"""
+        if change and "is_published" in form.changed_data:
+            from django.utils import timezone
+
+            obj.moderated_by = request.user
+            obj.moderated_at = timezone.now()
+        super().save_model(request, obj, form, change)
+
+
+@admin.register(pghistory.models.Events)
+class PgHistoryEventsAdmin(admin.ModelAdmin):
+    """Admin interface for pghistory Events"""
+
+    list_display = (
+        'pgh_id',
+        'pgh_created_at',
+        'pgh_label',
+        'pgh_model',
+        'pgh_obj_id',
+        'pgh_context_display',
+    )
+    list_filter = (
+        'pgh_label',
+        'pgh_model',
+        'pgh_created_at',
+    )
+    search_fields = (
+        'pgh_obj_id',
+        'pgh_context',
+    )
+    readonly_fields = (
+        'pgh_id',
+        'pgh_created_at',
+        'pgh_label',
+        'pgh_model',
+        'pgh_obj_id',
+        'pgh_context',
+        'pgh_data',
+    )
+    date_hierarchy = 'pgh_created_at'
+    ordering = ('-pgh_created_at',)
+
+    fieldsets = (
+        (
+            'Event Information',
+            {
+                'fields': (
+                    'pgh_id',
+                    'pgh_created_at',
+                    'pgh_label',
+                    'pgh_model',
+                    'pgh_obj_id',
+                )
+            },
+        ),
+        (
+            'Context & Data',
+            {
+                'fields': (
+                    'pgh_context',
+                    'pgh_data',
+                ),
+                'classes': ('collapse',),
+            },
+        ),
+    )
+
+    @admin.display(description="Context")
+    def pgh_context_display(self, obj):
+        """Display context information in a readable format"""
+        if obj.pgh_context:
+            if isinstance(obj.pgh_context, dict):
+                context_items = []
+                for key, value in obj.pgh_context.items():
+                    context_items.append(f"{key}: {value}")
+                return ", ".join(context_items)
+            return str(obj.pgh_context)
+        return "No context"
+
+    def has_add_permission(self, request):
+        """Disable manual creation of history events"""
+        return False
+
+    def has_change_permission(self, request, obj=None):
+        """Make history events read-only"""
+        return False
+
+    def has_delete_permission(self, request, obj=None):
+        """Prevent deletion of history events"""
+        return getattr(request.user, 'is_superuser', False)
 
 
 # Register the models with their admin classes

backend/apps/parks/api/__init__.py

@@ -1 +0,0 @@
-# Parks API module

backend/apps/parks/api/serializers.py

@@ -1,304 +0,0 @@
-"""
-Serializers for Parks API following Django styleguide patterns.
-Separates Input and Output serializers for clear boundaries.
-"""
-
-from rest_framework import serializers
-from ..models import Park
-
-
-class ParkLocationOutputSerializer(serializers.Serializer):
-    """Output serializer for park location data."""
-
-    latitude = serializers.SerializerMethodField()
-    longitude = serializers.SerializerMethodField()
-    city = serializers.SerializerMethodField()
-    state = serializers.SerializerMethodField()
-    country = serializers.SerializerMethodField()
-    formatted_address = serializers.SerializerMethodField()
-
-    def get_latitude(self, obj):
-        if hasattr(obj, "location") and obj.location:
-            return obj.location.latitude
-        return None
-
-    def get_longitude(self, obj):
-        if hasattr(obj, "location") and obj.location:
-            return obj.location.longitude
-        return None
-
-    def get_city(self, obj):
-        if hasattr(obj, "location") and obj.location:
-            return obj.location.city
-        return None
-
-    def get_state(self, obj):
-        if hasattr(obj, "location") and obj.location:
-            return obj.location.state
-        return None
-
-    def get_country(self, obj):
-        if hasattr(obj, "location") and obj.location:
-            return obj.location.country
-        return None
-
-    def get_formatted_address(self, obj):
-        if hasattr(obj, "location") and obj.location:
-            return obj.location.formatted_address
-        return ""
-
-
-class CompanyOutputSerializer(serializers.Serializer):
-    """Output serializer for company data."""
-
-    id = serializers.IntegerField()
-    name = serializers.CharField()
-    slug = serializers.CharField()
-    roles = serializers.ListField(child=serializers.CharField())
-
-
-class ParkAreaOutputSerializer(serializers.Serializer):
-    """Output serializer for park area data."""
-
-    id = serializers.IntegerField()
-    name = serializers.CharField()
-    slug = serializers.CharField()
-    description = serializers.CharField()
-
-
-class ParkListOutputSerializer(serializers.Serializer):
-    """Output serializer for park list view."""
-
-    id = serializers.IntegerField()
-    name = serializers.CharField()
-    slug = serializers.CharField()
-    status = serializers.CharField()
-    description = serializers.CharField()
-
-    # Statistics
-    average_rating = serializers.DecimalField(
-        max_digits=3, decimal_places=2, allow_null=True
-    )
-    coaster_count = serializers.IntegerField(allow_null=True)
-    ride_count = serializers.IntegerField(allow_null=True)
-
-    # Location (simplified for list view)
-    location = ParkLocationOutputSerializer(allow_null=True)
-
-    # Operator info
-    operator = CompanyOutputSerializer()
-
-    # Metadata
-    created_at = serializers.DateTimeField()
-    updated_at = serializers.DateTimeField()
-
-
-class ParkDetailOutputSerializer(serializers.Serializer):
-    """Output serializer for park detail view."""
-
-    id = serializers.IntegerField()
-    name = serializers.CharField()
-    slug = serializers.CharField()
-    status = serializers.CharField()
-    description = serializers.CharField()
-
-    # Details
-    opening_date = serializers.DateField(allow_null=True)
-    closing_date = serializers.DateField(allow_null=True)
-    operating_season = serializers.CharField()
-    size_acres = serializers.DecimalField(
-        max_digits=10, decimal_places=2, allow_null=True
-    )
-    website = serializers.URLField()
-
-    # Statistics
-    average_rating = serializers.DecimalField(
-        max_digits=3, decimal_places=2, allow_null=True
-    )
-    coaster_count = serializers.IntegerField(allow_null=True)
-    ride_count = serializers.IntegerField(allow_null=True)
-
-    # Location (full details)
-    location = ParkLocationOutputSerializer(allow_null=True)
-
-    # Companies
-    operator = CompanyOutputSerializer()
-    property_owner = CompanyOutputSerializer(allow_null=True)
-
-    # Areas
-    areas = ParkAreaOutputSerializer(many=True)
-
-    # Metadata
-    created_at = serializers.DateTimeField()
-    updated_at = serializers.DateTimeField()
-
-
-class ParkCreateInputSerializer(serializers.Serializer):
-    """Input serializer for creating parks."""
-
-    name = serializers.CharField(max_length=255)
-    description = serializers.CharField(allow_blank=True, default="")
-    status = serializers.ChoiceField(choices=Park.STATUS_CHOICES, default="OPERATING")
-
-    # Optional details
-    opening_date = serializers.DateField(required=False, allow_null=True)
-    closing_date = serializers.DateField(required=False, allow_null=True)
-    operating_season = serializers.CharField(
-        max_length=255, required=False, allow_blank=True
-    )
-    size_acres = serializers.DecimalField(
-        max_digits=10, decimal_places=2, required=False, allow_null=True
-    )
-    website = serializers.URLField(required=False, allow_blank=True)
-
-    # Required operator
-    operator_id = serializers.IntegerField()
-
-    # Optional property owner
-    property_owner_id = serializers.IntegerField(required=False, allow_null=True)
-
-    def validate(self, data):
-        """Cross-field validation."""
-        opening_date = data.get("opening_date")
-        closing_date = data.get("closing_date")
-
-        if opening_date and closing_date and closing_date < opening_date:
-            raise serializers.ValidationError(
-                "Closing date cannot be before opening date"
-            )
-
-        return data
-
-
-class ParkUpdateInputSerializer(serializers.Serializer):
-    """Input serializer for updating parks."""
-
-    name = serializers.CharField(max_length=255, required=False)
-    description = serializers.CharField(allow_blank=True, required=False)
-    status = serializers.ChoiceField(choices=Park.STATUS_CHOICES, required=False)
-
-    # Optional details
-    opening_date = serializers.DateField(required=False, allow_null=True)
-    closing_date = serializers.DateField(required=False, allow_null=True)
-    operating_season = serializers.CharField(
-        max_length=255, required=False, allow_blank=True
-    )
-    size_acres = serializers.DecimalField(
-        max_digits=10, decimal_places=2, required=False, allow_null=True
-    )
-    website = serializers.URLField(required=False, allow_blank=True)
-
-    # Companies
-    operator_id = serializers.IntegerField(required=False)
-    property_owner_id = serializers.IntegerField(required=False, allow_null=True)
-
-    def validate(self, data):
-        """Cross-field validation."""
-        opening_date = data.get("opening_date")
-        closing_date = data.get("closing_date")
-
-        if opening_date and closing_date and closing_date < opening_date:
-            raise serializers.ValidationError(
-                "Closing date cannot be before opening date"
-            )
-
-        return data
-
-
-class ParkFilterInputSerializer(serializers.Serializer):
-    """Input serializer for park filtering and search."""
-
-    # Search
-    search = serializers.CharField(required=False, allow_blank=True)
-
-    # Status filter
-    status = serializers.MultipleChoiceField(
-        choices=Park.STATUS_CHOICES, required=False
-    )
-
-    # Location filters
-    country = serializers.CharField(required=False, allow_blank=True)
-    state = serializers.CharField(required=False, allow_blank=True)
-    city = serializers.CharField(required=False, allow_blank=True)
-
-    # Rating filter
-    min_rating = serializers.DecimalField(
-        max_digits=3,
-        decimal_places=2,
-        required=False,
-        min_value=1,
-        max_value=10,
-    )
-
-    # Size filter
-    min_size_acres = serializers.DecimalField(
-        max_digits=10, decimal_places=2, required=False, min_value=0
-    )
-    max_size_acres = serializers.DecimalField(
-        max_digits=10, decimal_places=2, required=False, min_value=0
-    )
-
-    # Company filters
-    operator_id = serializers.IntegerField(required=False)
-    property_owner_id = serializers.IntegerField(required=False)
-
-    # Ordering
-    ordering = serializers.ChoiceField(
-        choices=[
-            "name",
-            "-name",
-            "opening_date",
-            "-opening_date",
-            "average_rating",
-            "-average_rating",
-            "coaster_count",
-            "-coaster_count",
-            "created_at",
-            "-created_at",
-        ],
-        required=False,
-        default="name",
-    )
-
-
-class ParkReviewOutputSerializer(serializers.Serializer):
-    """Output serializer for park reviews."""
-
-    id = serializers.IntegerField()
-    rating = serializers.IntegerField()
-    title = serializers.CharField()
-    content = serializers.CharField()
-    visit_date = serializers.DateField()
-    created_at = serializers.DateTimeField()
-
-    # User info (limited for privacy)
-    user = serializers.SerializerMethodField()
-
-    def get_user(self, obj):
-        return {
-            "username": obj.user.username,
-            "display_name": obj.user.get_full_name() or obj.user.username,
-        }
-
-
-class ParkStatsOutputSerializer(serializers.Serializer):
-    """Output serializer for park statistics."""
-
-    total_parks = serializers.IntegerField()
-    operating_parks = serializers.IntegerField()
-    closed_parks = serializers.IntegerField()
-    under_construction = serializers.IntegerField()
-
-    # Averages
-    average_rating = serializers.DecimalField(
-        max_digits=3, decimal_places=2, allow_null=True
-    )
-    average_coaster_count = serializers.DecimalField(
-        max_digits=5, decimal_places=2, allow_null=True
-    )
-
-    # Top countries
-    top_countries = serializers.ListField(child=serializers.DictField())
-
-    # Recently added
-    recently_added_count = serializers.IntegerField()

backend/apps/parks/api/urls.py

@@ -1,65 +0,0 @@
-"""
-URL configuration for Parks API following Django styleguide patterns.
-"""
-
-from django.urls import path, include
-from rest_framework.routers import DefaultRouter
-
-from .views import (
-    ParkListApi,
-    ParkDetailApi,
-    ParkCreateApi,
-    ParkUpdateApi,
-    ParkDeleteApi,
-    ParkApi,
-)
-
-app_name = "parks_api"
-
-# Option 1: Separate ViewSets for each operation (more explicit)
-router_separate = DefaultRouter()
-router_separate.register(r"list", ParkListApi, basename="park-list")
-router_separate.register(r"detail", ParkDetailApi, basename="park-detail")
-router_separate.register(r"create", ParkCreateApi, basename="park-create")
-router_separate.register(r"update", ParkUpdateApi, basename="park-update")
-router_separate.register(r"delete", ParkDeleteApi, basename="park-delete")
-
-# Option 2: Unified ViewSet (more conventional DRF)
-router_unified = DefaultRouter()
-router_unified.register(r"parks", ParkApi, basename="park")
-
-# Use unified approach for cleaner URLs
-urlpatterns = [
-    path("v1/", include(router_unified.urls)),
-]
-
-# Alternative manual URL patterns for more control
-urlpatterns_manual = [
-    # List and create
-    path(
-        "v1/parks/",
-        ParkApi.as_view({"get": "list", "post": "create"}),
-        name="park-list",
-    ),
-    # Stats endpoint
-    path("v1/parks/stats/", ParkApi.as_view({"get": "stats"}), name="park-stats"),
-    # Detail operations
-    path(
-        "v1/parks/<slug:slug>/",
-        ParkApi.as_view(
-            {
-                "get": "retrieve",
-                "put": "update",
-                "patch": "partial_update",
-                "delete": "destroy",
-            }
-        ),
-        name="park-detail",
-    ),
-    # Park reviews
-    path(
-        "v1/parks/<slug:slug>/reviews/",
-        ParkApi.as_view({"get": "reviews"}),
-        name="park-reviews",
-    ),
-]

backend/apps/parks/api/views.py

@@ -1,295 +0,0 @@
-"""
-Parks API views following Django styleguide patterns.
-Uses ClassNameApi naming convention and proper Input/Output serializers.
-"""
-
-from rest_framework.decorators import action
-from rest_framework.request import Request
-from rest_framework.response import Response
-from rest_framework.viewsets import GenericViewSet
-from rest_framework.permissions import (
-    IsAuthenticated,
-    IsAuthenticatedOrReadOnly,
-)
-from django_filters.rest_framework import DjangoFilterBackend
-from rest_framework.filters import SearchFilter, OrderingFilter
-
-from apps.core.api.mixins import (
-    CreateApiMixin,
-    UpdateApiMixin,
-    ListApiMixin,
-    RetrieveApiMixin,
-    DestroyApiMixin,
-)
-from ..selectors import (
-    park_list_with_stats,
-    park_detail_optimized,
-    park_reviews_for_park,
-    park_statistics,
-)
-from ..services import ParkService
-from .serializers import (
-    ParkListOutputSerializer,
-    ParkDetailOutputSerializer,
-    ParkCreateInputSerializer,
-    ParkUpdateInputSerializer,
-    ParkFilterInputSerializer,
-    ParkReviewOutputSerializer,
-    ParkStatsOutputSerializer,
-)
-
-
-class ParkListApi(ListApiMixin, GenericViewSet):
-    """
-    API endpoint for listing parks with filtering and search.
-
-    GET /api/v1/parks/
-    """
-
-    permission_classes = [IsAuthenticatedOrReadOnly]
-    filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
-    search_fields = ["name", "description"]
-    ordering_fields = [
-        "name",
-        "opening_date",
-        "average_rating",
-        "coaster_count",
-        "created_at",
-    ]
-    ordering = ["name"]
-
-    OutputSerializer = ParkListOutputSerializer
-    FilterSerializer = ParkFilterInputSerializer
-
-    def get_queryset(self):
-        """Use selector to get optimized queryset."""
-        # Parse filter parameters
-        filter_serializer = self.FilterSerializer(data=self.request.query_params)
-        filter_serializer.is_valid(raise_exception=True)
-        filters = filter_serializer.validated_data
-
-        return park_list_with_stats(filters=filters)
-
-    @action(detail=False, methods=["get"])
-    def stats(self, request: Request) -> Response:
-        """
-        Get park statistics.
-
-        GET /api/v1/parks/stats/
-        """
-        stats = park_statistics()
-        serializer = ParkStatsOutputSerializer(stats)
-
-        return self.create_response(
-            data=serializer.data,
-            metadata={"cache_duration": 3600},  # 1 hour cache hint
-        )
-
-
-class ParkDetailApi(RetrieveApiMixin, GenericViewSet):
-    """
-    API endpoint for retrieving individual park details.
-
-    GET /api/v1/parks/{id}/
-    """
-
-    permission_classes = [IsAuthenticatedOrReadOnly]
-    lookup_field = "slug"
-
-    OutputSerializer = ParkDetailOutputSerializer
-
-    def get_object(self):
-        """Use selector for optimized detail query."""
-        slug = self.kwargs.get("slug")
-        return park_detail_optimized(slug=slug)
-
-    @action(detail=True, methods=["get"])
-    def reviews(self, request: Request, slug: str = None) -> Response:
-        """
-        Get reviews for a specific park.
-
-        GET /api/v1/parks/{slug}/reviews/
-        """
-        park = self.get_object()
-        reviews = park_reviews_for_park(park_id=park.id, limit=50)
-
-        serializer = ParkReviewOutputSerializer(reviews, many=True)
-
-        return self.create_response(
-            data=serializer.data,
-            metadata={"total_reviews": len(reviews), "park_name": park.name},
-        )
-
-
-class ParkCreateApi(CreateApiMixin, GenericViewSet):
-    """
-    API endpoint for creating parks.
-
-    POST /api/v1/parks/create/
-    """
-
-    permission_classes = [IsAuthenticated]
-
-    InputSerializer = ParkCreateInputSerializer
-    OutputSerializer = ParkDetailOutputSerializer
-
-    def perform_create(self, **validated_data):
-        """Create park using service layer."""
-        return ParkService.create_park(**validated_data)
-
-
-class ParkUpdateApi(UpdateApiMixin, RetrieveApiMixin, GenericViewSet):
-    """
-    API endpoint for updating parks.
-
-    PUT /api/v1/parks/{slug}/update/
-    PATCH /api/v1/parks/{slug}/update/
-    """
-
-    permission_classes = [IsAuthenticated]
-    lookup_field = "slug"
-
-    InputSerializer = ParkUpdateInputSerializer
-    OutputSerializer = ParkDetailOutputSerializer
-
-    def get_object(self):
-        """Use selector for optimized detail query."""
-        slug = self.kwargs.get("slug")
-        return park_detail_optimized(slug=slug)
-
-    def perform_update(self, instance, **validated_data):
-        """Update park using service layer."""
-        return ParkService.update_park(park_id=instance.id, **validated_data)
-
-
-class ParkDeleteApi(DestroyApiMixin, RetrieveApiMixin, GenericViewSet):
-    """
-    API endpoint for deleting parks.
-
-    DELETE /api/v1/parks/{slug}/delete/
-    """
-
-    permission_classes = [IsAuthenticated]  # TODO: Add staff/admin permission
-    lookup_field = "slug"
-
-    def get_object(self):
-        """Use selector for optimized detail query."""
-        slug = self.kwargs.get("slug")
-        return park_detail_optimized(slug=slug)
-
-    def perform_destroy(self, instance):
-        """Delete park using service layer."""
-        ParkService.delete_park(park_id=instance.id)
-
-
-# Unified API ViewSet (alternative approach)
-class ParkApi(
-    CreateApiMixin,
-    UpdateApiMixin,
-    ListApiMixin,
-    RetrieveApiMixin,
-    DestroyApiMixin,
-    GenericViewSet,
-):
-    """
-    Unified API endpoint for parks with all CRUD operations.
-
-    GET /api/v1/parks/ - List parks
-    POST /api/v1/parks/ - Create park
-    GET /api/v1/parks/{slug}/ - Get park detail
-    PUT /api/v1/parks/{slug}/ - Update park
-    PATCH /api/v1/parks/{slug}/ - Partial update park
-    DELETE /api/v1/parks/{slug}/ - Delete park
-    """
-
-    permission_classes = [IsAuthenticatedOrReadOnly]
-    lookup_field = "slug"
-    filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
-    search_fields = ["name", "description"]
-    ordering_fields = [
-        "name",
-        "opening_date",
-        "average_rating",
-        "coaster_count",
-        "created_at",
-    ]
-    ordering = ["name"]
-
-    # Serializers for different operations
-    InputSerializer = ParkCreateInputSerializer  # Used for create
-    UpdateInputSerializer = ParkUpdateInputSerializer  # Used for update
-    OutputSerializer = ParkDetailOutputSerializer  # Used for retrieve
-    ListOutputSerializer = ParkListOutputSerializer  # Used for list
-    FilterSerializer = ParkFilterInputSerializer
-
-    def get_queryset(self):
-        """Use selector to get optimized queryset."""
-        if self.action == "list":
-            # Parse filter parameters for list view
-            filter_serializer = self.FilterSerializer(data=self.request.query_params)
-            filter_serializer.is_valid(raise_exception=True)
-            filters = filter_serializer.validated_data
-            return park_list_with_stats(**filters)
-
-        # For detail views, this won't be used since we override get_object
-        return []
-
-    def get_object(self):
-        """Use selector for optimized detail query."""
-        slug = self.kwargs.get("slug")
-        return park_detail_optimized(slug=slug)
-
-    def get_output_serializer(self, *args, **kwargs):
-        """Return appropriate output serializer based on action."""
-        if self.action == "list":
-            return self.ListOutputSerializer(*args, **kwargs)
-        return self.OutputSerializer(*args, **kwargs)
-
-    def get_input_serializer(self, *args, **kwargs):
-        """Return appropriate input serializer based on action."""
-        if self.action in ["update", "partial_update"]:
-            return self.UpdateInputSerializer(*args, **kwargs)
-        return self.InputSerializer(*args, **kwargs)
-
-    def perform_create(self, **validated_data):
-        """Create park using service layer."""
-        return ParkService.create_park(**validated_data)
-
-    def perform_update(self, instance, **validated_data):
-        """Update park using service layer."""
-        return ParkService.update_park(park_id=instance.id, **validated_data)
-
-    def perform_destroy(self, instance):
-        """Delete park using service layer."""
-        ParkService.delete_park(park_id=instance.id)
-
-    @action(detail=False, methods=["get"])
-    def stats(self, request: Request) -> Response:
-        """
-        Get park statistics.
-
-        GET /api/v1/parks/stats/
-        """
-        stats = park_statistics()
-        serializer = ParkStatsOutputSerializer(stats)
-
-        return self.create_response(
-            data=serializer.data, metadata={"cache_duration": 3600}
-        )
-
-    @action(detail=True, methods=["get"])
-    def reviews(self, request: Request, slug: str = None) -> Response:
-        """
-        Get reviews for a specific park.
-
-        GET /api/v1/parks/{slug}/reviews/
-        """
-        park = self.get_object()
-        reviews = park_reviews_for_park(park_id=park.id, limit=50)
-
-        serializer = ParkReviewOutputSerializer(reviews, many=True)
-
-        return self.create_response(
-            data=serializer.data,
-            metadata={"total_reviews": len(reviews), "park_name": park.name},
-        )

backend/apps/parks/migrations/0006_remove_company_insert_insert_and_more.py

@@ -0,0 +1,163 @@
+# Generated by Django 5.2.5 on 2025-08-24 18:23
+
+import pgtrigger.compiler
+import pgtrigger.migrations
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("parks", "0005_merge_20250820_2020"),
+    ]
+
+    operations = [
+        pgtrigger.migrations.RemoveTrigger(
+            model_name="company",
+            name="insert_insert",
+        ),
+        pgtrigger.migrations.RemoveTrigger(
+            model_name="company",
+            name="update_update",
+        ),
+        pgtrigger.migrations.RemoveTrigger(
+            model_name="park",
+            name="insert_insert",
+        ),
+        pgtrigger.migrations.RemoveTrigger(
+            model_name="park",
+            name="update_update",
+        ),
+        pgtrigger.migrations.RemoveTrigger(
+            model_name="parkarea",
+            name="insert_insert",
+        ),
+        pgtrigger.migrations.RemoveTrigger(
+            model_name="parkarea",
+            name="update_update",
+        ),
+        pgtrigger.migrations.RemoveTrigger(
+            model_name="parkreview",
+            name="insert_insert",
+        ),
+        pgtrigger.migrations.RemoveTrigger(
+            model_name="parkreview",
+            name="update_update",
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="company",
+            trigger=pgtrigger.compiler.Trigger(
+                name="insert_insert",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    func='INSERT INTO "parks_companyevent" ("created_at", "description", "founded_year", "id", "name", "parks_count", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "rides_count", "roles", "slug", "updated_at", "website") VALUES (NEW."created_at", NEW."description", NEW."founded_year", NEW."id", NEW."name", NEW."parks_count", _pgh_attach_context(), NOW(), \'insert\', NEW."id", NEW."rides_count", NEW."roles", NEW."slug", NEW."updated_at", NEW."website"); RETURN NULL;',
+                    hash="0ed33eeca3344c43d8124d1f12e3acd3e6fdef02",
+                    operation="INSERT",
+                    pgid="pgtrigger_insert_insert_35b57",
+                    table="parks_company",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="company",
+            trigger=pgtrigger.compiler.Trigger(
+                name="update_update",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    condition="WHEN (OLD.* IS DISTINCT FROM NEW.*)",
+                    func='INSERT INTO "parks_companyevent" ("created_at", "description", "founded_year", "id", "name", "parks_count", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "rides_count", "roles", "slug", "updated_at", "website") VALUES (NEW."created_at", NEW."description", NEW."founded_year", NEW."id", NEW."name", NEW."parks_count", _pgh_attach_context(), NOW(), \'update\', NEW."id", NEW."rides_count", NEW."roles", NEW."slug", NEW."updated_at", NEW."website"); RETURN NULL;',
+                    hash="ce9d8347090a033d0a9550419b80a1c4a339216c",
+                    operation="UPDATE",
+                    pgid="pgtrigger_update_update_d3286",
+                    table="parks_company",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="park",
+            trigger=pgtrigger.compiler.Trigger(
+                name="insert_insert",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    func='INSERT INTO "parks_parkevent" ("average_rating", "closing_date", "coaster_count", "created_at", "description", "id", "name", "opening_date", "operating_season", "operator_id", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "property_owner_id", "ride_count", "size_acres", "slug", "status", "updated_at", "website") VALUES (NEW."average_rating", NEW."closing_date", NEW."coaster_count", NEW."created_at", NEW."description", NEW."id", NEW."name", NEW."opening_date", NEW."operating_season", NEW."operator_id", _pgh_attach_context(), NOW(), \'insert\', NEW."id", NEW."property_owner_id", NEW."ride_count", NEW."size_acres", NEW."slug", NEW."status", NEW."updated_at", NEW."website"); RETURN NULL;',
+                    hash="0a4fc95f70ad65df16aa5eaf2939266260c49213",
+                    operation="INSERT",
+                    pgid="pgtrigger_insert_insert_66883",
+                    table="parks_park",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="park",
+            trigger=pgtrigger.compiler.Trigger(
+                name="update_update",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    condition="WHEN (OLD.* IS DISTINCT FROM NEW.*)",
+                    func='INSERT INTO "parks_parkevent" ("average_rating", "closing_date", "coaster_count", "created_at", "description", "id", "name", "opening_date", "operating_season", "operator_id", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "property_owner_id", "ride_count", "size_acres", "slug", "status", "updated_at", "website") VALUES (NEW."average_rating", NEW."closing_date", NEW."coaster_count", NEW."created_at", NEW."description", NEW."id", NEW."name", NEW."opening_date", NEW."operating_season", NEW."operator_id", _pgh_attach_context(), NOW(), \'update\', NEW."id", NEW."property_owner_id", NEW."ride_count", NEW."size_acres", NEW."slug", NEW."status", NEW."updated_at", NEW."website"); RETURN NULL;',
+                    hash="24a57b318c082585e7c79da37677be7032600db9",
+                    operation="UPDATE",
+                    pgid="pgtrigger_update_update_19f56",
+                    table="parks_park",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="parkarea",
+            trigger=pgtrigger.compiler.Trigger(
+                name="insert_insert",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    func='INSERT INTO "parks_parkareaevent" ("closing_date", "created_at", "description", "id", "name", "opening_date", "park_id", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "slug", "updated_at") VALUES (NEW."closing_date", NEW."created_at", NEW."description", NEW."id", NEW."name", NEW."opening_date", NEW."park_id", _pgh_attach_context(), NOW(), \'insert\', NEW."id", NEW."slug", NEW."updated_at"); RETURN NULL;',
+                    hash="fa64ee07f872bf2214b2c1b638b028429752bac4",
+                    operation="INSERT",
+                    pgid="pgtrigger_insert_insert_13457",
+                    table="parks_parkarea",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="parkarea",
+            trigger=pgtrigger.compiler.Trigger(
+                name="update_update",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    condition="WHEN (OLD.* IS DISTINCT FROM NEW.*)",
+                    func='INSERT INTO "parks_parkareaevent" ("closing_date", "created_at", "description", "id", "name", "opening_date", "park_id", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "slug", "updated_at") VALUES (NEW."closing_date", NEW."created_at", NEW."description", NEW."id", NEW."name", NEW."opening_date", NEW."park_id", _pgh_attach_context(), NOW(), \'update\', NEW."id", NEW."slug", NEW."updated_at"); RETURN NULL;',
+                    hash="59fa84527a4fd0fa51685058b6037fa22163a095",
+                    operation="UPDATE",
+                    pgid="pgtrigger_update_update_6e5aa",
+                    table="parks_parkarea",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="parkreview",
+            trigger=pgtrigger.compiler.Trigger(
+                name="insert_insert",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    func='INSERT INTO "parks_parkreviewevent" ("content", "created_at", "id", "is_published", "moderated_at", "moderated_by_id", "moderation_notes", "park_id", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "rating", "title", "updated_at", "user_id", "visit_date") VALUES (NEW."content", NEW."created_at", NEW."id", NEW."is_published", NEW."moderated_at", NEW."moderated_by_id", NEW."moderation_notes", NEW."park_id", _pgh_attach_context(), NOW(), \'insert\', NEW."id", NEW."rating", NEW."title", NEW."updated_at", NEW."user_id", NEW."visit_date"); RETURN NULL;',
+                    hash="fb501d2b3a0d903a03f1a1ff0ae8dd79b189791f",
+                    operation="INSERT",
+                    pgid="pgtrigger_insert_insert_a99bc",
+                    table="parks_parkreview",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="parkreview",
+            trigger=pgtrigger.compiler.Trigger(
+                name="update_update",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    condition="WHEN (OLD.* IS DISTINCT FROM NEW.*)",
+                    func='INSERT INTO "parks_parkreviewevent" ("content", "created_at", "id", "is_published", "moderated_at", "moderated_by_id", "moderation_notes", "park_id", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "rating", "title", "updated_at", "user_id", "visit_date") VALUES (NEW."content", NEW."created_at", NEW."id", NEW."is_published", NEW."moderated_at", NEW."moderated_by_id", NEW."moderation_notes", NEW."park_id", _pgh_attach_context(), NOW(), \'update\', NEW."id", NEW."rating", NEW."title", NEW."updated_at", NEW."user_id", NEW."visit_date"); RETURN NULL;',
+                    hash="254ab0f9ccc0488ea313f1c50a2c35603f7ef02d",
+                    operation="UPDATE",
+                    pgid="pgtrigger_update_update_0e40d",
+                    table="parks_parkreview",
+                    when="AFTER",
+                ),
+            ),
+        ),
+    ]

backend/apps/parks/migrations/0007_companyheadquartersevent_parklocationevent_and_more.py

@@ -0,0 +1,232 @@
+# Generated by Django 5.2.5 on 2025-08-24 19:25
+
+import django.contrib.gis.db.models.fields
+import django.db.models.deletion
+import pgtrigger.compiler
+import pgtrigger.migrations
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("parks", "0006_remove_company_insert_insert_and_more"),
+        ("pghistory", "0007_auto_20250421_0444"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="CompanyHeadquartersEvent",
+            fields=[
+                ("pgh_id", models.AutoField(primary_key=True, serialize=False)),
+                ("pgh_created_at", models.DateTimeField(auto_now_add=True)),
+                ("pgh_label", models.TextField(help_text="The event label.")),
+                ("id", models.BigIntegerField()),
+                (
+                    "street_address",
+                    models.CharField(
+                        blank=True,
+                        help_text="Mailing address if publicly available",
+                        max_length=255,
+                    ),
+                ),
+                (
+                    "city",
+                    models.CharField(help_text="Headquarters city", max_length=100),
+                ),
+                (
+                    "state_province",
+                    models.CharField(
+                        blank=True, help_text="State/Province/Region", max_length=100
+                    ),
+                ),
+                (
+                    "country",
+                    models.CharField(
+                        default="USA",
+                        help_text="Country where headquarters is located",
+                        max_length=100,
+                    ),
+                ),
+                (
+                    "postal_code",
+                    models.CharField(
+                        blank=True, help_text="ZIP or postal code", max_length=20
+                    ),
+                ),
+                (
+                    "mailing_address",
+                    models.TextField(
+                        blank=True,
+                        help_text="Complete mailing address if different from basic address",
+                    ),
+                ),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+        migrations.CreateModel(
+            name="ParkLocationEvent",
+            fields=[
+                ("pgh_id", models.AutoField(primary_key=True, serialize=False)),
+                ("pgh_created_at", models.DateTimeField(auto_now_add=True)),
+                ("pgh_label", models.TextField(help_text="The event label.")),
+                ("id", models.BigIntegerField()),
+                (
+                    "point",
+                    django.contrib.gis.db.models.fields.PointField(
+                        blank=True,
+                        help_text="Geographic coordinates (longitude, latitude)",
+                        null=True,
+                        srid=4326,
+                    ),
+                ),
+                ("street_address", models.CharField(blank=True, max_length=255)),
+                ("city", models.CharField(max_length=100)),
+                ("state", models.CharField(max_length=100)),
+                ("country", models.CharField(default="USA", max_length=100)),
+                ("postal_code", models.CharField(blank=True, max_length=20)),
+                ("highway_exit", models.CharField(blank=True, max_length=100)),
+                ("parking_notes", models.TextField(blank=True)),
+                ("best_arrival_time", models.TimeField(blank=True, null=True)),
+                ("seasonal_notes", models.TextField(blank=True)),
+                ("osm_id", models.BigIntegerField(blank=True, null=True)),
+                (
+                    "osm_type",
+                    models.CharField(
+                        blank=True,
+                        help_text="Type of OpenStreetMap object (node, way, or relation)",
+                        max_length=10,
+                    ),
+                ),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="companyheadquarters",
+            trigger=pgtrigger.compiler.Trigger(
+                name="insert_insert",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    func='INSERT INTO "parks_companyheadquartersevent" ("city", "company_id", "country", "created_at", "id", "mailing_address", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "postal_code", "state_province", "street_address", "updated_at") VALUES (NEW."city", NEW."company_id", NEW."country", NEW."created_at", NEW."id", NEW."mailing_address", _pgh_attach_context(), NOW(), \'insert\', NEW."id", NEW."postal_code", NEW."state_province", NEW."street_address", NEW."updated_at"); RETURN NULL;',
+                    hash="acf99673091ec3717f404fdccefd6e0cb228c82e",
+                    operation="INSERT",
+                    pgid="pgtrigger_insert_insert_72259",
+                    table="parks_companyheadquarters",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="companyheadquarters",
+            trigger=pgtrigger.compiler.Trigger(
+                name="update_update",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    condition="WHEN (OLD.* IS DISTINCT FROM NEW.*)",
+                    func='INSERT INTO "parks_companyheadquartersevent" ("city", "company_id", "country", "created_at", "id", "mailing_address", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "postal_code", "state_province", "street_address", "updated_at") VALUES (NEW."city", NEW."company_id", NEW."country", NEW."created_at", NEW."id", NEW."mailing_address", _pgh_attach_context(), NOW(), \'update\', NEW."id", NEW."postal_code", NEW."state_province", NEW."street_address", NEW."updated_at"); RETURN NULL;',
+                    hash="bbbff3a1c9748d3ce1b2bf1b705d03ea40530c9b",
+                    operation="UPDATE",
+                    pgid="pgtrigger_update_update_c5392",
+                    table="parks_companyheadquarters",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="parklocation",
+            trigger=pgtrigger.compiler.Trigger(
+                name="insert_insert",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    func='INSERT INTO "parks_parklocationevent" ("best_arrival_time", "city", "country", "highway_exit", "id", "osm_id", "osm_type", "park_id", "parking_notes", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "point", "postal_code", "seasonal_notes", "state", "street_address") VALUES (NEW."best_arrival_time", NEW."city", NEW."country", NEW."highway_exit", NEW."id", NEW."osm_id", NEW."osm_type", NEW."park_id", NEW."parking_notes", _pgh_attach_context(), NOW(), \'insert\', NEW."id", NEW."point", NEW."postal_code", NEW."seasonal_notes", NEW."state", NEW."street_address"); RETURN NULL;',
+                    hash="fcc717a6f7408f959ac1f6406d4ba42b674e3c55",
+                    operation="INSERT",
+                    pgid="pgtrigger_insert_insert_f8c53",
+                    table="parks_parklocation",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="parklocation",
+            trigger=pgtrigger.compiler.Trigger(
+                name="update_update",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    condition="WHEN (OLD.* IS DISTINCT FROM NEW.*)",
+                    func='INSERT INTO "parks_parklocationevent" ("best_arrival_time", "city", "country", "highway_exit", "id", "osm_id", "osm_type", "park_id", "parking_notes", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "point", "postal_code", "seasonal_notes", "state", "street_address") VALUES (NEW."best_arrival_time", NEW."city", NEW."country", NEW."highway_exit", NEW."id", NEW."osm_id", NEW."osm_type", NEW."park_id", NEW."parking_notes", _pgh_attach_context(), NOW(), \'update\', NEW."id", NEW."point", NEW."postal_code", NEW."seasonal_notes", NEW."state", NEW."street_address"); RETURN NULL;',
+                    hash="dedb3937ae968cc9f2b30309fbf72d9168039efe",
+                    operation="UPDATE",
+                    pgid="pgtrigger_update_update_6dd0d",
+                    table="parks_parklocation",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        migrations.AddField(
+            model_name="companyheadquartersevent",
+            name="company",
+            field=models.ForeignKey(
+                db_constraint=False,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                related_query_name="+",
+                to="parks.company",
+            ),
+        ),
+        migrations.AddField(
+            model_name="companyheadquartersevent",
+            name="pgh_context",
+            field=models.ForeignKey(
+                db_constraint=False,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                to="pghistory.context",
+            ),
+        ),
+        migrations.AddField(
+            model_name="companyheadquartersevent",
+            name="pgh_obj",
+            field=models.ForeignKey(
+                db_constraint=False,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="events",
+                to="parks.companyheadquarters",
+            ),
+        ),
+        migrations.AddField(
+            model_name="parklocationevent",
+            name="park",
+            field=models.ForeignKey(
+                db_constraint=False,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                related_query_name="+",
+                to="parks.park",
+            ),
+        ),
+        migrations.AddField(
+            model_name="parklocationevent",
+            name="pgh_context",
+            field=models.ForeignKey(
+                db_constraint=False,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                to="pghistory.context",
+            ),
+        ),
+        migrations.AddField(
+            model_name="parklocationevent",
+            name="pgh_obj",
+            field=models.ForeignKey(
+                db_constraint=False,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="events",
+                to="parks.parklocation",
+            ),
+        ),
+    ]

backend/apps/parks/models/companies.py

@@ -40,12 +40,13 @@ class Company(TrackedModel):
     def __str__(self):
         return self.name
 
-    class Meta:
+    class Meta(TrackedModel.Meta):
         app_label = "parks"
         ordering = ["name"]
         verbose_name_plural = "Companies"
 
 
+@pghistory.track()
 class CompanyHeadquarters(models.Model):
     """
     Simple address storage for company headquarters without coordinate tracking.

backend/apps/parks/models/location.py

@@ -1,7 +1,9 @@
 from django.contrib.gis.db import models
 from django.contrib.gis.geos import Point
+import pghistory
 
 
+@pghistory.track()
 class ParkLocation(models.Model):
     """
     Represents the geographic location and address of a park, with PostGIS support.

backend/apps/rides/admin.py

@@ -1,8 +1,10 @@
 from django.contrib import admin
 from django.contrib.gis.admin import GISModelAdmin
+from django.utils.html import format_html
 from .models.company import Company
-from .models.rides import Ride
+from .models.rides import Ride, RideModel, RollerCoasterStats
 from .models.location import RideLocation
+from .models.reviews import RideReview
 
 
 class ManufacturerAdmin(admin.ModelAdmin):
@@ -74,23 +76,412 @@ class RideLocationAdmin(GISModelAdmin):
         ),
     )
 
+    @admin.display(description="Latitude")
     def latitude(self, obj):
         return obj.latitude
 
-    latitude.short_description = "Latitude"
-
+    @admin.display(description="Longitude")
     def longitude(self, obj):
         return obj.longitude
 
-    longitude.short_description = "Longitude"
+
+class RollerCoasterStatsInline(admin.StackedInline):
+    """Inline admin for RollerCoasterStats"""
+
+    model = RollerCoasterStats
+    extra = 0
+    fields = (
+        ("height_ft", "length_ft", "speed_mph"),
+        ("track_material", "roller_coaster_type"),
+        ("launch_type", "inversions"),
+        ("max_drop_height_ft", "ride_time_seconds"),
+        ("train_style", "trains_count"),
+        ("cars_per_train", "seats_per_car"),
+    )
+    classes = ("collapse",)
 
 
+@admin.register(Ride)
 class RideAdmin(admin.ModelAdmin):
-    """Enhanced Ride admin with location inline"""
+    """Enhanced Ride admin with location and coaster stats inlines"""
 
-    inlines = [RideLocationInline]
+    list_display = (
+        "name",
+        "park",
+        "category_display",
+        "manufacturer",
+        "status",
+        "opening_date",
+        "average_rating",
+    )
+    list_filter = (
+        "category",
+        "status",
+        "park",
+        "manufacturer",
+        "designer",
+        "opening_date",
+    )
+    search_fields = (
+        "name",
+        "description",
+        "park__name",
+        "manufacturer__name",
+        "designer__name",
+    )
+    readonly_fields = ("created_at", "updated_at")
+    prepopulated_fields = {"slug": ("name",)}
+    inlines = [RideLocationInline, RollerCoasterStatsInline]
+    date_hierarchy = "opening_date"
+    ordering = ("park", "name")
+
+    fieldsets = (
+        (
+            "Basic Information",
+            {
+                "fields": (
+                    "name",
+                    "slug",
+                    "description",
+                    "park",
+                    "park_area",
+                    "category",
+                )
+            },
+        ),
+        (
+            "Companies",
+            {
+                "fields": (
+                    "manufacturer",
+                    "designer",
+                    "ride_model",
+                )
+            },
+        ),
+        (
+            "Status & Dates",
+            {
+                "fields": (
+                    "status",
+                    "post_closing_status",
+                    "opening_date",
+                    "closing_date",
+                    "status_since",
+                )
+            },
+        ),
+        (
+            "Ride Specifications",
+            {
+                "fields": (
+                    "min_height_in",
+                    "max_height_in",
+                    "capacity_per_hour",
+                    "ride_duration_seconds",
+                    "average_rating",
+                ),
+                "classes": ("collapse",),
+            },
+        ),
+        (
+            "Metadata",
+            {
+                "fields": ("created_at", "updated_at"),
+                "classes": ("collapse",),
+            },
+        ),
+    )
+
+    @admin.display(description="Category")
+    def category_display(self, obj):
+        """Display category with full name"""
+        return dict(obj._meta.get_field("category").choices).get(
+            obj.category, obj.category
+        )
+
+
+@admin.register(RideModel)
+class RideModelAdmin(admin.ModelAdmin):
+    """Admin interface for ride models"""
+
+    list_display = (
+        "name",
+        "manufacturer",
+        "category_display",
+        "ride_count",
+    )
+    list_filter = (
+        "manufacturer",
+        "category",
+    )
+    search_fields = (
+        "name",
+        "description",
+        "manufacturer__name",
+    )
+    ordering = ("manufacturer", "name")
+
+    fieldsets = (
+        (
+            "Model Information",
+            {
+                "fields": (
+                    "name",
+                    "manufacturer",
+                    "category",
+                    "description",
+                )
+            },
+        ),
+    )
+
+    @admin.display(description="Category")
+    def category_display(self, obj):
+        """Display category with full name"""
+        return dict(obj._meta.get_field("category").choices).get(
+            obj.category, obj.category
+        )
+
+    @admin.display(description="Installations")
+    def ride_count(self, obj):
+        """Display number of ride installations"""
+        return obj.rides.count()
+
+
+@admin.register(RollerCoasterStats)
+class RollerCoasterStatsAdmin(admin.ModelAdmin):
+    """Admin interface for roller coaster statistics"""
+
+    list_display = (
+        "ride",
+        "height_ft",
+        "speed_mph",
+        "length_ft",
+        "inversions",
+        "track_material",
+        "roller_coaster_type",
+    )
+    list_filter = (
+        "track_material",
+        "roller_coaster_type",
+        "launch_type",
+        "inversions",
+    )
+    search_fields = (
+        "ride__name",
+        "ride__park__name",
+        "track_type",
+        "train_style",
+    )
+    readonly_fields = ("calculated_capacity",)
+
+    fieldsets = (
+        (
+            "Basic Stats",
+            {
+                "fields": (
+                    "ride",
+                    "height_ft",
+                    "length_ft",
+                    "speed_mph",
+                    "max_drop_height_ft",
+                )
+            },
+        ),
+        (
+            "Track & Design",
+            {
+                "fields": (
+                    "track_material",
+                    "track_type",
+                    "roller_coaster_type",
+                    "launch_type",
+                    "inversions",
+                )
+            },
+        ),
+        (
+            "Operation Details",
+            {
+                "fields": (
+                    "ride_time_seconds",
+                    "train_style",
+                    "trains_count",
+                    "cars_per_train",
+                    "seats_per_car",
+                    "calculated_capacity",
+                ),
+                "classes": ("collapse",),
+            },
+        ),
+    )
+
+    @admin.display(description="Calculated Capacity")
+    def calculated_capacity(self, obj):
+        """Calculate theoretical hourly capacity"""
+        if all(
+            [
+                obj.trains_count,
+                obj.cars_per_train,
+                obj.seats_per_car,
+                obj.ride_time_seconds,
+            ]
+        ):
+            total_seats = obj.trains_count * obj.cars_per_train * obj.seats_per_car
+            # Add 2 min loading time
+            cycles_per_hour = 3600 / (obj.ride_time_seconds + 120)
+            return f"{int(total_seats * cycles_per_hour)} riders/hour"
+        return "N/A"
+
+
+@admin.register(RideReview)
+class RideReviewAdmin(admin.ModelAdmin):
+    """Admin interface for ride reviews"""
+
+    list_display = (
+        "ride",
+        "user",
+        "rating",
+        "title",
+        "visit_date",
+        "is_published",
+        "created_at",
+        "moderation_status",
+    )
+    list_filter = (
+        "rating",
+        "is_published",
+        "visit_date",
+        "created_at",
+        "ride__park",
+        "moderated_by",
+    )
+    search_fields = (
+        "title",
+        "content",
+        "user__username",
+        "ride__name",
+        "ride__park__name",
+    )
+    readonly_fields = ("created_at", "updated_at")
+    date_hierarchy = "created_at"
+    ordering = ("-created_at",)
+
+    fieldsets = (
+        (
+            "Review Details",
+            {
+                "fields": (
+                    "user",
+                    "ride",
+                    "rating",
+                    "title",
+                    "content",
+                    "visit_date",
+                )
+            },
+        ),
+        (
+            "Publication Status",
+            {
+                "fields": ("is_published",),
+            },
+        ),
+        (
+            "Moderation",
+            {
+                "fields": (
+                    "moderated_by",
+                    "moderated_at",
+                    "moderation_notes",
+                ),
+                "classes": ("collapse",),
+            },
+        ),
+        (
+            "Metadata",
+            {
+                "fields": ("created_at", "updated_at"),
+                "classes": ("collapse",),
+            },
+        ),
+    )
+
+    @admin.display(description="Moderation Status", boolean=True)
+    def moderation_status(self, obj):
+        """Display moderation status with color coding"""
+        if obj.moderated_by:
+            return format_html(
+                '<span style="color: {};">{}</span>',
+                "green" if obj.is_published else "red",
+                "Approved" if obj.is_published else "Rejected",
+            )
+        return format_html('<span style="color: orange;">Pending</span>')
+
+    def save_model(self, request, obj, form, change):
+        """Auto-set moderation info when status changes"""
+        if change and "is_published" in form.changed_data:
+            from django.utils import timezone
+
+            obj.moderated_by = request.user
+            obj.moderated_at = timezone.now()
+        super().save_model(request, obj, form, change)
+
+
+@admin.register(Company)
+class CompanyAdmin(admin.ModelAdmin):
+    """Enhanced Company admin for rides app"""
+
+    list_display = (
+        "name",
+        "roles_display",
+        "website",
+        "founded_date",
+        "rides_count",
+        "coasters_count",
+    )
+    list_filter = ("roles", "founded_date")
+    search_fields = ("name", "description")
+    readonly_fields = ("created_at", "updated_at")
+    prepopulated_fields = {"slug": ("name",)}
+
+    fieldsets = (
+        (
+            "Basic Information",
+            {
+                "fields": (
+                    "name",
+                    "slug",
+                    "roles",
+                    "description",
+                    "website",
+                )
+            },
+        ),
+        (
+            "Company Details",
+            {
+                "fields": (
+                    "founded_date",
+                    "rides_count",
+                    "coasters_count",
+                )
+            },
+        ),
+        (
+            "Metadata",
+            {
+                "fields": ("created_at", "updated_at"),
+                "classes": ("collapse",),
+            },
+        ),
+    )
+
+    @admin.display(description="Roles")
+    def roles_display(self, obj):
+        """Display roles as a formatted string"""
+        return ", ".join(obj.roles) if obj.roles else "No roles"
 
 
-admin.site.register(Company)
-admin.site.register(Ride, RideAdmin)
 admin.site.register(RideLocation, RideLocationAdmin)

backend/apps/rides/api/__init__.py

@@ -1 +0,0 @@
-# Rides API module

backend/apps/rides/api/serializers.py

@@ -1,345 +0,0 @@
-"""
-Serializers for Rides API following Django styleguide patterns.
-"""
-
-from rest_framework import serializers
-from ..models import Ride
-
-
-class RideModelOutputSerializer(serializers.Serializer):
-    """Output serializer for ride model data."""
-
-    id = serializers.IntegerField()
-    name = serializers.CharField()
-    description = serializers.CharField()
-    category = serializers.CharField()
-    manufacturer = serializers.SerializerMethodField()
-
-    def get_manufacturer(self, obj):
-        if obj.manufacturer:
-            return {
-                "id": obj.manufacturer.id,
-                "name": obj.manufacturer.name,
-                "slug": obj.manufacturer.slug,
-            }
-        return None
-
-
-class RideParkOutputSerializer(serializers.Serializer):
-    """Output serializer for ride's park data."""
-
-    id = serializers.IntegerField()
-    name = serializers.CharField()
-    slug = serializers.CharField()
-
-
-class RideListOutputSerializer(serializers.Serializer):
-    """Output serializer for ride list view."""
-
-    id = serializers.IntegerField()
-    name = serializers.CharField()
-    slug = serializers.CharField()
-    category = serializers.CharField()
-    status = serializers.CharField()
-    description = serializers.CharField()
-
-    # Park info
-    park = RideParkOutputSerializer()
-
-    # Statistics
-    average_rating = serializers.DecimalField(
-        max_digits=3, decimal_places=2, allow_null=True
-    )
-    capacity_per_hour = serializers.IntegerField(allow_null=True)
-
-    # Dates
-    opening_date = serializers.DateField(allow_null=True)
-    closing_date = serializers.DateField(allow_null=True)
-
-    # Metadata
-    created_at = serializers.DateTimeField()
-    updated_at = serializers.DateTimeField()
-
-
-class RideDetailOutputSerializer(serializers.Serializer):
-    """Output serializer for ride detail view."""
-
-    id = serializers.IntegerField()
-    name = serializers.CharField()
-    slug = serializers.CharField()
-    category = serializers.CharField()
-    status = serializers.CharField()
-    post_closing_status = serializers.CharField(allow_null=True)
-    description = serializers.CharField()
-
-    # Park info
-    park = RideParkOutputSerializer()
-    park_area = serializers.SerializerMethodField()
-
-    # Dates
-    opening_date = serializers.DateField(allow_null=True)
-    closing_date = serializers.DateField(allow_null=True)
-    status_since = serializers.DateField(allow_null=True)
-
-    # Physical specs
-    min_height_in = serializers.IntegerField(allow_null=True)
-    max_height_in = serializers.IntegerField(allow_null=True)
-    capacity_per_hour = serializers.IntegerField(allow_null=True)
-    ride_duration_seconds = serializers.IntegerField(allow_null=True)
-
-    # Statistics
-    average_rating = serializers.DecimalField(
-        max_digits=3, decimal_places=2, allow_null=True
-    )
-
-    # Companies
-    manufacturer = serializers.SerializerMethodField()
-    designer = serializers.SerializerMethodField()
-
-    # Model
-    ride_model = RideModelOutputSerializer(allow_null=True)
-
-    # Metadata
-    created_at = serializers.DateTimeField()
-    updated_at = serializers.DateTimeField()
-
-    def get_park_area(self, obj):
-        if obj.park_area:
-            return {
-                "id": obj.park_area.id,
-                "name": obj.park_area.name,
-                "slug": obj.park_area.slug,
-            }
-        return None
-
-    def get_manufacturer(self, obj):
-        if obj.manufacturer:
-            return {
-                "id": obj.manufacturer.id,
-                "name": obj.manufacturer.name,
-                "slug": obj.manufacturer.slug,
-            }
-        return None
-
-    def get_designer(self, obj):
-        if obj.designer:
-            return {
-                "id": obj.designer.id,
-                "name": obj.designer.name,
-                "slug": obj.designer.slug,
-            }
-        return None
-
-
-class RideCreateInputSerializer(serializers.Serializer):
-    """Input serializer for creating rides."""
-
-    name = serializers.CharField(max_length=255)
-    description = serializers.CharField(allow_blank=True, default="")
-    category = serializers.ChoiceField(choices=Ride.CATEGORY_CHOICES)
-    status = serializers.ChoiceField(choices=Ride.STATUS_CHOICES, default="OPERATING")
-
-    # Required park
-    park_id = serializers.IntegerField()
-
-    # Optional area
-    park_area_id = serializers.IntegerField(required=False, allow_null=True)
-
-    # Optional dates
-    opening_date = serializers.DateField(required=False, allow_null=True)
-    closing_date = serializers.DateField(required=False, allow_null=True)
-    status_since = serializers.DateField(required=False, allow_null=True)
-
-    # Optional specs
-    min_height_in = serializers.IntegerField(
-        required=False, allow_null=True, min_value=30, max_value=90
-    )
-    max_height_in = serializers.IntegerField(
-        required=False, allow_null=True, min_value=30, max_value=90
-    )
-    capacity_per_hour = serializers.IntegerField(
-        required=False, allow_null=True, min_value=1
-    )
-    ride_duration_seconds = serializers.IntegerField(
-        required=False, allow_null=True, min_value=1
-    )
-
-    # Optional companies
-    manufacturer_id = serializers.IntegerField(required=False, allow_null=True)
-    designer_id = serializers.IntegerField(required=False, allow_null=True)
-
-    # Optional model
-    ride_model_id = serializers.IntegerField(required=False, allow_null=True)
-
-    def validate(self, data):
-        """Cross-field validation."""
-        # Date validation
-        opening_date = data.get("opening_date")
-        closing_date = data.get("closing_date")
-
-        if opening_date and closing_date and closing_date < opening_date:
-            raise serializers.ValidationError(
-                "Closing date cannot be before opening date"
-            )
-
-        # Height validation
-        min_height = data.get("min_height_in")
-        max_height = data.get("max_height_in")
-
-        if min_height and max_height and min_height > max_height:
-            raise serializers.ValidationError(
-                "Minimum height cannot be greater than maximum height"
-            )
-
-        return data
-
-
-class RideUpdateInputSerializer(serializers.Serializer):
-    """Input serializer for updating rides."""
-
-    name = serializers.CharField(max_length=255, required=False)
-    description = serializers.CharField(allow_blank=True, required=False)
-    category = serializers.ChoiceField(choices=Ride.CATEGORY_CHOICES, required=False)
-    status = serializers.ChoiceField(choices=Ride.STATUS_CHOICES, required=False)
-    post_closing_status = serializers.ChoiceField(
-        choices=Ride.POST_CLOSING_STATUS_CHOICES,
-        required=False,
-        allow_null=True,
-    )
-
-    # Park and area
-    park_id = serializers.IntegerField(required=False)
-    park_area_id = serializers.IntegerField(required=False, allow_null=True)
-
-    # Dates
-    opening_date = serializers.DateField(required=False, allow_null=True)
-    closing_date = serializers.DateField(required=False, allow_null=True)
-    status_since = serializers.DateField(required=False, allow_null=True)
-
-    # Specs
-    min_height_in = serializers.IntegerField(
-        required=False, allow_null=True, min_value=30, max_value=90
-    )
-    max_height_in = serializers.IntegerField(
-        required=False, allow_null=True, min_value=30, max_value=90
-    )
-    capacity_per_hour = serializers.IntegerField(
-        required=False, allow_null=True, min_value=1
-    )
-    ride_duration_seconds = serializers.IntegerField(
-        required=False, allow_null=True, min_value=1
-    )
-
-    # Companies
-    manufacturer_id = serializers.IntegerField(required=False, allow_null=True)
-    designer_id = serializers.IntegerField(required=False, allow_null=True)
-
-    # Model
-    ride_model_id = serializers.IntegerField(required=False, allow_null=True)
-
-    def validate(self, data):
-        """Cross-field validation."""
-        # Date validation
-        opening_date = data.get("opening_date")
-        closing_date = data.get("closing_date")
-
-        if opening_date and closing_date and closing_date < opening_date:
-            raise serializers.ValidationError(
-                "Closing date cannot be before opening date"
-            )
-
-        # Height validation
-        min_height = data.get("min_height_in")
-        max_height = data.get("max_height_in")
-
-        if min_height and max_height and min_height > max_height:
-            raise serializers.ValidationError(
-                "Minimum height cannot be greater than maximum height"
-            )
-
-        return data
-
-
-class RideFilterInputSerializer(serializers.Serializer):
-    """Input serializer for ride filtering and search."""
-
-    # Search
-    search = serializers.CharField(required=False, allow_blank=True)
-
-    # Category filter
-    category = serializers.MultipleChoiceField(
-        choices=Ride.CATEGORY_CHOICES, required=False
-    )
-
-    # Status filter
-    status = serializers.MultipleChoiceField(
-        choices=Ride.STATUS_CHOICES, required=False
-    )
-
-    # Park filter
-    park_id = serializers.IntegerField(required=False)
-    park_slug = serializers.CharField(required=False, allow_blank=True)
-
-    # Company filters
-    manufacturer_id = serializers.IntegerField(required=False)
-    designer_id = serializers.IntegerField(required=False)
-
-    # Rating filter
-    min_rating = serializers.DecimalField(
-        max_digits=3,
-        decimal_places=2,
-        required=False,
-        min_value=1,
-        max_value=10,
-    )
-
-    # Height filters
-    min_height_requirement = serializers.IntegerField(required=False)
-    max_height_requirement = serializers.IntegerField(required=False)
-
-    # Capacity filter
-    min_capacity = serializers.IntegerField(required=False)
-
-    # Ordering
-    ordering = serializers.ChoiceField(
-        choices=[
-            "name",
-            "-name",
-            "opening_date",
-            "-opening_date",
-            "average_rating",
-            "-average_rating",
-            "capacity_per_hour",
-            "-capacity_per_hour",
-            "created_at",
-            "-created_at",
-        ],
-        required=False,
-        default="name",
-    )
-
-
-class RideStatsOutputSerializer(serializers.Serializer):
-    """Output serializer for ride statistics."""
-
-    total_rides = serializers.IntegerField()
-    operating_rides = serializers.IntegerField()
-    closed_rides = serializers.IntegerField()
-    under_construction = serializers.IntegerField()
-
-    # By category
-    rides_by_category = serializers.DictField()
-
-    # Averages
-    average_rating = serializers.DecimalField(
-        max_digits=3, decimal_places=2, allow_null=True
-    )
-    average_capacity = serializers.DecimalField(
-        max_digits=8, decimal_places=2, allow_null=True
-    )
-
-    # Top manufacturers
-    top_manufacturers = serializers.ListField(child=serializers.DictField())
-
-    # Recently added
-    recently_added_count = serializers.IntegerField()

backend/apps/rides/api/urls.py

@@ -1,14 +0,0 @@
-"""
-URL configuration for Rides API following Django styleguide patterns.
-"""
-
-# Note: We'll create the views file after this
-# from .views import RideApi
-
-app_name = "rides_api"
-
-# Placeholder for future implementation
-urlpatterns = [
-    # Will be implemented in next phase
-    # path('v1/', include(router.urls)),
-]

backend/apps/rides/migrations/0003_remove_company_insert_insert_and_more.py

@@ -0,0 +1,89 @@
+# Generated by Django 5.2.5 on 2025-08-24 18:23
+
+import pgtrigger.compiler
+import pgtrigger.migrations
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("rides", "0002_add_business_constraints"),
+    ]
+
+    operations = [
+        pgtrigger.migrations.RemoveTrigger(
+            model_name="company",
+            name="insert_insert",
+        ),
+        pgtrigger.migrations.RemoveTrigger(
+            model_name="company",
+            name="update_update",
+        ),
+        pgtrigger.migrations.RemoveTrigger(
+            model_name="ridereview",
+            name="insert_insert",
+        ),
+        pgtrigger.migrations.RemoveTrigger(
+            model_name="ridereview",
+            name="update_update",
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="company",
+            trigger=pgtrigger.compiler.Trigger(
+                name="insert_insert",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    func='INSERT INTO "rides_companyevent" ("coasters_count", "created_at", "description", "founded_date", "id", "name", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "rides_count", "roles", "slug", "updated_at", "website") VALUES (NEW."coasters_count", NEW."created_at", NEW."description", NEW."founded_date", NEW."id", NEW."name", _pgh_attach_context(), NOW(), \'insert\', NEW."id", NEW."rides_count", NEW."roles", NEW."slug", NEW."updated_at", NEW."website"); RETURN NULL;',
+                    hash="8229e39396673e3801d570ad8d1c602b528fadc1",
+                    operation="INSERT",
+                    pgid="pgtrigger_insert_insert_e7194",
+                    table="rides_company",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="company",
+            trigger=pgtrigger.compiler.Trigger(
+                name="update_update",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    condition="WHEN (OLD.* IS DISTINCT FROM NEW.*)",
+                    func='INSERT INTO "rides_companyevent" ("coasters_count", "created_at", "description", "founded_date", "id", "name", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "rides_count", "roles", "slug", "updated_at", "website") VALUES (NEW."coasters_count", NEW."created_at", NEW."description", NEW."founded_date", NEW."id", NEW."name", _pgh_attach_context(), NOW(), \'update\', NEW."id", NEW."rides_count", NEW."roles", NEW."slug", NEW."updated_at", NEW."website"); RETURN NULL;',
+                    hash="9d4d58e00963bf10b3cc428ef609044104366655",
+                    operation="UPDATE",
+                    pgid="pgtrigger_update_update_456a8",
+                    table="rides_company",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="ridereview",
+            trigger=pgtrigger.compiler.Trigger(
+                name="insert_insert",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    func='INSERT INTO "rides_ridereviewevent" ("content", "created_at", "id", "is_published", "moderated_at", "moderated_by_id", "moderation_notes", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "rating", "ride_id", "title", "updated_at", "user_id", "visit_date") VALUES (NEW."content", NEW."created_at", NEW."id", NEW."is_published", NEW."moderated_at", NEW."moderated_by_id", NEW."moderation_notes", _pgh_attach_context(), NOW(), \'insert\', NEW."id", NEW."rating", NEW."ride_id", NEW."title", NEW."updated_at", NEW."user_id", NEW."visit_date"); RETURN NULL;',
+                    hash="0d6021859fef528429d7d6028439c08de6040e52",
+                    operation="INSERT",
+                    pgid="pgtrigger_insert_insert_33237",
+                    table="rides_ridereview",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="ridereview",
+            trigger=pgtrigger.compiler.Trigger(
+                name="update_update",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    condition="WHEN (OLD.* IS DISTINCT FROM NEW.*)",
+                    func='INSERT INTO "rides_ridereviewevent" ("content", "created_at", "id", "is_published", "moderated_at", "moderated_by_id", "moderation_notes", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "rating", "ride_id", "title", "updated_at", "user_id", "visit_date") VALUES (NEW."content", NEW."created_at", NEW."id", NEW."is_published", NEW."moderated_at", NEW."moderated_by_id", NEW."moderation_notes", _pgh_attach_context(), NOW(), \'update\', NEW."id", NEW."rating", NEW."ride_id", NEW."title", NEW."updated_at", NEW."user_id", NEW."visit_date"); RETURN NULL;',
+                    hash="b0acd6ed16f909a42f9bedd975c7f385d0868d32",
+                    operation="UPDATE",
+                    pgid="pgtrigger_update_update_90298",
+                    table="rides_ridereview",
+                    when="AFTER",
+                ),
+            ),
+        ),
+    ]

backend/apps/rides/migrations/0004_rideevent_ridemodelevent_rollercoasterstatsevent_and_more.py

@@ -0,0 +1,470 @@
+# Generated by Django 5.2.5 on 2025-08-24 19:11
+
+import django.db.models.deletion
+import pgtrigger.compiler
+import pgtrigger.migrations
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("parks", "0006_remove_company_insert_insert_and_more"),
+        ("pghistory", "0007_auto_20250421_0444"),
+        ("rides", "0003_remove_company_insert_insert_and_more"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="RideEvent",
+            fields=[
+                ("pgh_id", models.AutoField(primary_key=True, serialize=False)),
+                ("pgh_created_at", models.DateTimeField(auto_now_add=True)),
+                ("pgh_label", models.TextField(help_text="The event label.")),
+                ("id", models.BigIntegerField()),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                ("name", models.CharField(max_length=255)),
+                ("slug", models.SlugField(db_index=False, max_length=255)),
+                ("description", models.TextField(blank=True)),
+                (
+                    "category",
+                    models.CharField(
+                        blank=True,
+                        choices=[
+                            ("", "Select ride type"),
+                            ("RC", "Roller Coaster"),
+                            ("DR", "Dark Ride"),
+                            ("FR", "Flat Ride"),
+                            ("WR", "Water Ride"),
+                            ("TR", "Transport"),
+                            ("OT", "Other"),
+                        ],
+                        default="",
+                        max_length=2,
+                    ),
+                ),
+                (
+                    "status",
+                    models.CharField(
+                        choices=[
+                            ("", "Select status"),
+                            ("OPERATING", "Operating"),
+                            ("CLOSED_TEMP", "Temporarily Closed"),
+                            ("SBNO", "Standing But Not Operating"),
+                            ("CLOSING", "Closing"),
+                            ("CLOSED_PERM", "Permanently Closed"),
+                            ("UNDER_CONSTRUCTION", "Under Construction"),
+                            ("DEMOLISHED", "Demolished"),
+                            ("RELOCATED", "Relocated"),
+                        ],
+                        default="OPERATING",
+                        max_length=20,
+                    ),
+                ),
+                (
+                    "post_closing_status",
+                    models.CharField(
+                        blank=True,
+                        choices=[
+                            ("SBNO", "Standing But Not Operating"),
+                            ("CLOSED_PERM", "Permanently Closed"),
+                        ],
+                        help_text="Status to change to after closing date",
+                        max_length=20,
+                        null=True,
+                    ),
+                ),
+                ("opening_date", models.DateField(blank=True, null=True)),
+                ("closing_date", models.DateField(blank=True, null=True)),
+                ("status_since", models.DateField(blank=True, null=True)),
+                ("min_height_in", models.PositiveIntegerField(blank=True, null=True)),
+                ("max_height_in", models.PositiveIntegerField(blank=True, null=True)),
+                (
+                    "capacity_per_hour",
+                    models.PositiveIntegerField(blank=True, null=True),
+                ),
+                (
+                    "ride_duration_seconds",
+                    models.PositiveIntegerField(blank=True, null=True),
+                ),
+                (
+                    "average_rating",
+                    models.DecimalField(
+                        blank=True, decimal_places=2, max_digits=3, null=True
+                    ),
+                ),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+        migrations.CreateModel(
+            name="RideModelEvent",
+            fields=[
+                ("pgh_id", models.AutoField(primary_key=True, serialize=False)),
+                ("pgh_created_at", models.DateTimeField(auto_now_add=True)),
+                ("pgh_label", models.TextField(help_text="The event label.")),
+                ("id", models.BigIntegerField()),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                ("name", models.CharField(max_length=255)),
+                ("description", models.TextField(blank=True)),
+                (
+                    "category",
+                    models.CharField(
+                        blank=True,
+                        choices=[
+                            ("", "Select ride type"),
+                            ("RC", "Roller Coaster"),
+                            ("DR", "Dark Ride"),
+                            ("FR", "Flat Ride"),
+                            ("WR", "Water Ride"),
+                            ("TR", "Transport"),
+                            ("OT", "Other"),
+                        ],
+                        default="",
+                        max_length=2,
+                    ),
+                ),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+        migrations.CreateModel(
+            name="RollerCoasterStatsEvent",
+            fields=[
+                ("pgh_id", models.AutoField(primary_key=True, serialize=False)),
+                ("pgh_created_at", models.DateTimeField(auto_now_add=True)),
+                ("pgh_label", models.TextField(help_text="The event label.")),
+                ("id", models.BigIntegerField()),
+                (
+                    "height_ft",
+                    models.DecimalField(
+                        blank=True, decimal_places=2, max_digits=6, null=True
+                    ),
+                ),
+                (
+                    "length_ft",
+                    models.DecimalField(
+                        blank=True, decimal_places=2, max_digits=7, null=True
+                    ),
+                ),
+                (
+                    "speed_mph",
+                    models.DecimalField(
+                        blank=True, decimal_places=2, max_digits=5, null=True
+                    ),
+                ),
+                ("inversions", models.PositiveIntegerField(default=0)),
+                (
+                    "ride_time_seconds",
+                    models.PositiveIntegerField(blank=True, null=True),
+                ),
+                ("track_type", models.CharField(blank=True, max_length=255)),
+                (
+                    "track_material",
+                    models.CharField(
+                        blank=True,
+                        choices=[
+                            ("STEEL", "Steel"),
+                            ("WOOD", "Wood"),
+                            ("HYBRID", "Hybrid"),
+                        ],
+                        default="STEEL",
+                        max_length=20,
+                    ),
+                ),
+                (
+                    "roller_coaster_type",
+                    models.CharField(
+                        blank=True,
+                        choices=[
+                            ("SITDOWN", "Sit Down"),
+                            ("INVERTED", "Inverted"),
+                            ("FLYING", "Flying"),
+                            ("STANDUP", "Stand Up"),
+                            ("WING", "Wing"),
+                            ("DIVE", "Dive"),
+                            ("FAMILY", "Family"),
+                            ("WILD_MOUSE", "Wild Mouse"),
+                            ("SPINNING", "Spinning"),
+                            ("FOURTH_DIMENSION", "4th Dimension"),
+                            ("OTHER", "Other"),
+                        ],
+                        default="SITDOWN",
+                        max_length=20,
+                    ),
+                ),
+                (
+                    "max_drop_height_ft",
+                    models.DecimalField(
+                        blank=True, decimal_places=2, max_digits=6, null=True
+                    ),
+                ),
+                (
+                    "launch_type",
+                    models.CharField(
+                        choices=[
+                            ("CHAIN", "Chain Lift"),
+                            ("LSM", "LSM Launch"),
+                            ("HYDRAULIC", "Hydraulic Launch"),
+                            ("GRAVITY", "Gravity"),
+                            ("OTHER", "Other"),
+                        ],
+                        default="CHAIN",
+                        max_length=20,
+                    ),
+                ),
+                ("train_style", models.CharField(blank=True, max_length=255)),
+                ("trains_count", models.PositiveIntegerField(blank=True, null=True)),
+                ("cars_per_train", models.PositiveIntegerField(blank=True, null=True)),
+                ("seats_per_car", models.PositiveIntegerField(blank=True, null=True)),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="ride",
+            trigger=pgtrigger.compiler.Trigger(
+                name="insert_insert",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    func='INSERT INTO "rides_rideevent" ("average_rating", "capacity_per_hour", "category", "closing_date", "created_at", "description", "designer_id", "id", "manufacturer_id", "max_height_in", "min_height_in", "name", "opening_date", "park_area_id", "park_id", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "post_closing_status", "ride_duration_seconds", "ride_model_id", "slug", "status", "status_since", "updated_at") VALUES (NEW."average_rating", NEW."capacity_per_hour", NEW."category", NEW."closing_date", NEW."created_at", NEW."description", NEW."designer_id", NEW."id", NEW."manufacturer_id", NEW."max_height_in", NEW."min_height_in", NEW."name", NEW."opening_date", NEW."park_area_id", NEW."park_id", _pgh_attach_context(), NOW(), \'insert\', NEW."id", NEW."post_closing_status", NEW."ride_duration_seconds", NEW."ride_model_id", NEW."slug", NEW."status", NEW."status_since", NEW."updated_at"); RETURN NULL;',
+                    hash="870aa867ae6892f187dc0382e4a6833b5d1267c5",
+                    operation="INSERT",
+                    pgid="pgtrigger_insert_insert_52074",
+                    table="rides_ride",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="ride",
+            trigger=pgtrigger.compiler.Trigger(
+                name="update_update",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    condition="WHEN (OLD.* IS DISTINCT FROM NEW.*)",
+                    func='INSERT INTO "rides_rideevent" ("average_rating", "capacity_per_hour", "category", "closing_date", "created_at", "description", "designer_id", "id", "manufacturer_id", "max_height_in", "min_height_in", "name", "opening_date", "park_area_id", "park_id", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "post_closing_status", "ride_duration_seconds", "ride_model_id", "slug", "status", "status_since", "updated_at") VALUES (NEW."average_rating", NEW."capacity_per_hour", NEW."category", NEW."closing_date", NEW."created_at", NEW."description", NEW."designer_id", NEW."id", NEW."manufacturer_id", NEW."max_height_in", NEW."min_height_in", NEW."name", NEW."opening_date", NEW."park_area_id", NEW."park_id", _pgh_attach_context(), NOW(), \'update\', NEW."id", NEW."post_closing_status", NEW."ride_duration_seconds", NEW."ride_model_id", NEW."slug", NEW."status", NEW."status_since", NEW."updated_at"); RETURN NULL;',
+                    hash="8bafb42256ee98b4517ae4d39d0e774111794fea",
+                    operation="UPDATE",
+                    pgid="pgtrigger_update_update_4917a",
+                    table="rides_ride",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="ridemodel",
+            trigger=pgtrigger.compiler.Trigger(
+                name="insert_insert",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    func='INSERT INTO "rides_ridemodelevent" ("category", "created_at", "description", "id", "manufacturer_id", "name", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "updated_at") VALUES (NEW."category", NEW."created_at", NEW."description", NEW."id", NEW."manufacturer_id", NEW."name", _pgh_attach_context(), NOW(), \'insert\', NEW."id", NEW."updated_at"); RETURN NULL;',
+                    hash="e9e3c3ec4cb2400b363035534c580c94a3bb1d53",
+                    operation="INSERT",
+                    pgid="pgtrigger_insert_insert_0aaee",
+                    table="rides_ridemodel",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="ridemodel",
+            trigger=pgtrigger.compiler.Trigger(
+                name="update_update",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    condition="WHEN (OLD.* IS DISTINCT FROM NEW.*)",
+                    func='INSERT INTO "rides_ridemodelevent" ("category", "created_at", "description", "id", "manufacturer_id", "name", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "updated_at") VALUES (NEW."category", NEW."created_at", NEW."description", NEW."id", NEW."manufacturer_id", NEW."name", _pgh_attach_context(), NOW(), \'update\', NEW."id", NEW."updated_at"); RETURN NULL;',
+                    hash="4c8073b866beac402ace852e23974fcb01d24267",
+                    operation="UPDATE",
+                    pgid="pgtrigger_update_update_0ca1a",
+                    table="rides_ridemodel",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="rollercoasterstats",
+            trigger=pgtrigger.compiler.Trigger(
+                name="insert_insert",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    func='INSERT INTO "rides_rollercoasterstatsevent" ("cars_per_train", "height_ft", "id", "inversions", "launch_type", "length_ft", "max_drop_height_ft", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "ride_id", "ride_time_seconds", "roller_coaster_type", "seats_per_car", "speed_mph", "track_material", "track_type", "train_style", "trains_count") VALUES (NEW."cars_per_train", NEW."height_ft", NEW."id", NEW."inversions", NEW."launch_type", NEW."length_ft", NEW."max_drop_height_ft", _pgh_attach_context(), NOW(), \'insert\', NEW."id", NEW."ride_id", NEW."ride_time_seconds", NEW."roller_coaster_type", NEW."seats_per_car", NEW."speed_mph", NEW."track_material", NEW."track_type", NEW."train_style", NEW."trains_count"); RETURN NULL;',
+                    hash="529f2cf3bb62b57c85123143523475c1999099ec",
+                    operation="INSERT",
+                    pgid="pgtrigger_insert_insert_96f8b",
+                    table="rides_rollercoasterstats",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="rollercoasterstats",
+            trigger=pgtrigger.compiler.Trigger(
+                name="update_update",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    condition="WHEN (OLD.* IS DISTINCT FROM NEW.*)",
+                    func='INSERT INTO "rides_rollercoasterstatsevent" ("cars_per_train", "height_ft", "id", "inversions", "launch_type", "length_ft", "max_drop_height_ft", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "ride_id", "ride_time_seconds", "roller_coaster_type", "seats_per_car", "speed_mph", "track_material", "track_type", "train_style", "trains_count") VALUES (NEW."cars_per_train", NEW."height_ft", NEW."id", NEW."inversions", NEW."launch_type", NEW."length_ft", NEW."max_drop_height_ft", _pgh_attach_context(), NOW(), \'update\', NEW."id", NEW."ride_id", NEW."ride_time_seconds", NEW."roller_coaster_type", NEW."seats_per_car", NEW."speed_mph", NEW."track_material", NEW."track_type", NEW."train_style", NEW."trains_count"); RETURN NULL;',
+                    hash="3c9d3cb53ac46a2f4b2a27a63c5ed17a18de9827",
+                    operation="UPDATE",
+                    pgid="pgtrigger_update_update_24e8a",
+                    table="rides_rollercoasterstats",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        migrations.AddField(
+            model_name="rideevent",
+            name="designer",
+            field=models.ForeignKey(
+                blank=True,
+                db_constraint=False,
+                limit_choices_to={"roles__contains": ["DESIGNER"]},
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                related_query_name="+",
+                to="rides.company",
+            ),
+        ),
+        migrations.AddField(
+            model_name="rideevent",
+            name="manufacturer",
+            field=models.ForeignKey(
+                blank=True,
+                db_constraint=False,
+                limit_choices_to={"roles__contains": ["MANUFACTURER"]},
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                related_query_name="+",
+                to="rides.company",
+            ),
+        ),
+        migrations.AddField(
+            model_name="rideevent",
+            name="park",
+            field=models.ForeignKey(
+                db_constraint=False,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                related_query_name="+",
+                to="parks.park",
+            ),
+        ),
+        migrations.AddField(
+            model_name="rideevent",
+            name="park_area",
+            field=models.ForeignKey(
+                blank=True,
+                db_constraint=False,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                related_query_name="+",
+                to="parks.parkarea",
+            ),
+        ),
+        migrations.AddField(
+            model_name="rideevent",
+            name="pgh_context",
+            field=models.ForeignKey(
+                db_constraint=False,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                to="pghistory.context",
+            ),
+        ),
+        migrations.AddField(
+            model_name="rideevent",
+            name="pgh_obj",
+            field=models.ForeignKey(
+                db_constraint=False,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="events",
+                to="rides.ride",
+            ),
+        ),
+        migrations.AddField(
+            model_name="rideevent",
+            name="ride_model",
+            field=models.ForeignKey(
+                blank=True,
+                db_constraint=False,
+                help_text="The specific model/type of this ride",
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                related_query_name="+",
+                to="rides.ridemodel",
+            ),
+        ),
+        migrations.AddField(
+            model_name="ridemodelevent",
+            name="manufacturer",
+            field=models.ForeignKey(
+                blank=True,
+                db_constraint=False,
+                limit_choices_to={"roles__contains": ["MANUFACTURER"]},
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                related_query_name="+",
+                to="rides.company",
+            ),
+        ),
+        migrations.AddField(
+            model_name="ridemodelevent",
+            name="pgh_context",
+            field=models.ForeignKey(
+                db_constraint=False,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                to="pghistory.context",
+            ),
+        ),
+        migrations.AddField(
+            model_name="ridemodelevent",
+            name="pgh_obj",
+            field=models.ForeignKey(
+                db_constraint=False,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="events",
+                to="rides.ridemodel",
+            ),
+        ),
+        migrations.AddField(
+            model_name="rollercoasterstatsevent",
+            name="pgh_context",
+            field=models.ForeignKey(
+                db_constraint=False,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                to="pghistory.context",
+            ),
+        ),
+        migrations.AddField(
+            model_name="rollercoasterstatsevent",
+            name="pgh_obj",
+            field=models.ForeignKey(
+                db_constraint=False,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="events",
+                to="rides.rollercoasterstats",
+            ),
+        ),
+        migrations.AddField(
+            model_name="rollercoasterstatsevent",
+            name="ride",
+            field=models.ForeignKey(
+                db_constraint=False,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                related_query_name="+",
+                to="rides.ride",
+            ),
+        ),
+    ]

backend/apps/rides/migrations/0005_ridelocationevent_ridelocation_insert_insert_and_more.py

@@ -0,0 +1,128 @@
+# Generated by Django 5.2.5 on 2025-08-24 19:25
+
+import django.contrib.gis.db.models.fields
+import django.db.models.deletion
+import pgtrigger.compiler
+import pgtrigger.migrations
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("pghistory", "0007_auto_20250421_0444"),
+        ("rides", "0004_rideevent_ridemodelevent_rollercoasterstatsevent_and_more"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="RideLocationEvent",
+            fields=[
+                ("pgh_id", models.AutoField(primary_key=True, serialize=False)),
+                ("pgh_created_at", models.DateTimeField(auto_now_add=True)),
+                ("pgh_label", models.TextField(help_text="The event label.")),
+                ("id", models.BigIntegerField()),
+                (
+                    "point",
+                    django.contrib.gis.db.models.fields.PointField(
+                        blank=True,
+                        help_text="Geographic coordinates for ride location (longitude, latitude)",
+                        null=True,
+                        srid=4326,
+                    ),
+                ),
+                (
+                    "park_area",
+                    models.CharField(
+                        blank=True,
+                        help_text="Themed area or land within the park (e.g., 'Frontierland', 'Tomorrowland')",
+                        max_length=100,
+                    ),
+                ),
+                (
+                    "notes",
+                    models.TextField(blank=True, help_text="General location notes"),
+                ),
+                (
+                    "entrance_notes",
+                    models.TextField(
+                        blank=True,
+                        help_text="Directions to ride entrance, queue location, or navigation tips",
+                    ),
+                ),
+                (
+                    "accessibility_notes",
+                    models.TextField(
+                        blank=True,
+                        help_text="Information about accessible entrances, wheelchair access, etc.",
+                    ),
+                ),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="ridelocation",
+            trigger=pgtrigger.compiler.Trigger(
+                name="insert_insert",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    func='INSERT INTO "rides_ridelocationevent" ("accessibility_notes", "created_at", "entrance_notes", "id", "notes", "park_area", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "point", "ride_id", "updated_at") VALUES (NEW."accessibility_notes", NEW."created_at", NEW."entrance_notes", NEW."id", NEW."notes", NEW."park_area", _pgh_attach_context(), NOW(), \'insert\', NEW."id", NEW."point", NEW."ride_id", NEW."updated_at"); RETURN NULL;',
+                    hash="04c4c3aa17d4ef852d52b40d1dba4cd7372d5e29",
+                    operation="INSERT",
+                    pgid="pgtrigger_insert_insert_b66c2",
+                    table="rides_ridelocation",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="ridelocation",
+            trigger=pgtrigger.compiler.Trigger(
+                name="update_update",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    condition="WHEN (OLD.* IS DISTINCT FROM NEW.*)",
+                    func='INSERT INTO "rides_ridelocationevent" ("accessibility_notes", "created_at", "entrance_notes", "id", "notes", "park_area", "pgh_context_id", "pgh_created_at", "pgh_label", "pgh_obj_id", "point", "ride_id", "updated_at") VALUES (NEW."accessibility_notes", NEW."created_at", NEW."entrance_notes", NEW."id", NEW."notes", NEW."park_area", _pgh_attach_context(), NOW(), \'update\', NEW."id", NEW."point", NEW."ride_id", NEW."updated_at"); RETURN NULL;',
+                    hash="7073b4517d00b884b2f3fddf89caeefaa64058ad",
+                    operation="UPDATE",
+                    pgid="pgtrigger_update_update_402ba",
+                    table="rides_ridelocation",
+                    when="AFTER",
+                ),
+            ),
+        ),
+        migrations.AddField(
+            model_name="ridelocationevent",
+            name="pgh_context",
+            field=models.ForeignKey(
+                db_constraint=False,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                to="pghistory.context",
+            ),
+        ),
+        migrations.AddField(
+            model_name="ridelocationevent",
+            name="pgh_obj",
+            field=models.ForeignKey(
+                db_constraint=False,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="events",
+                to="rides.ridelocation",
+            ),
+        ),
+        migrations.AddField(
+            model_name="ridelocationevent",
+            name="ride",
+            field=models.ForeignKey(
+                db_constraint=False,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                related_query_name="+",
+                to="rides.ride",
+            ),
+        ),
+    ]

backend/apps/rides/models/location.py

@@ -1,8 +1,10 @@
 from django.contrib.gis.db import models as gis_models
 from django.db import models
 from django.contrib.gis.geos import Point
+import pghistory
 
 
+@pghistory.track()
 class RideLocation(models.Model):
     """
     Lightweight location tracking for individual rides within parks.

backend/apps/rides/models/rides.py

@@ -3,6 +3,7 @@ from django.utils.text import slugify
 from django.contrib.contenttypes.fields import GenericRelation
 from apps.core.models import TrackedModel
 from .company import Company
+import pghistory
 
 # Shared choices that will be used by multiple models
 CATEGORY_CHOICES = [
@@ -19,6 +20,7 @@ CATEGORY_CHOICES = [
 Categories = CATEGORY_CHOICES
 
 
+@pghistory.track()
 class RideModel(TrackedModel):
     """
     Represents a specific model/type of ride that can be manufactured by different
@@ -40,7 +42,7 @@ class RideModel(TrackedModel):
         max_length=2, choices=CATEGORY_CHOICES, default="", blank=True
     )
 
-    class Meta:
+    class Meta(TrackedModel.Meta):
         ordering = ["manufacturer", "name"]
         unique_together = ["manufacturer", "name"]
 
@@ -52,6 +54,7 @@ class RideModel(TrackedModel):
         )
 
 
+@pghistory.track()
 class Ride(TrackedModel):
     """Model for individual ride installations at parks"""
 
@@ -134,7 +137,7 @@ class Ride(TrackedModel):
     )
     photos = GenericRelation("media.Photo")
 
-    class Meta:
+    class Meta(TrackedModel.Meta):
         ordering = ["name"]
         unique_together = ["park", "slug"]
         constraints = [
@@ -203,6 +206,7 @@ class Ride(TrackedModel):
         super().save(*args, **kwargs)
 
 
+@pghistory.track()
 class RollerCoasterStats(models.Model):
     """Model for tracking roller coaster specific statistics"""