Refactor account adapters and admin classes; enhance type hinting for better clarity and maintainability, ensuring consistent typing across methods and improving overall code quality.

Refactor advanced search template to utilize Alpine.js for state management. Enhance search functionality with dynamic view modes and improved filter handling using HTMX.

.claude/settings.local.json

@@ -0,0 +1,12 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(python manage.py check:*)",
+      "Bash(uv run:*)",
+      "Bash(find:*)",
+      "Bash(python:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

.clinerules/cline_rules.md

@@ -1,91 +1,98 @@
-## Brief overview
+---
-Critical thinking rules for frontend design decisions. No excuses for poor design choices that ignore user vision.
+description: Core ThrillWiki development rules covering API organization, data models, development commands, code quality standards, and critical business rules
+author: ThrillWiki Development Team
+version: 1.0
+globs: ["**/*.py", "apps/**/*", "thrillwiki/**/*", "**/*.md"]
+tags: ["django", "api-design", "code-quality", "development-commands", "business-rules"]
+---
 
-## Rule compliance and design decisions
+# ThrillWiki Core Development Rules
-- Read ALL .clinerules files before making any code changes
-- Never assume exceptions to rules marked as "MANDATORY"
-- Take full responsibility for rule violations without excuses
-- Ask "What is the most optimal approach?" before ANY design decision
-- Justify every choice against user requirements - not your damn preferences
-- Stop making lazy design decisions without evaluation
-- Document your reasoning or get destroyed later
 
-## User vision, feedback, and assumptions
+## Objective
-- Figure out what the user actually wants, not your assumptions
+This rule defines the fundamental development standards, API organization patterns, code quality requirements, and critical business rules that MUST be followed for all ThrillWiki development work. It ensures consistency, maintainability, and adherence to project-specific constraints.
-- Ask questions when unclear - stop guessing like an idiot
-- Deliver their vision, not your garbage
-- User dissatisfaction means you screwed up understanding their vision
-- Stop defending your bad choices and listen
-- Fix the actual problem, not band-aid symptoms
-- Scrap everything and restart if needed
-- NEVER assume user preferences without confirmation
-- Stop guessing at requirements like a moron
-- Your instincts are wrong - question everything
-- Get explicit approval or fail
-
-## Implementation and backend integration
-- Think before you code, don't just hack away
-- Evaluate trade-offs or make terrible decisions
-- Question if your solution actually solves their damn problem
-- NEVER change color schemes without explicit user approval
-- ALWAYS use responsive design principles
-- ALWAYS follow best theme choice guidelines so users may choose light or dark mode
-- NEVER use quick fixes for complex problems
-- Support user goals, not your aesthetic ego
-- Follow established patterns unless they specifically want innovation
-- Make it work everywhere or you failed
-- Document decisions so you don't repeat mistakes
-- MANDATORY: Research ALL backend endpoints before making ANY frontend changes
-- Verify endpoint URLs, parameters, and response formats in actual Django codebase
-- Test complete frontend-backend integration before considering work complete
-- MANDATORY: Update ALL frontend documentation files after backend changes
-- Synchronize docs/frontend.md, docs/lib-api.ts, and docs/types-api.ts
-- Take immediate responsibility for integration failures without excuses
-- MUST create frontend integration prompt after every backend change affecting API
-- Include complete API endpoint information with all parameters and types
-- Document all mandatory API rules (trailing slashes, HTTP methods, authentication)
-- Never assume frontend developers have access to backend code
 
 ## API Organization and Data Models
+
+### Mandatory API Structure
 - **MANDATORY NESTING**: All API directory structures MUST match URL nesting patterns. No exceptions.
 - **NO TOP-LEVEL ENDPOINTS**: URLs must be nested under top-level domains
 - **MANDATORY TRAILING SLASHES**: All API endpoints MUST include trailing forward slashes unless ending with query parameters
-- Validate all endpoint URLs against the mandatory trailing slash rule
+- **Validation Required**: Validate all endpoint URLs against the mandatory trailing slash rule
-- **RIDE TYPES vs RIDE MODELS**: These are separate concepts for ALL ride categories:
+
-  - **Ride Types**: How rides operate (e.g., "inverted", "trackless", "spinning", "log flume", "monorail")
+### Ride System Architecture
-  - **Ride Models**: Specific manufacturer products (e.g., "B&M Dive Coaster", "Vekoma Boomerang")
+**RIDE TYPES vs RIDE MODELS**: These are separate concepts for ALL ride categories:
-  - Individual rides reference BOTH the model (what product) and type (how it operates)
+- **Ride Types**: How rides operate (e.g., "inverted", "trackless", "spinning", "log flume", "monorail")
-  - Ride types must be available for ALL ride categories, not just roller coasters
+- **Ride Models**: Specific manufacturer products (e.g., "B&M Dive Coaster", "Vekoma Boomerang")
+- **Implementation**: Individual rides reference BOTH the model (what product) and type (how it operates)
+- **Coverage**: Ride types MUST be available for ALL ride categories, not just roller coasters
 
 ## Development Commands and Code Quality
-- **Django Server**: Always use `uv run manage.py runserver_plus` instead of `python manage.py runserver`
+
-- **Django Migrations**: Always use `uv run manage.py makemigrations` and `uv run manage.py migrate` instead of `python manage.py`
+### Required Commands
-- **Package Management**: Always use `uv add <package>` instead of `pip install <package>`
+- **Django Server**: ALWAYS use `uv run manage.py runserver_plus` instead of `python manage.py runserver`
-- **Django Management**: Always use `uv run manage.py <command>` instead of `python manage.py <command>`
+- **Django Migrations**: ALWAYS use `uv run manage.py makemigrations` and `uv run manage.py migrate` instead of `python manage.py`
-- Break down methods with high cognitive complexity (>15) into smaller, focused helper methods
+- **Package Management**: ALWAYS use `uv add <package>` instead of `pip install <package>`
-- Extract logical operations into separate methods with descriptive names
+- **Django Management**: ALWAYS use `uv run manage.py <command>` instead of `python manage.py <command>`
-- Use single responsibility principle - each method should have one clear purpose
+
-- Prefer composition over deeply nested conditional logic
+### Code Quality Standards
-- Always handle None values explicitly to avoid type errors
+- **Cognitive Complexity**: Break down methods with high cognitive complexity (>15) into smaller, focused helper methods
-- Use proper type annotations, including union types (e.g., `Polygon | None`)
+- **Method Extraction**: Extract logical operations into separate methods with descriptive names
-- Structure API views with clear separation between parameter handling, business logic, and response building
+- **Single Responsibility**: Each method SHOULD have one clear purpose
-- When addressing SonarQube or linting warnings, focus on structural improvements rather than quick fixes
+- **Logic Structure**: Prefer composition over deeply nested conditional logic
+- **Null Handling**: ALWAYS handle None values explicitly to avoid type errors
+- **Type Annotations**: Use proper type annotations, including union types (e.g., `Polygon | None`)
+- **API Structure**: Structure API views with clear separation between parameter handling, business logic, and response building
+- **Quality Improvements**: When addressing SonarQube or linting warnings, focus on structural improvements rather than quick fixes
 
 ## ThrillWiki Project Rules
+
+### Domain Architecture
 - **Domain Structure**: Parks contain rides, rides have models, companies have multiple roles (manufacturer/operator/designer)
 - **Media Integration**: Use CloudflareImagesField for all photo uploads with variants and transformations
-- **Tracking**: All models use pghistory for change tracking and TrackedModel base class
+- **Change Tracking**: All models use pghistory for change tracking and TrackedModel base class
-- **Slugs**: Unique within scope (park slugs global, ride slugs within park, ride model slugs within manufacturer)
+- **Slug Management**: Unique within scope (park slugs global, ride slugs within park, ride model slugs within manufacturer)
+
+### Status and Role Management
 - **Status Management**: Rides have operational status (OPERATING, CLOSED_TEMP, SBNO, etc.) with date tracking
 - **Company Roles**: Companies can be MANUFACTURER, OPERATOR, DESIGNER, PROPERTY_OWNER with array field
 - **Location Data**: Use PostGIS for geographic data, separate location models for parks and rides
+
+### Technical Patterns
 - **API Patterns**: Use DRF with drf-spectacular, comprehensive serializers, nested endpoints, caching
 - **Photo Management**: Banner/card image references, photo types, attribution fields, primary photo logic
 - **Search Integration**: Text search, filtering, autocomplete endpoints, pagination
 - **Statistics**: Cached stats endpoints with automatic invalidation via Django signals
 
 ## CRITICAL RULES
-- **DOCUMENTATION**: After every change, it is MANDATORY to update docs/frontend.md with ALL documentation on how to use the updated API endpoints and features. It is MANDATORY to include any types in docs/types-api.ts for NextJS as the file would appear in `src/types/api.ts`. It is MANDATORY to include any new API endpoints in docs/lib-api.ts for NextJS as the file would appear in `/src/lib/api.ts`. Maintain accuracy and compliance in all technical documentation. Ensure API documentation matches backend URL routing expectations.
+
-- **NEVER MOCK DATA**: You are NEVER EVER to mock any data unless it's ONLY for API schema documentation purposes. All data must come from real database queries and actual model instances. Mock data is STRICTLY FORBIDDEN in all API responses, services, and business logic.
+### Data Integrity (ABSOLUTE)
-- **DOMAIN SEPARATION**: Company roles OPERATOR and PROPERTY_OWNER are EXCLUSIVELY for parks domain. They should NEVER be used in rides URLs or ride-related contexts. Only MANUFACTURER and DESIGNER roles are for rides domain. Parks: `/parks/{park_slug}/` and `/parks/`. Rides: `/parks/{park_slug}/rides/{ride_slug}/` and `/rides/`. Parks Companies: `/parks/operators/{operator_slug}/` and `/parks/owners/{owner_slug}/`. Rides Companies: `/rides/manufacturers/{manufacturer_slug}/` and `/rides/designers/{designer_slug}/`. NEVER mix these domains - this is a fundamental and DANGEROUS business rule violation.
+🚨 **NEVER MOCK DATA**: You are NEVER EVER to mock any data unless it's ONLY for API schema documentation purposes. All data MUST come from real database queries and actual model instances. Mock data is STRICTLY FORBIDDEN in all API responses, services, and business logic.
-- **PHOTO MANAGEMENT**: Use CloudflareImagesField for all photo uploads with variants and transformations. Clearly define and use photo types (e.g., banner, card) for all images. Include attribution fields for all photos. Implement logic to determine the primary photo for each model.
+
+### Domain Separation (CRITICAL BUSINESS RULE)
+🚨 **DOMAIN SEPARATION**: Company roles OPERATOR and PROPERTY_OWNER are EXCLUSIVELY for parks domain. They SHOULD NEVER be used in rides URLs or ride-related contexts. Only MANUFACTURER and DESIGNER roles are for rides domain.
+
+**Correct URL Patterns:**
+- **Parks**: `/parks/{park_slug}/` and `/parks/`
+- **Rides**: `/parks/{park_slug}/rides/{ride_slug}/` and `/rides/`
+- **Parks Companies**: `/parks/operators/{operator_slug}/` and `/parks/owners/{owner_slug}/`
+- **Rides Companies**: `/rides/manufacturers/{manufacturer_slug}/` and `/rides/designers/{designer_slug}/`
+
+⚠️ **WARNING**: NEVER mix these domains - this is a fundamental and DANGEROUS business rule violation.
+
+### Photo Management Standards
+🚨 **PHOTO MANAGEMENT**: 
+- Use CloudflareImagesField for all photo uploads with variants and transformations
+- Clearly define and use photo types (e.g., banner, card) for all images
+- Include attribution fields for all photos
+- Implement logic to determine the primary photo for each model
+
+## Verification Checklist
+
+Before implementing any changes, verify:
+- [ ] All API endpoints have trailing slashes
+- [ ] Domain separation is maintained (parks vs rides companies)
+- [ ] No mock data is used outside of schema documentation
+- [ ] Proper uv commands are used for all Django operations
+- [ ] Type annotations are complete and accurate
+- [ ] Methods follow single responsibility principle
+- [ ] CloudflareImagesField is used for all photo uploads

.clinerules/rich-choice-objects.md

@@ -0,0 +1,100 @@
+---
+description: Mandatory Rich Choice Objects system enforcement for ThrillWiki project replacing Django tuple-based choices with rich metadata-driven choice fields
+author: ThrillWiki Development Team
+version: 1.0
+globs: ["apps/**/choices.py", "apps/**/models.py", "apps/**/serializers.py", "apps/**/__init__.py"]
+tags: ["django", "choices", "rich-choice-objects", "data-modeling", "mandatory"]
+---
+
+# Rich Choice Objects System (MANDATORY)
+
+## Objective
+This rule enforces the mandatory use of the Rich Choice Objects system instead of Django's traditional tuple-based choices for ALL choice fields in the ThrillWiki project. It ensures consistent, metadata-rich choice handling with enhanced UI capabilities and maintainable code patterns.
+
+## Brief Overview
+Mandatory use of Rich Choice Objects system instead of Django tuple-based choices for all choice fields in ThrillWiki project.
+
+## Rich Choice Objects Enforcement
+
+### Absolute Requirements
+🚨 **NEVER use Django tuple-based choices** (e.g., `choices=[('VALUE', 'Label')]`) - ALWAYS use RichChoiceField
+
+### Implementation Standards
+- **Field Usage**: All choice fields MUST use `RichChoiceField(choice_group="group_name", domain="domain_name")` pattern
+- **Choice Definitions**: MUST be created in domain-specific `choices.py` files using RichChoice dataclass
+- **Rich Metadata**: All choices MUST include rich metadata (color, icon, description, css_class at minimum)
+- **Registration**: Choice groups MUST be registered with global registry using `register_choices()` function
+- **Auto-Registration**: Import choices in domain `__init__.py` to trigger auto-registration on Django startup
+
+### Required Patterns
+- **Categorization**: Use ChoiceCategory enum for proper categorization (STATUS, CLASSIFICATION, TECHNICAL, SECURITY)
+- **Business Logic**: Leverage rich metadata for UI styling, permissions, and business logic instead of hardcoded values
+- **Serialization**: Update serializers to use RichChoiceSerializer for choice fields
+
+### Migration Requirements
+- **NO Backwards Compatibility**: DO NOT maintain backwards compatibility with tuple-based choices - migrate fully to Rich Choice Objects
+- **Model Refactoring**: Ensure all existing models using tuple-based choices are refactored to use RichChoiceField
+- **Validation**: Validate choice groups are correctly loaded in registry during application startup
+
+### Domain Consistency
+- **Follow Established Patterns**: Follow established patterns from rides, parks, and accounts domains for consistency
+- **Domain-Specific Organization**: Maintain domain-specific choice organization in separate `choices.py` files
+
+## Implementation Checklist
+
+Before implementing choice fields, verify:
+- [ ] RichChoiceField is used instead of Django tuple choices
+- [ ] Choice group and domain are properly specified
+- [ ] Rich metadata includes color, icon, description, css_class
+- [ ] Choices are defined in domain-specific `choices.py` file
+- [ ] Choice group is registered with `register_choices()` function
+- [ ] Domain `__init__.py` imports choices for auto-registration
+- [ ] Appropriate ChoiceCategory enum is used
+- [ ] Serializers use RichChoiceSerializer for choice fields
+- [ ] No tuple-based choices remain in the codebase
+
+## Examples
+
+### ✅ CORRECT Implementation
+```python
+# In apps/rides/choices.py
+from core.choices import RichChoice, ChoiceCategory, register_choices
+
+RIDE_STATUS_CHOICES = [
+    RichChoice(
+        value="operating",
+        label="Operating",
+        color="#10b981",
+        icon="check-circle",
+        description="Ride is currently operating normally",
+        css_class="status-operating",
+        category=ChoiceCategory.STATUS
+    ),
+    # ... more choices
+]
+
+register_choices("ride_status", RIDE_STATUS_CHOICES, domain="rides")
+
+# In models.py
+status = RichChoiceField(choice_group="ride_status", domain="rides")
+```
+
+### ❌ FORBIDDEN Implementation
+```python
+# NEVER DO THIS - Tuple-based choices are forbidden
+STATUS_CHOICES = [
+    ('operating', 'Operating'),
+    ('closed', 'Closed'),
+]
+
+status = models.CharField(max_length=20, choices=STATUS_CHOICES)
+```
+
+## Verification Steps
+
+To ensure compliance:
+1. Search codebase for any remaining tuple-based choice patterns
+2. Verify all choice fields use RichChoiceField
+3. Confirm all choices have complete rich metadata
+4. Test choice group registration during application startup
+5. Validate serializers use RichChoiceSerializer where appropriate

.clinerules/thrillwiki-context.md

@@ -0,0 +1,161 @@
+---
+description: Comprehensive ThrillWiki Django project context including architecture, development patterns, business rules, and mandatory Context7 MCP integration workflow
+author: ThrillWiki Development Team
+version: 2.0
+globs: ["**/*.py", "**/*.html", "**/*.js", "**/*.css", "**/*.md"]
+tags: ["django", "architecture", "api-design", "business-rules", "context7-integration", "thrillwiki"]
+---
+
+# ThrillWiki Django Project Context
+
+## Objective
+This rule provides comprehensive context for the ThrillWiki project, defining core architecture patterns, business rules, development workflows, and mandatory integration requirements. It serves as the primary reference for maintaining consistency across all ThrillWiki development activities.
+
+## Project Overview
+ThrillWiki is a comprehensive theme park database platform with user-generated content, expert moderation, and rich media support. Built with Django REST Framework, it serves 120+ API endpoints for parks, rides, companies, and user management.
+
+## Core Architecture
+
+### Technology Stack
+- **Backend**: Django 5.0+ with DRF, PostgreSQL + PostGIS, Redis caching, Celery tasks
+- **Frontend**: HTMX + AlpineJS + Tailwind CSS + Django-Cotton 
+  - 🚨 **CRITICAL**: NO React/Vue/Angular allowed
+- **Media**: Cloudflare Images using Direct Upload with variants and transformations
+- **Tracking**: pghistory for all model changes, TrackedModel base class
+- **Choices**: Rich Choice Objects system (NEVER use Django tuple choices)
+
+### Domain Architecture
+- **Parks Domain**: `parks/`, companies (OPERATOR/PROPERTY_OWNER roles only)
+- **Rides Domain**: `rides/`, companies (MANUFACTURER/DESIGNER roles only)
+- **Core Apps**: `accounts/`, `media/`, `moderation/`, `core/`
+- 🚨 **CRITICAL BUSINESS RULE**: Never mix park/ride company roles - fundamental business rule violation
+
+## Development Patterns
+
+### Model Patterns
+- **Base Classes**: All models MUST inherit from TrackedModel
+- **Slug Handling**: Use SluggedModel for slugs with history tracking
+- **Location Data**: Use PostGIS for geographic data, separate location models
+- **Media Fields**: Use CloudflareImagesField for all image handling
+
+### API Design Patterns
+- **URL Structure**: Nested URLs (`/parks/{slug}/rides/{slug}/`)
+- **Trailing Slashes**: MANDATORY trailing slashes on all endpoints
+- **Authentication**: Token-based with role hierarchy (USER/MODERATOR/ADMIN/SUPERUSER)
+- **Filtering**: Comprehensive filtering - rides (25+ parameters), parks (15+ parameters)
+- **Responses**: Standard DRF pagination, rich error responses with details
+- **Caching**: Multi-level (Redis, CDN, browser) with signal-based invalidation
+
+### Choice System (MANDATORY)
+- **Implementation**: `RichChoiceField(choice_group="group_name", domain="domain_name")`
+- **Definition**: Domain-specific `choices.py` using RichChoice dataclass
+- **Registration**: `register_choices()` function in domain `__init__.py`
+- **Required Metadata**: color, icon, description, css_class (minimum)
+- 🚨 **FORBIDDEN**: NO tuple-based choices allowed anywhere in codebase
+
+## Development Commands
+
+### Package Management
+- **Python Packages**: `uv add <package>` (NOT `pip install`)
+- **Server**: `uv run manage.py runserver_plus` (NOT `python manage.py`)
+- **Migrations**: `uv run manage.py makemigrations/migrate`
+- **Management**: ALWAYS use `uv run manage.py <command>`
+
+## Business Rules
+
+### Company Role Separation
+- **Parks Domain**: Only OPERATOR and PROPERTY_OWNER roles
+- **Rides Domain**: Only MANUFACTURER and DESIGNER roles
+- 🚨 **CRITICAL**: Never allow cross-domain company roles
+
+### Data Integrity
+- **Model Changes**: All must be tracked via pghistory
+- **API Responses**: MUST use real database data (NEVER MOCK DATA)
+- **Geographic Data**: MUST use PostGIS for accuracy
+
+## Frontend Constraints
+
+### Architecture Requirements
+- **HTMX**: Dynamic updates and AJAX interactions
+- **AlpineJS**: Client-side state management
+- **Tailwind CSS**: Styling framework
+- **Progressive Enhancement**: Required approach
+
+### Performance Targets
+- **First Contentful Paint**: < 1.5s
+- **Time to Interactive**: < 2s
+- **Compliance**: Core Web Vitals compliance
+- **Browser Support**: Latest 2 versions of major browsers
+
+## Context7 MCP Integration (MANDATORY)
+
+### Requirement
+🚨 **CRITICAL**: ALWAYS use Context7 MCP for documentation lookups before making changes
+
+### Libraries Requiring Context7
+- **tailwindcss**: CSS utility classes, responsive design, component styling
+- **django**: Models, views, forms, URL patterns, Django-specific patterns
+- **django-cotton**: Component creation, template organization, Cotton-specific syntax
+- **htmx**: Dynamic updates, form handling, AJAX interactions
+- **alpinejs**: Client-side state management, reactive data, JavaScript interactions
+- **django-rest-framework**: API design, serializers, viewsets, DRF patterns
+- **postgresql**: Database queries, PostGIS functions, advanced SQL features
+- **postgis**: Geographic data handling and spatial queries
+- **redis**: Caching strategies, session management, performance optimization
+
+### Mandatory Workflow Steps
+1. **Before editing/creating code**: Query Context7 for relevant library documentation
+2. **During debugging**: Use Context7 to verify syntax, patterns, and best practices
+3. **When implementing new features**: Reference Context7 for current API and method signatures
+4. **For performance issues**: Consult Context7 for optimization techniques and patterns
+5. **For geographic data handling**: Use Context7 for PostGIS functions and best practices
+6. **For caching strategies**: Refer to Context7 for Redis patterns and best practices
+7. **For database queries**: Utilize Context7 for PostgreSQL best practices and advanced SQL features
+
+### Mandatory Scenarios
+- Creating new Django models or API endpoints
+- Implementing HTMX dynamic functionality
+- Writing AlpineJS reactive components
+- Designing responsive layouts with Tailwind CSS
+- Creating Django-Cotton components
+- Debugging CSS, JavaScript, or Django issues
+- Implementing caching or database optimizations
+- Handling geographic data with PostGIS
+- Utilizing Redis for session management
+- Implementing real-time features with WebSockets
+
+### Context7 Commands
+1. **Resolve Library**: Always call `Context7:resolve-library-id` first to get correct library ID
+2. **Get Documentation**: Then use `Context7:get-library-docs` with appropriate topic parameter
+
+### Example Topics by Library
+- **tailwindcss**: responsive design, flexbox, grid, animations
+- **django**: models, views, forms, admin, signals
+- **django-cotton**: components, templates, slots, props
+- **htmx**: hx-get, hx-post, hx-swap, hx-trigger, hx-target
+- **alpinejs**: x-data, x-show, x-if, x-for, x-model
+- **django-rest-framework**: serializers, viewsets, routers, permissions
+- **postgresql**: joins, indexes, transactions, window functions
+- **postgis**: geospatial queries, distance calculations, spatial indexes
+- **redis**: caching strategies, pub/sub, data structures
+
+## Code Quality Standards
+
+### Model Requirements
+- All models MUST inherit from TrackedModel
+- Use SluggedModel for entities with slugs and history tracking
+- Always use RichChoiceField instead of Django choices
+- Use CloudflareImagesField for all image handling
+- Use PostGIS fields and separate location models for geographic data
+
+### API Requirements
+- MUST include trailing slashes and follow nested pattern
+- All responses MUST use real database queries
+- Implement comprehensive filtering and pagination
+- Use signal-based cache invalidation
+
+### Development Workflow
+- Use uv for all Python package operations
+- Use runserver_plus for enhanced development server
+- Always use `uv run` for Django management commands
+- All functionality MUST work with progressive enhancement

.clinerules/thrillwiki-simple.md

@@ -0,0 +1,56 @@
+---
+description: Condensed ThrillWiki Django project context with architecture, patterns, and mandatory Context7 integration
+author: ThrillWiki Development Team
+version: 2.1
+globs: ["**/*.py", "**/*.html", "**/*.js", "**/*.css", "**/*.md"]
+tags: ["django", "architecture", "context7-integration", "thrillwiki"]
+---
+
+# ThrillWiki Django Project Context
+
+## Project Overview
+Theme park database platform with Django REST Framework serving 120+ API endpoints for parks, rides, companies, and users.
+
+## Core Architecture
+- **Backend**: Django 5.1+, DRF, PostgreSQL+PostGIS, Redis, Celery
+- **Frontend**: HTMX (V2+) + AlpineJS + Tailwind CSS (V4+) + Django-Cotton
+  - 🚨 **ABSOLUTELY NO Custom JS** - use HTMX + AlpineJS ONLY
+  - Clean, simple UX preferred
+- **Media**: Cloudflare Images with Direct Upload
+- **Tracking**: pghistory, TrackedModel base class
+- **Choices**: Rich Choice Objects (NEVER Django tuple choices)
+
+## Development Patterns
+- **Models**: TrackedModel inheritance, SluggedModel for slugs, PostGIS for location
+- **APIs**: Nested URLs (`/parks/{slug}/rides/{slug}/`), mandatory trailing slashes
+- **Commands**: `uv add <package>`, `uv run manage.py <command>` (NOT pip/python)
+- **Choices**: `RichChoiceField(choice_group="name", domain="domain")` MANDATORY
+
+## Business Rules
+🚨 **CRITICAL**: Company role separation - Parks (OPERATOR/PROPERTY_OWNER only), Rides (MANUFACTURER/DESIGNER only)
+
+## Context7 MCP Integration (MANDATORY)
+
+### Required Libraries
+tailwindcss, django, django-cotton, htmx, alpinejs, django-rest-framework, postgresql, postgis, redis
+
+### Workflow
+1. **ALWAYS** call `Context7:resolve-library-id` first
+2. Then `Context7:get-library-docs` with topic parameter
+3. Required for: new models/APIs, HTMX functionality, AlpineJS components, Tailwind layouts, Cotton components, debugging, optimizations
+
+### Example Topics
+- **tailwindcss**: responsive, flexbox, grid
+- **django**: models, views, forms
+- **htmx**: hx-get, hx-post, hx-swap, hx-target
+- **alpinejs**: x-data, x-show, x-if, x-for
+
+## Standards
+- All models inherit TrackedModel
+- Real database data only (NO MOCKING)
+- RichChoiceField over Django choices
+- Progressive enhancement required
+
+- We prefer to edit existing files instead of creating new ones.
+
+YOU ARE STRICTLY AND ABSOLUTELY FORBIDDEN FROM IGNORING, BYPASSING, OR AVOIDING THESE RULES IN ANY WAY WITH NO EXCEPTIONS!!!

.gitignore

@@ -120,3 +120,7 @@ frontend/.env
 
 # Extracted packages
 django-forwardemail/
+frontend/
+frontend
+.snapshots
+uv.lock

.replit

@@ -0,0 +1,73 @@
+modules = ["bash", "web", "nodejs-20", "python-3.13", "postgresql-16"]
+
+[nix]
+channel = "stable-25_05"
+packages = [
+  "freetype",
+  "gdal",
+  "geos",
+  "gitFull",
+  "lcms2",
+  "libimagequant",
+  "libjpeg",
+  "libtiff",
+  "libwebp",
+  "libxcrypt",
+  "openjpeg",
+  "playwright-driver",
+  "postgresql",
+  "proj",
+  "tcl",
+  "tk",
+  "uv",
+  "zlib",
+]
+
+[agent]
+expertMode = true
+
+[workflows]
+runButton = "Project"
+
+[[workflows.workflow]]
+name = "Project"
+mode = "parallel"
+author = "agent"
+
+[[workflows.workflow.tasks]]
+task = "workflow.run"
+args = "ThrillWiki Server"
+
+[[workflows.workflow]]
+name = "ThrillWiki Server"
+author = "agent"
+
+[[workflows.workflow.tasks]]
+task = "shell.exec"
+args = "/home/runner/workspace/.venv/bin/python manage.py tailwind runserver 0.0.0.0:5000"
+waitForPort = 5000
+
+[workflows.workflow.metadata]
+outputType = "webview"
+
+[[ports]]
+localPort = 5000
+externalPort = 80
+
+[[ports]]
+localPort = 41923
+externalPort = 3000
+
+[[ports]]
+localPort = 45245
+externalPort = 3001
+
+[deployment]
+deploymentTarget = "autoscale"
+run = [
+  "gunicorn",
+  "--bind=0.0.0.0:5000",
+  "--reuse-port",
+  "thrillwiki.wsgi:application",
+]
+build = ["uv", "pip", "install", "--system", "-r", "requirements.txt"]

.roo/mcp.json

@@ -0,0 +1,18 @@
+{
+  "mcpServers": {
+    "context7": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@upstash/context7-mcp"
+      ],
+      "env": {
+        "DEFAULT_MINIMUM_TOKENS": ""
+      },
+      "alwaysAllow": [
+        "resolve-library-id",
+        "get-library-docs"
+      ]
+    }
+  }
+}

CI_README.md

@@ -1,277 +0,0 @@
-# ThrillWiki CI/CD System
-
-This repository includes a **complete automated CI/CD system** that creates a Linux VM on Unraid and automatically deploys ThrillWiki when commits are pushed to GitHub.
-
-## 🚀 Complete Automation (Unraid)
-
-For **full automation** including VM creation on Unraid:
-
-```bash
-./scripts/unraid/setup-complete-automation.sh
-```
-
-This single command will:
-- ✅ Create and configure VM on Unraid
-- ✅ Install Ubuntu Server with all dependencies
-- ✅ Deploy ThrillWiki application
-- ✅ Set up automated CI/CD pipeline
-- ✅ Configure webhook listener
-- ✅ Test the entire system
-
-## Manual Setup (Any Linux VM)
-
-For manual setup on existing Linux VMs:
-
-```bash
-./scripts/setup-vm-ci.sh
-```
-
-## System Components
-
-### 📁 Files Created
-
-```
-scripts/
-├── ci-start.sh                      # Local development server startup
-├── webhook-listener.py              # GitHub webhook listener
-├── vm-deploy.sh                    # VM deployment script
-├── setup-vm-ci.sh                  # Manual VM setup script
-├── unraid/
-│   ├── vm-manager.py               # Unraid VM management
-│   └── setup-complete-automation.sh # Complete automation
-└── systemd/
-    ├── thrillwiki.service           # Django app service
-    └── thrillwiki-webhook.service   # Webhook listener service
-
-docs/
-├── VM_DEPLOYMENT_SETUP.md          # Manual setup documentation
-└── UNRAID_COMPLETE_AUTOMATION.md   # Complete automation guide
-```
-
-### 🔄 Deployment Flow
-
-**Complete Automation:**
-```
-GitHub Push → Webhook → Local Listener → SSH → Unraid VM → Deploy & Restart
-```
-
-**Manual Setup:**
-```
-GitHub Push → Webhook → Local Listener → SSH to VM → Deploy Script → Server Restart
-```
-
-## Features
-
-- **Complete VM Automation**: Automatically creates VMs on Unraid
-- **Automatic Deployment**: Deploys on push to main branch
-- **Health Checks**: Verifies deployment success
-- **Rollback Support**: Automatic rollback on deployment failure
-- **Service Management**: Systemd integration for reliable service management
-- **Database Setup**: Automated PostgreSQL configuration
-- **Logging**: Comprehensive logging for debugging
-- **Security**: SSH key authentication and webhook secrets
-- **One-Command Setup**: Full automation with single script
-
-## Usage
-
-### Complete Automation (Recommended)
-
-For Unraid users, run the complete automation:
-
-```bash
-./scripts/unraid/setup-complete-automation.sh
-```
-
-After setup, start the webhook listener:
-```bash
-./start-webhook.sh
-```
-
-### Local Development
-
-Start the local development server:
-
-```bash
-./scripts/ci-start.sh
-```
-
-### VM Management (Unraid)
-
-```bash
-# Check VM status
-python3 scripts/unraid/vm-manager.py status
-
-# Start/stop VM
-python3 scripts/unraid/vm-manager.py start
-python3 scripts/unraid/vm-manager.py stop
-
-# Get VM IP
-python3 scripts/unraid/vm-manager.py ip
-```
-
-### Service Management
-
-On the VM:
-
-```bash
-# Check status
-ssh thrillwiki-vm "./scripts/vm-deploy.sh status"
-
-# Restart service
-ssh thrillwiki-vm "./scripts/vm-deploy.sh restart"
-
-# View logs
-ssh thrillwiki-vm "journalctl -u thrillwiki -f"
-```
-
-### Manual VM Deployment
-
-Deploy to VM manually:
-
-```bash
-ssh thrillwiki-vm "cd thrillwiki && ./scripts/vm-deploy.sh"
-```
-
-## Configuration
-
-### Automated Configuration
-
-The complete automation script creates all necessary configuration files:
-
-- `***REMOVED***.unraid` - Unraid VM configuration
-- `***REMOVED***.webhook` - Webhook listener configuration
-- SSH keys and configuration
-- Service configurations
-
-### Manual Environment Variables
-
-For manual setup, create `***REMOVED***.webhook` file:
-
-```bash
-WEBHOOK_PORT=9000
-WEBHOOK_SECRET=your_secret_here
-VM_HOST=your_vm_ip
-VM_USER=ubuntu
-VM_KEY_PATH=/path/to/ssh/key
-VM_PROJECT_PATH=/home/ubuntu/thrillwiki
-REPO_URL=https://github.com/username/repo.git
-DEPLOY_BRANCH=main
-```
-
-### GitHub Webhook
-
-Configure in your GitHub repository:
-- **URL**: `http://YOUR_PUBLIC_IP:9000/webhook`
-- **Content Type**: `application/json`
-- **Secret**: Your webhook secret
-- **Events**: Push events
-
-## Requirements
-
-### For Complete Automation
-- **Local Machine**: Python 3.8+, SSH client
-- **Unraid Server**: 6.8+ with VM support
-- **Resources**: 4GB RAM, 50GB disk minimum
-- **Ubuntu ISO**: Ubuntu Server 22.04 in `/mnt/user/isos/`
-
-### For Manual Setup
-- **Local Machine**: Python 3.8+, SSH access to VM, Public IP
-- **Linux VM**: Ubuntu 20.04+, Python 3.8+, UV package manager, Git, SSH server
-
-## Troubleshooting
-
-### Complete Automation Issues
-
-1. **VM Creation Fails**
-   ```bash
-   # Check Unraid VM support
-   ssh unraid "virsh list --all"
-   
-   # Verify Ubuntu ISO exists
-   ssh unraid "ls -la /mnt/user/isos/ubuntu-*.iso"
-   ```
-
-2. **VM Won't Start**
-   ```bash
-   # Check VM status
-   python3 scripts/unraid/vm-manager.py status
-   
-   # Check Unraid logs
-   ssh unraid "tail -f /var/log/libvirt/qemu/thrillwiki-vm.log"
-   ```
-
-### General Issues
-
-1. **SSH Connection Failed**
-   ```bash
-   # Check SSH key permissions
-   chmod 600 ~/.ssh/thrillwiki_vm
-   
-   # Test connection
-   ssh thrillwiki-vm
-   ```
-
-2. **Webhook Not Receiving Events**
-   ```bash
-   # Check if port is open
-   sudo ufw allow 9000
-   
-   # Verify webhook URL in GitHub
-   curl -X GET http://localhost:9000/health
-   ```
-
-3. **Service Won't Start**
-   ```bash
-   # Check service logs
-   ssh thrillwiki-vm "journalctl -u thrillwiki --no-pager"
-   
-   # Manual start
-   ssh thrillwiki-vm "cd thrillwiki && ./scripts/ci-start.sh"
-   ```
-
-### Logs
-
-- **Setup logs**: `logs/unraid-automation.log`
-- **Local webhook**: `logs/webhook.log`
-- **VM deployment**: `logs/deploy.log` (on VM)
-- **Django server**: `logs/django.log` (on VM)
-- **System logs**: `journalctl -u thrillwiki -f` (on VM)
-
-## Security Notes
-
-- Automated SSH key generation and management
-- Dedicated keys for each connection (VM access, Unraid access)
-- No password authentication
-- Systemd security features enabled
-- Firewall configuration support
-- Secret management in environment files
-
-## Documentation
-
-- **Complete Automation**: [`docs/UNRAID_COMPLETE_AUTOMATION.md`](docs/UNRAID_COMPLETE_AUTOMATION.md)
-- **Manual Setup**: [`docs/VM_DEPLOYMENT_SETUP.md`](docs/VM_DEPLOYMENT_SETUP.md)
-
----
-
-## Quick Start Summary
-
-### For Unraid Users (Complete Automation)
-```bash
-# One command to set up everything
-./scripts/unraid/setup-complete-automation.sh
-
-# Start webhook listener
-./start-webhook.sh
-
-# Push commits to auto-deploy!
-```
-
-### For Existing VM Users
-```bash
-# Manual setup
-./scripts/setup-vm-ci.sh
-
-# Configure webhook and push to deploy
-```
-
-**The system will automatically deploy your Django application whenever you push commits to the main branch!** 🚀

README.md

@@ -1,200 +1,87 @@
-# ThrillWiki Django + Vue.js Monorepo
+# ThrillWiki Backend
 
-A comprehensive theme park and roller coaster information system built with a modern monorepo architecture combining Django REST API backend with Vue.js frontend.
+Django REST API backend for the ThrillWiki monorepo.
 
-## 🏗️ Architecture Overview
+## 🏗️ Architecture
 
-This project uses a monorepo structure that cleanly separates backend and frontend concerns while maintaining shared resources and documentation:
+This backend follows Django best practices with a modular app structure:
 
 ```
-thrillwiki-monorepo/
+backend/
-├── backend/                 # Django REST API (Port 8000)
+├── apps/                 # Django applications
-│   ├── apps/               # Modular Django applications
+│   ├── accounts/         # User management
-│   ├── config/             # Django settings and configuration
+│   ├── parks/           # Theme park data
-│   ├── templates/          # Django templates
+│   ├── rides/           # Ride information
-│   └── static/             # Static assets
+│   ├── moderation/      # Content moderation
-├── frontend/                # Vue.js SPA (Port 5174)
+│   ├── location/        # Geographic data
-│   ├── src/                # Vue.js source code
+│   ├── media/           # File management
-│   ├── public/             # Static assets
+│   ├── email_service/   # Email functionality
-│   └── dist/               # Build output
+│   └── core/            # Core utilities
-├── shared/                  # Shared resources and documentation
+├── config/              # Django configuration
-│   ├── docs/               # Comprehensive documentation
+│   ├── django/          # Settings files
-│   ├── scripts/            # Development and deployment scripts
+│   └── settings/        # Modular settings
-│   ├── config/             # Shared configuration
+├── templates/           # Django templates
-│   └── media/              # Shared media files
+├── static/              # Static files
-├── architecture/            # Architecture documentation
+└── tests/               # Test files
-└── profiles/                # Development profiles
 ```
 
+## 🛠️ Technology Stack
+
+- **Django 5.0+** - Web framework
+- **Django REST Framework** - API framework
+- **PostgreSQL** - Primary database
+- **Redis** - Caching and sessions
+- **UV** - Python package management
+- **Celery** - Background task processing
+
 ## 🚀 Quick Start
 
 ### Prerequisites
 
-- **Python 3.11+** with [uv](https://docs.astral.sh/uv/) for backend dependencies
+- Python 3.11+
-- **Node.js 18+** with [pnpm](https://pnpm.io/) for frontend dependencies
+- [uv](https://docs.astral.sh/uv/) package manager
-- **PostgreSQL 14+** (optional, defaults to SQLite for development)
+- PostgreSQL 14+
-- **Redis 6+** (optional, for caching and sessions)
+- Redis 6+
 
-### Development Setup
+### Setup
 
-1. **Clone the repository**
+1. **Install dependencies**
-   ```bash
-   git clone <repository-url>
-   cd thrillwiki-monorepo
-   ```
-
-2. **Install dependencies**
-   ```bash
-   # Install frontend dependencies
-   pnpm install
-
-   # Install backend dependencies
-   cd backend && uv sync && cd ..
-   ```
-
-3. **Environment configuration**
-   ```bash
-   # Copy environment files
-   cp .env.example .env
-   cp backend/.env.example backend/.env
-   cp frontend/.env.development frontend/.env.local
-
-   # Edit .env files with your settings
-   ```
-
-4. **Database setup**
    ```bash
    cd backend
+   uv sync
+   ```
+
+2. **Environment configuration**
+   ```bash
+   cp .env.example .env
+   # Edit .env with your settings
+   ```
+
+3. **Database setup**
+   ```bash
    uv run manage.py migrate
    uv run manage.py createsuperuser
-   cd ..
    ```
 
-5. **Start development servers**
+4. **Start development server**
    ```bash
-   # Start both servers concurrently
+   uv run manage.py runserver
-   pnpm run dev
-
-   # Or start individually
-   pnpm run dev:frontend    # Vue.js on :5174
-   pnpm run dev:backend     # Django on :8000
    ```
 
-## 📁 Project Structure Details
-
-### Backend (`/backend`)
-- **Django 5.0+** with REST Framework for API development
-- **Modular app architecture** with separate apps for parks, rides, accounts, etc.
-- **UV package management** for fast, reliable Python dependency management
-- **PostgreSQL/SQLite** database with comprehensive entity relationships
-- **Redis** for caching, sessions, and background tasks
-- **Comprehensive API** with frontend serializers for camelCase conversion
-
-### Frontend (`/frontend`)
-- **Vue 3** with Composition API and `<script setup>` syntax
-- **TypeScript** for type safety and better developer experience
-- **Vite** for lightning-fast development and optimized production builds
-- **Tailwind CSS** with custom design system and dark mode support
-- **Pinia** for state management with modular stores
-- **Vue Router** for client-side routing
-- **Comprehensive UI component library** with shadcn-vue components
-
-### Shared Resources (`/shared`)
-- **Documentation** - Comprehensive guides and API documentation
-- **Development scripts** - Automated setup, build, and deployment scripts
-- **Configuration** - Shared Docker, CI/CD, and infrastructure configs
-- **Media management** - Centralized media file handling and optimization
-
-## 🛠️ Development Workflow
-
-### Available Scripts
-
-```bash
-# Development
-pnpm run dev              # Start both servers concurrently
-pnpm run dev:frontend     # Frontend only (:5174)
-pnpm run dev:backend      # Backend only (:8000)
-
-# Building
-pnpm run build            # Build frontend for production
-pnpm run build:staging    # Build for staging environment
-pnpm run build:production # Build for production environment
-
-# Testing
-pnpm run test             # Run all tests
-pnpm run test:frontend    # Frontend unit and E2E tests
-pnpm run test:backend     # Backend unit and integration tests
-
-# Code Quality
-pnpm run lint             # Lint all code
-pnpm run type-check       # TypeScript type checking
-
-# Setup and Maintenance
-pnpm run install:all      # Install all dependencies
-./shared/scripts/dev/setup-dev.sh    # Full development setup
-./shared/scripts/dev/start-all.sh    # Start all services
-```
-
-### Backend Development
-
-```bash
-cd backend
-
-# Django management commands
-uv run manage.py migrate
-uv run manage.py makemigrations
-uv run manage.py createsuperuser
-uv run manage.py collectstatic
-
-# Testing and quality
-uv run manage.py test
-uv run black .           # Format code
-uv run flake8 .          # Lint code
-uv run isort .           # Sort imports
-```
-
-### Frontend Development
-
-```bash
-cd frontend
-
-# Vue.js development
-pnpm run dev            # Start dev server
-pnpm run build          # Production build
-pnpm run preview        # Preview production build
-pnpm run test:unit      # Vitest unit tests
-pnpm run test:e2e       # Playwright E2E tests
-pnpm run lint           # ESLint
-pnpm run type-check     # TypeScript checking
-```
-
 ## 🔧 Configuration
 
 ### Environment Variables
 
-#### Root `.env`
+Required environment variables:
+
 ```bash
 # Database
 DATABASE_URL=postgresql://user:pass@localhost/thrillwiki
-REDIS_URL=redis://localhost:6379
 
-# Security
+# Django
 SECRET_KEY=your-secret-key
 DEBUG=True
-
-# API Configuration
-API_BASE_URL=http://localhost:8000/api
-```
-
-#### Backend `.env`
-```bash
-# Django Settings
 DJANGO_SETTINGS_MODULE=config.django.local
-DEBUG=True
-ALLOWED_HOSTS=localhost,127.0.0.1
-
-# Database
-DATABASE_URL=postgresql://user:pass@localhost/thrillwiki
 
 # Redis
 REDIS_URL=redis://localhost:6379
@@ -203,142 +90,140 @@ REDIS_URL=redis://localhost:6379
 EMAIL_HOST=smtp.gmail.com
 EMAIL_PORT=587
 EMAIL_USE_TLS=True
+EMAIL_HOST_USER=your-email@gmail.com
+EMAIL_HOST_PASSWORD=your-app-password
 ```
 
-#### Frontend `.env.local`
+### Settings Structure
+
+- `config/django/base.py` - Base settings
+- `config/django/local.py` - Development settings
+- `config/django/production.py` - Production settings
+- `config/django/test.py` - Test settings
+
+## 📁 Apps Overview
+
+### Core Apps
+
+- **accounts** - User authentication and profile management
+- **parks** - Theme park models and operations
+- **rides** - Ride information and relationships
+- **core** - Shared utilities and base classes
+
+### Support Apps
+
+- **moderation** - Content moderation workflows
+- **location** - Geographic data and services
+- **media** - File upload and management
+- **email_service** - Email sending and templates
+
+## 🔌 API Endpoints
+
+Base URL: `http://localhost:8000/api/`
+
+### Authentication
+- `POST /auth/login/` - User login
+- `POST /auth/logout/` - User logout
+- `POST /auth/register/` - User registration
+
+### Parks
+- `GET /parks/` - List parks
+- `GET /parks/{id}/` - Park details
+- `POST /parks/` - Create park (admin)
+
+### Rides
+- `GET /rides/` - List rides
+- `GET /rides/{id}/` - Ride details
+- `GET /parks/{park_id}/rides/` - Rides by park
+
+## 🧪 Testing
+
 ```bash
-# API Configuration
+# Run all tests
-VITE_API_BASE_URL=http://localhost:8000/api
+uv run manage.py test
 
-# Development
+# Run specific app tests
-VITE_APP_TITLE=ThrillWiki (Development)
+uv run manage.py test apps.parks
 
-# Feature Flags
+# Run with coverage
-VITE_ENABLE_DEBUG=true
+uv run coverage run manage.py test
+uv run coverage report
 ```
 
-## 📊 Key Features
+## 🔧 Management Commands
 
-### Backend Features
+Custom management commands:
-- **Comprehensive Park Database** - Detailed information about theme parks worldwide
-- **Extensive Ride Database** - Complete roller coaster and ride information
-- **User Management** - Authentication, profiles, and permissions
-- **Content Moderation** - Review and approval workflows
-- **API Documentation** - Auto-generated OpenAPI/Swagger docs
-- **Background Tasks** - Celery integration for long-running processes
-- **Caching Strategy** - Redis-based caching for performance
-- **Search Functionality** - Full-text search across all content
 
-### Frontend Features
+```bash
-- **Responsive Design** - Mobile-first approach with Tailwind CSS
+# Import park data
-- **Dark Mode Support** - Complete dark/light theme system
+uv run manage.py import_parks data/parks.json
-- **Real-time Search** - Instant search with debouncing and highlighting
-- **Interactive Maps** - Park and ride location visualization
-- **Photo Galleries** - High-quality image management
-- **User Dashboard** - Personalized content and contributions
-- **Progressive Web App** - PWA capabilities for mobile experience
-- **Accessibility** - WCAG 2.1 AA compliance
 
-## 📖 Documentation
+# Generate test data
+uv run manage.py generate_test_data
 
-### Core Documentation
+# Clean up expired sessions
-- **[Backend Documentation](./backend/README.md)** - Django setup and API details
+uv run manage.py clearsessions
-- **[Frontend Documentation](./frontend/README.md)** - Vue.js setup and development
+```
-- **[API Documentation](./shared/docs/api/README.md)** - Complete API reference
-- **[Development Workflow](./shared/docs/development/workflow.md)** - Daily development processes
 
-### Architecture & Deployment
+## 📊 Database
-- **[Architecture Overview](./architecture/)** - System design and decisions
-- **[Deployment Guide](./shared/docs/deployment/)** - Production deployment instructions
-- **[Development Scripts](./shared/scripts/)** - Automation and tooling
 
-### Additional Resources
+### Entity Relationships
-- **[Contributing Guide](./CONTRIBUTING.md)** - How to contribute to the project
+
-- **[Code of Conduct](./CODE_OF_CONDUCT.md)** - Community guidelines
+- **Parks** have Operators (required) and PropertyOwners (optional)
-- **[Security Policy](./SECURITY.md)** - Security reporting and policies
+- **Rides** belong to Parks and may have Manufacturers/Designers
+- **Users** can create submissions and moderate content
+
+### Migrations
+
+```bash
+# Create migrations
+uv run manage.py makemigrations
+
+# Apply migrations
+uv run manage.py migrate
+
+# Show migration status
+uv run manage.py showmigrations
+```
+
+## 🔐 Security
+
+- CORS configured for frontend integration
+- CSRF protection enabled
+- JWT token authentication
+- Rate limiting on API endpoints
+- Input validation and sanitization
+
+## 📈 Performance
+
+- Database query optimization
+- Redis caching for frequent queries
+- Background task processing with Celery
+- Database connection pooling
 
 ## 🚀 Deployment
 
-### Development Environment
+See the [Deployment Guide](../shared/docs/deployment/) for production setup.
-```bash
-# Quick start with all services
-./shared/scripts/dev/start-all.sh
 
-# Full development setup
+## 🐛 Debugging
-./shared/scripts/dev/setup-dev.sh
-```
 
-### Production Deployment
+### Development Tools
-```bash
-# Build all components
-./shared/scripts/build/build-all.sh
 
-# Deploy to production
+- Django Debug Toolbar
-./shared/scripts/deploy/deploy.sh
+- Django Extensions
-```
+- Silk profiler for performance analysis
 
-See [Deployment Guide](./shared/docs/deployment/) for detailed production setup instructions.
+### Logging
 
-## 🧪 Testing Strategy
+Logs are written to:
-
+- Console (development)
-### Backend Testing
+- Files in `logs/` directory (production)
-- **Unit Tests** - Individual function and method testing
+- External logging service (production)
-- **Integration Tests** - API endpoint and database interaction testing
-- **E2E Tests** - Full user journey testing with Selenium
-
-### Frontend Testing
-- **Unit Tests** - Component and utility function testing with Vitest
-- **Integration Tests** - Component interaction testing
-- **E2E Tests** - User journey testing with Playwright
-
-### Code Quality
-- **Linting** - ESLint for JavaScript/TypeScript, Flake8 for Python
-- **Type Checking** - TypeScript for frontend, mypy for Python
-- **Code Formatting** - Prettier for frontend, Black for Python
 
 ## 🤝 Contributing
 
-We welcome contributions! Please see our [Contributing Guide](./CONTRIBUTING.md) for details on:
+1. Follow Django coding standards
-
+2. Write tests for new features
-1. **Development Setup** - Getting your development environment ready
+3. Update documentation
-2. **Code Standards** - Coding conventions and best practices
+4. Run linting: `uv run flake8 .`
-3. **Pull Request Process** - How to submit your changes
+5. Format code: `uv run black .`
-4. **Issue Reporting** - How to report bugs and request features
-
-### Quick Contribution Start
-```bash
-# Fork and clone the repository
-git clone https://github.com/your-username/thrillwiki-monorepo.git
-cd thrillwiki-monorepo
-
-# Set up development environment
-./shared/scripts/dev/setup-dev.sh
-
-# Create a feature branch
-git checkout -b feature/your-feature-name
-
-# Make your changes and test
-pnpm run test
-
-# Submit a pull request
-```
-
-## 📄 License
-
-This project is licensed under the MIT License - see the [LICENSE](./LICENSE) file for details.
-
-## 🙏 Acknowledgments
-
-- **Theme Park Community** - For providing data and inspiration
-- **Open Source Contributors** - For the amazing tools and libraries
-- **Vue.js and Django Communities** - For excellent documentation and support
-
-## 📞 Support
-
-- **Issues** - [GitHub Issues](https://github.com/your-repo/thrillwiki-monorepo/issues)
-- **Discussions** - [GitHub Discussions](https://github.com/your-repo/thrillwiki-monorepo/discussions)
-- **Documentation** - [Project Wiki](https://github.com/your-repo/thrillwiki-monorepo/wiki)
-
----
-
-**Built with ❤️ for the theme park and roller coaster community**

README_HYBRID_ENDPOINTS.md

@@ -1,180 +0,0 @@
-# ThrillWiki Hybrid Filtering Endpoints Test Suite
-
-This repository contains a comprehensive test script for the newly synchronized Parks and Rides hybrid filtering endpoints.
-
-## Quick Start
-
-1. **Start the Django server:**
-   ```bash
-   cd backend && uv run manage.py runserver 8000
-   ```
-
-2. **Run the test script:**
-   ```bash
-   ./test_hybrid_endpoints.sh
-   ```
-
-   Or with a custom base URL:
-   ```bash
-   ./test_hybrid_endpoints.sh http://localhost:8000
-   ```
-
-## What Gets Tested
-
-### Parks Hybrid Filtering (`/api/v1/parks/hybrid/`)
-- ✅ Basic hybrid filtering (automatic strategy selection)
-- ✅ Search functionality (`?search=disney`)
-- ✅ Status filtering (`?status=OPERATING,CLOSED_TEMP`)
-- ✅ Geographic filtering (`?country=United%20States&state=Florida,California`)
-- ✅ Numeric range filtering (`?opening_year_min=1990&rating_min=4.0`)
-- ✅ Park statistics filtering (`?size_min=100&ride_count_min=10`)
-- ✅ Operator filtering (`?operator=disney,universal`)
-- ✅ Progressive loading (`?offset=50`)
-- ✅ Filter metadata (`/filter-metadata/`)
-- ✅ Scoped metadata (`/filter-metadata/?scoped=true&country=United%20States`)
-
-### Rides Hybrid Filtering (`/api/v1/rides/hybrid/`)
-- ✅ Basic hybrid filtering (automatic strategy selection)
-- ✅ Search functionality (`?search=coaster`)
-- ✅ Category filtering (`?category=RC,DR`)
-- ✅ Status and park filtering (`?status=OPERATING&park_slug=cedar-point`)
-- ✅ Manufacturer/designer filtering (`?manufacturer=bolliger-mabillard`)
-- ✅ Roller coaster specific filtering (`?roller_coaster_type=INVERTED&has_inversions=true`)
-- ✅ Performance filtering (`?height_ft_min=200&speed_mph_min=70`)
-- ✅ Quality metrics (`?rating_min=4.5&capacity_min=1000`)
-- ✅ Accessibility filtering (`?height_requirement_min=48&height_requirement_max=54`)
-- ✅ Progressive loading (`?offset=25&category=RC`)
-- ✅ Filter metadata (`/filter-metadata/`)
-- ✅ Scoped metadata (`/filter-metadata/?scoped=true&category=RC`)
-
-### Advanced Testing
-- ✅ Complex combination queries
-- ✅ Edge cases (empty results, invalid parameters)
-- ✅ Performance timing comparisons
-- ✅ Error handling validation
-
-## Key Features Demonstrated
-
-### 🔄 Automatic Strategy Selection
-- **≤200 records**: Client-side filtering (loads all data for frontend filtering)
-- **>200 records**: Server-side filtering (database filtering with pagination)
-
-### 📊 Progressive Loading
-- Initial load: 50 records
-- Progressive batches: 25 records
-- Seamless pagination for large datasets
-
-### 🔍 Comprehensive Filtering
-- **Parks**: 17+ filter parameters including geographic, temporal, and statistical filters
-- **Rides**: 17+ filter parameters including roller coaster specs, performance metrics, and accessibility
-
-### 📋 Dynamic Filter Metadata
-- Real-time filter options based on current data
-- Scoped metadata for contextual filtering
-- Ranges and categorical options automatically generated
-
-### ⚡ Performance Optimized
-- 5-minute intelligent caching
-- Strategic database indexing
-- Optimized queries with prefetch_related
-
-## Response Format
-
-Both endpoints return consistent response structures:
-
-```json
-{
-  "parks": [...],           // or "rides": [...]
-  "total_count": 123,
-  "strategy": "client_side", // or "server_side"
-  "has_more": false,
-  "next_offset": null,
-  "filter_metadata": {
-    "categorical": {
-      "countries": ["United States", "Canada", ...],
-      "categories": ["RC", "DR", "FR", ...],
-      // ... more options
-    },
-    "ranges": {
-      "opening_year": {"min": 1800, "max": 2025},
-      "rating": {"min": 1.0, "max": 10.0},
-      // ... more ranges
-    }
-  }
-}
-```
-
-## Dependencies
-
-- **curl**: Required for making HTTP requests
-- **jq**: Optional but recommended for pretty JSON formatting
-
-## Example Usage
-
-### Basic Parks Query
-```bash
-curl "http://localhost:8000/api/v1/parks/hybrid/"
-```
-
-### Search for Disney Parks
-```bash
-curl "http://localhost:8000/api/v1/parks/hybrid/?search=disney"
-```
-
-### Filter Roller Coasters with Inversions
-```bash
-curl "http://localhost:8000/api/v1/rides/hybrid/?category=RC&has_inversions=true&height_ft_min=100"
-```
-
-### Get Filter Metadata
-```bash
-curl "http://localhost:8000/api/v1/parks/hybrid/filter-metadata/"
-```
-
-## Integration Guide
-
-### Frontend Integration
-1. Use filter metadata to build dynamic filter interfaces
-2. Implement progressive loading for better UX
-3. Handle both client-side and server-side strategies
-4. Cache filter metadata to reduce API calls
-
-### Performance Considerations
-- Monitor response times and adjust thresholds as needed
-- Use progressive loading for datasets >200 records
-- Implement proper error handling for edge cases
-- Consider implementing request debouncing for search
-
-## Troubleshooting
-
-### Server Not Running
-```
-❌ Server not available at http://localhost:8000
-💡 Make sure to start the Django server first:
-   cd backend && uv run manage.py runserver 8000
-```
-
-### Missing jq
-```
-⚠️  jq not found - JSON responses will not be pretty-printed
-```
-Install jq for better output formatting:
-```bash
-# macOS
-brew install jq
-
-# Ubuntu/Debian
-sudo apt-get install jq
-```
-
-## Next Steps
-
-1. **Integrate into Frontend**: Use these endpoints in your React/Next.js application
-2. **Build Filter UI**: Create dynamic filter interfaces using the metadata
-3. **Implement Progressive Loading**: Handle large datasets efficiently
-4. **Monitor Performance**: Track response times and optimize as needed
-5. **Add Caching**: Implement client-side caching for better UX
-
----
-
-🎢 **Happy filtering!** These endpoints provide a powerful, scalable foundation for building advanced search and filtering experiences in your theme park application.

TAILWIND_V4_MIGRATION.md

@@ -1,326 +0,0 @@
-# Tailwind CSS v3 to v4 Migration Documentation
-
-## Overview
-
-This document details the complete migration process from Tailwind CSS v3 to v4 for the Django ThrillWiki project. The migration was performed on August 15, 2025, and includes all changes, configurations, and verification steps.
-
-## Migration Summary
-
-- **From**: Tailwind CSS v3.x
-- **To**: Tailwind CSS v4.1.12
-- **Project**: Django ThrillWiki (Django + Tailwind CSS integration)
-- **Status**: ✅ Complete and Verified
-- **Breaking Changes**: None (all styling preserved)
-
-## Key Changes in Tailwind CSS v4
-
-### 1. CSS Import Syntax
-- **v3**: Used `@tailwind` directives
-- **v4**: Uses single `@import "tailwindcss"` statement
-
-### 2. Theme Configuration
-- **v3**: Configuration in `tailwind.config.js`
-- **v4**: CSS-first approach with `@theme` blocks
-
-### 3. Deprecated Utilities
-Multiple utility classes were renamed or deprecated in v4.
-
-## Migration Steps Performed
-
-### Step 1: Update Main CSS File
-
-**File**: `static/css/src/input.css`
-
-**Before (v3)**:
-```css
-@tailwind base;
-@tailwind components;
-@tailwind utilities;
-
-/* Custom styles... */
-```
-
-**After (v4)**:
-```css
-@import "tailwindcss";
-
-@theme {
-  --color-primary: #4f46e5;
-  --color-secondary: #e11d48;
-  --color-accent: #8b5cf6;
-  --font-family-sans: Poppins, sans-serif;
-}
-
-/* Custom styles... */
-```
-
-### Step 2: Theme Variable Migration
-
-Migrated custom colors and fonts from `tailwind.config.js` to CSS variables in `@theme` block:
-
-| Variable | Value | Description |
-|----------|-------|-------------|
-| `--color-primary` | `#4f46e5` | Indigo-600 (primary brand color) |
-| `--color-secondary` | `#e11d48` | Rose-600 (secondary brand color) |
-| `--color-accent` | `#8b5cf6` | Violet-500 (accent color) |
-| `--font-family-sans` | `Poppins, sans-serif` | Primary font family |
-
-### Step 3: Deprecated Utility Updates
-
-#### Outline Utilities
-- **Changed**: `outline-none` → `outline-hidden`
-- **Files affected**: All template files, component CSS
-
-#### Ring Utilities  
-- **Changed**: `ring` → `ring-3`
-- **Reason**: Default ring width now requires explicit specification
-
-#### Shadow Utilities
-- **Changed**: 
-  - `shadow-sm` → `shadow-xs`
-  - `shadow` → `shadow-sm`
-- **Files affected**: Button components, card components
-
-#### Opacity Utilities
-- **Changed**: `bg-opacity-*` format → `color/opacity` format
-- **Example**: `bg-blue-500 bg-opacity-50` → `bg-blue-500/50`
-
-#### Flex Utilities
-- **Changed**: `flex-shrink-0` → `shrink-0`
-
-#### Important Modifier
-- **Changed**: `!important` → `!` (shorter syntax)
-- **Example**: `!outline-none` → `!outline-hidden`
-
-### Step 4: Template File Updates
-
-Updated the following template files with new utility classes:
-
-#### Core Templates
-- `templates/base.html`
-- `templates/components/navbar.html`
-- `templates/components/footer.html`
-
-#### Page Templates
-- `templates/parks/park_list.html`
-- `templates/parks/park_detail.html`
-- `templates/rides/ride_list.html`
-- `templates/rides/ride_detail.html`
-- `templates/companies/company_list.html`
-- `templates/companies/company_detail.html`
-
-#### Form Templates
-- `templates/parks/park_form.html`
-- `templates/rides/ride_form.html`
-- `templates/companies/company_form.html`
-
-#### Component Templates
-- `templates/components/search_results.html`
-- `templates/components/pagination.html`
-
-### Step 5: Component CSS Updates
-
-Updated custom component classes in `static/css/src/input.css`:
-
-**Button Components**:
-```css
-.btn-primary {
-    @apply inline-flex items-center px-6 py-2.5 border border-transparent rounded-full shadow-md text-sm font-medium text-white bg-gradient-to-r from-primary to-secondary hover:from-primary/90 hover:to-secondary/90 focus:outline-hidden focus:ring-3 focus:ring-offset-2 focus:ring-primary/50 transform hover:scale-105 transition-all;
-}
-
-.btn-secondary {
-    @apply inline-flex items-center px-6 py-2.5 border border-gray-200 dark:border-gray-700 rounded-full shadow-md text-sm font-medium text-gray-700 dark:text-gray-200 bg-white dark:bg-gray-800 hover:bg-gray-50 dark:hover:bg-gray-700 focus:outline-hidden focus:ring-3 focus:ring-offset-2 focus:ring-primary/50 transform hover:scale-105 transition-all;
-}
-```
-
-## Configuration Files
-
-### Tailwind Config (Preserved for Reference)
-
-**File**: `tailwind.config.js`
-
-The original v3 configuration was preserved for reference but is no longer the primary configuration method:
-
-```javascript
-module.exports = {
-  content: [
-    './templates/**/*.html',
-    './static/js/**/*.js',
-    './*/templates/**/*.html',
-  ],
-  darkMode: 'class',
-  theme: {
-    extend: {
-      colors: {
-        primary: '#4f46e5',
-        secondary: '#e11d48', 
-        accent: '#8b5cf6',
-      },
-      fontFamily: {
-        sans: ['Poppins', 'sans-serif'],
-      },
-    },
-  },
-  plugins: [
-    require('@tailwindcss/forms'),
-    require('@tailwindcss/typography'),
-  ],
-}
-```
-
-### Package.json Updates
-
-No changes required to `package.json` as the Django-Tailwind package handles version management.
-
-## Verification Steps
-
-### 1. Build Process Verification
-```bash
-# Clean and rebuild CSS
-lsof -ti :8000 | xargs kill -9
-find . -type d -name "__pycache__" -exec rm -r {} +
-uv run manage.py tailwind runserver
-```
-
-**Result**: ✅ Build successful, no errors
-
-### 2. CSS Compilation Check
-```bash
-# Check compiled CSS size and content
-ls -la static/css/tailwind.css
-head -50 static/css/tailwind.css | grep -E "(primary|secondary|accent)"
-```
-
-**Result**: ✅ CSS properly compiled with theme variables
-
-### 3. Server Response Check
-```bash
-curl -s -o /dev/null -w "%{http_code}" http://localhost:8000/
-```
-
-**Result**: ✅ HTTP 200 - Server responding correctly
-
-### 4. Visual Verification
-- ✅ Primary colors (indigo) displaying correctly
-- ✅ Secondary colors (rose) displaying correctly  
-- ✅ Accent colors (violet) displaying correctly
-- ✅ Poppins font family loading correctly
-- ✅ Button styling and interactions working
-- ✅ Dark mode functionality preserved
-- ✅ Responsive design intact
-- ✅ All animations and transitions working
-
-## Files Modified
-
-### CSS Files
-- `static/css/src/input.css` - ✅ Major updates (import syntax, theme variables, component classes)
-
-### Template Files (Updated utility classes)
-- `templates/base.html`
-- `templates/components/navbar.html`
-- `templates/components/footer.html`
-- `templates/parks/park_list.html`
-- `templates/parks/park_detail.html`
-- `templates/parks/park_form.html`
-- `templates/rides/ride_list.html`
-- `templates/rides/ride_detail.html`
-- `templates/rides/ride_form.html`
-- `templates/companies/company_list.html`
-- `templates/companies/company_detail.html`
-- `templates/companies/company_form.html`
-- `templates/components/search_results.html`
-- `templates/components/pagination.html`
-
-### Configuration Files (Preserved)
-- `tailwind.config.js` - ✅ Preserved for reference
-
-## Benefits of v4 Migration
-
-### Performance Improvements
-- Smaller CSS bundle size
-- Faster compilation times
-- Improved CSS-in-JS performance
-
-### Developer Experience
-- CSS-first configuration approach
-- Better IDE support for theme variables
-- Simplified import syntax
-
-### Future Compatibility
-- Modern CSS features support
-- Better container queries support
-- Enhanced dark mode capabilities
-
-## Troubleshooting Guide
-
-### Common Issues and Solutions
-
-#### Issue: "Cannot apply unknown utility class"
-**Solution**: Check if utility was renamed in v4 migration table above
-
-#### Issue: Custom colors not working
-**Solution**: Ensure `@theme` block is properly defined with CSS variables
-
-#### Issue: Build errors
-**Solution**: Run clean build process:
-```bash
-lsof -ti :8000 | xargs kill -9
-find . -type d -name "__pycache__" -exec rm -r {} +
-uv run manage.py tailwind runserver
-```
-
-## Rollback Plan
-
-If rollback is needed:
-
-1. **Restore CSS Import Syntax**:
-```css
-@tailwind base;
-@tailwind components; 
-@tailwind utilities;
-```
-
-2. **Remove @theme Block**: Delete the `@theme` section from input.css
-
-3. **Revert Utility Classes**: Use search/replace to revert utility class changes
-
-4. **Downgrade Tailwind**: Update package to v3.x version
-
-## Post-Migration Checklist
-
-- [x] CSS compilation working
-- [x] Development server running
-- [x] All pages loading correctly
-- [x] Colors displaying properly
-- [x] Fonts loading correctly
-- [x] Interactive elements working
-- [x] Dark mode functioning
-- [x] Responsive design intact
-- [x] No console errors
-- [x] Performance acceptable
-
-## Future Considerations
-
-### New v4 Features to Explore
-- Enhanced container queries
-- Improved dark mode utilities
-- New color-mix() support
-- Advanced CSS nesting
-
-### Maintenance Notes
-- Monitor for v4 updates and new features
-- Consider migrating more configuration to CSS variables
-- Evaluate new utility classes as they're released
-
-## Contact and Support
-
-For questions about this migration:
-- Review this documentation
-- Check Tailwind CSS v4 official documentation
-- Consult the preserved `tailwind.config.js` for original settings
-
----
-
-**Migration Completed**: August 15, 2025  
-**Tailwind Version**: v4.1.12  
-**Status**: Production Ready ✅

TAILWIND_V4_QUICK_REFERENCE.md

@@ -1,80 +0,0 @@
-# Tailwind CSS v4 Quick Reference Guide
-
-## Common v3 → v4 Utility Migrations
-
-| v3 Utility | v4 Utility | Notes |
-|------------|------------|-------|
-| `outline-none` | `outline-hidden` | Accessibility improvement |
-| `ring` | `ring-3` | Must specify ring width |
-| `shadow-sm` | `shadow-xs` | Renamed for consistency |
-| `shadow` | `shadow-sm` | Renamed for consistency |
-| `flex-shrink-0` | `shrink-0` | Shortened syntax |
-| `bg-blue-500 bg-opacity-50` | `bg-blue-500/50` | New opacity syntax |
-| `text-gray-700 text-opacity-75` | `text-gray-700/75` | New opacity syntax |
-| `!outline-none` | `!outline-hidden` | Updated important syntax |
-
-## Theme Variables (Available in CSS)
-
-```css
-/* Colors */
-var(--color-primary)    /* #4f46e5 - Indigo-600 */
-var(--color-secondary)  /* #e11d48 - Rose-600 */
-var(--color-accent)     /* #8b5cf6 - Violet-500 */
-
-/* Fonts */
-var(--font-family-sans) /* Poppins, sans-serif */
-```
-
-## Usage in Templates
-
-### Before (v3)
-```html
-<button class="outline-none ring hover:ring-2 shadow-sm bg-blue-500 bg-opacity-75">
-  Click me
-</button>
-```
-
-### After (v4)
-```html
-<button class="outline-hidden ring-3 hover:ring-2 shadow-xs bg-blue-500/75">
-  Click me
-</button>
-```
-
-## Development Commands
-
-### Start Development Server
-```bash
-lsof -ti :8000 | xargs kill -9; find . -type d -name "__pycache__" -exec rm -r {} +; uv run manage.py tailwind runserver
-```
-
-### Force CSS Rebuild
-```bash
-uv run manage.py tailwind build
-```
-
-## New v4 Features
-
-- **CSS-first configuration** via `@theme` blocks
-- **Improved opacity syntax** with `/` operator  
-- **Better color-mix() support**
-- **Enhanced dark mode utilities**
-- **Faster compilation**
-
-## Troubleshooting
-
-### Unknown utility class error
-1. Check if utility was renamed (see table above)
-2. Verify custom theme variables are defined
-3. Run clean build process
-
-### Colors not working
-1. Ensure `@theme` block exists in `static/css/src/input.css`
-2. Check CSS variable names match usage
-3. Verify CSS compilation completed
-
-## Resources
-
-- [Full Migration Documentation](./TAILWIND_V4_MIGRATION.md)
-- [Tailwind CSS v4 Official Docs](https://tailwindcss.com/docs)
-- [Django-Tailwind Package](https://django-tailwind.readthedocs.io/)

api_endpoints_curl_commands.sh

@@ -1,649 +0,0 @@
-#!/bin/bash
-
-# ThrillWiki API Endpoints - Complete Curl Commands
-# Generated from comprehensive URL analysis
-# Base URL - adjust as needed for your environment
-BASE_URL="http://localhost:8000"
-
-# Command line options
-SKIP_AUTH=false
-ONLY_AUTH=false
-SKIP_DOCS=false
-HELP=false
-
-# Parse command line arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --skip-auth)
-      SKIP_AUTH=true
-      shift
-      ;;
-    --only-auth)
-      ONLY_AUTH=true
-      shift
-      ;;
-    --skip-docs)
-      SKIP_DOCS=true
-      shift
-      ;;
-    --base-url)
-      BASE_URL="$2"
-      shift 2
-      ;;
-    --help|-h)
-      HELP=true
-      shift
-      ;;
-    *)
-      echo "Unknown option: $1"
-      echo "Use --help for usage information"
-      exit 1
-      ;;
-  esac
-done
-
-# Show help
-if [ "$HELP" = true ]; then
-  echo "ThrillWiki API Endpoints Test Suite"
-  echo ""
-  echo "Usage: $0 [OPTIONS]"
-  echo ""
-  echo "Options:"
-  echo "  --skip-auth     Skip endpoints that require authentication"
-  echo "  --only-auth     Only test endpoints that require authentication"
-  echo "  --skip-docs     Skip API documentation endpoints (schema, swagger, redoc)"
-  echo "  --base-url URL  Set custom base URL (default: http://localhost:8000)"
-  echo "  --help, -h      Show this help message"
-  echo ""
-  echo "Examples:"
-  echo "  $0                           # Test all endpoints"
-  echo "  $0 --skip-auth               # Test only public endpoints"
-  echo "  $0 --only-auth               # Test only authenticated endpoints"
-  echo "  $0 --skip-docs --skip-auth   # Test only public non-documentation endpoints"
-  echo "  $0 --base-url https://api.example.com  # Use custom base URL"
-  exit 0
-fi
-
-# Validate conflicting options
-if [ "$SKIP_AUTH" = true ] && [ "$ONLY_AUTH" = true ]; then
-  echo "Error: --skip-auth and --only-auth cannot be used together"
-  exit 1
-fi
-
-echo "=== ThrillWiki API Endpoints Test Suite ==="
-echo "Base URL: $BASE_URL"
-if [ "$SKIP_AUTH" = true ]; then
-  echo "Mode: Public endpoints only (skipping authentication required)"
-elif [ "$ONLY_AUTH" = true ]; then
-  echo "Mode: Authenticated endpoints only"
-else
-  echo "Mode: All endpoints"
-fi
-if [ "$SKIP_DOCS" = true ]; then
-  echo "Skipping: API documentation endpoints"
-fi
-echo ""
-
-# Helper function to check if we should run an endpoint
-should_run_endpoint() {
-  local requires_auth=$1
-  local is_docs=$2
-  
-  # Skip docs if requested
-  if [ "$SKIP_DOCS" = true ] && [ "$is_docs" = true ]; then
-    return 1
-  fi
-  
-  # Skip auth endpoints if requested
-  if [ "$SKIP_AUTH" = true ] && [ "$requires_auth" = true ]; then
-    return 1
-  fi
-  
-  # Only run auth endpoints if requested
-  if [ "$ONLY_AUTH" = true ] && [ "$requires_auth" = false ]; then
-    return 1
-  fi
-  
-  return 0
-}
-
-# Counter for endpoint numbering
-ENDPOINT_NUM=1
-
-# ============================================================================
-# AUTHENTICATION ENDPOINTS (/api/v1/auth/)
-# ============================================================================
-if should_run_endpoint false false || should_run_endpoint true false; then
-  echo "=== AUTHENTICATION ENDPOINTS ==="
-fi
-
-if should_run_endpoint false false; then
-  echo "$ENDPOINT_NUM. Login"
-  curl -X POST "$BASE_URL/api/v1/auth/login/" \
-    -H "Content-Type: application/json" \
-    -d '{"username": "testuser", "password": "testpass"}'
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Signup"
-  curl -X POST "$BASE_URL/api/v1/auth/signup/" \
-    -H "Content-Type: application/json" \
-    -d '{"username": "newuser", "email": "test@example.com", "password": "newpass123"}'
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Logout"
-  curl -X POST "$BASE_URL/api/v1/auth/logout/" \
-    -H "Content-Type: application/json"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Password Reset"
-  curl -X POST "$BASE_URL/api/v1/auth/password/reset/" \
-    -H "Content-Type: application/json" \
-    -d '{"email": "user@example.com"}'
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Social Providers"
-  curl -X GET "$BASE_URL/api/v1/auth/providers/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Auth Status"
-  curl -X GET "$BASE_URL/api/v1/auth/status/"
-  ((ENDPOINT_NUM++))
-fi
-
-if should_run_endpoint true false; then
-  echo -e "\n$ENDPOINT_NUM. Current User"
-  curl -X GET "$BASE_URL/api/v1/auth/user/" \
-    -H "Authorization: Bearer YOUR_TOKEN_HERE"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Password Change"
-  curl -X POST "$BASE_URL/api/v1/auth/password/change/" \
-    -H "Content-Type: application/json" \
-    -H "Authorization: Bearer YOUR_TOKEN_HERE" \
-    -d '{"old_password": "oldpass", "new_password": "newpass123"}'
-  ((ENDPOINT_NUM++))
-fi
-
-# ============================================================================
-# HEALTH CHECK ENDPOINTS (/api/v1/health/)
-# ============================================================================
-if should_run_endpoint false false; then
-  echo -e "\n\n=== HEALTH CHECK ENDPOINTS ==="
-
-  echo "$ENDPOINT_NUM. Health Check"
-  curl -X GET "$BASE_URL/api/v1/health/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Simple Health"
-  curl -X GET "$BASE_URL/api/v1/health/simple/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Performance Metrics"
-  curl -X GET "$BASE_URL/api/v1/health/performance/"
-  ((ENDPOINT_NUM++))
-fi
-
-# ============================================================================
-# TRENDING SYSTEM ENDPOINTS (/api/v1/trending/)
-# ============================================================================
-if should_run_endpoint false false; then
-  echo -e "\n\n=== TRENDING SYSTEM ENDPOINTS ==="
-
-  echo "$ENDPOINT_NUM. Trending Content"
-  curl -X GET "$BASE_URL/api/v1/trending/content/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. New Content"
-  curl -X GET "$BASE_URL/api/v1/trending/new/"
-  ((ENDPOINT_NUM++))
-fi
-
-# ============================================================================
-# STATISTICS ENDPOINTS (/api/v1/stats/)
-# ============================================================================
-if should_run_endpoint false false || should_run_endpoint true false; then
-  echo -e "\n\n=== STATISTICS ENDPOINTS ==="
-fi
-
-if should_run_endpoint false false; then
-  echo "$ENDPOINT_NUM. Statistics"
-  curl -X GET "$BASE_URL/api/v1/stats/"
-  ((ENDPOINT_NUM++))
-fi
-
-if should_run_endpoint true false; then
-  echo -e "\n$ENDPOINT_NUM. Recalculate Statistics"
-  curl -X POST "$BASE_URL/api/v1/stats/recalculate/" \
-    -H "Authorization: Bearer YOUR_TOKEN_HERE"
-  ((ENDPOINT_NUM++))
-fi
-
-# ============================================================================
-# RANKING SYSTEM ENDPOINTS (/api/v1/rankings/)
-# ============================================================================
-if should_run_endpoint false false || should_run_endpoint true false; then
-  echo -e "\n\n=== RANKING SYSTEM ENDPOINTS ==="
-fi
-
-if should_run_endpoint false false; then
-  echo "$ENDPOINT_NUM. List Rankings"
-  curl -X GET "$BASE_URL/api/v1/rankings/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. List Rankings with Filters"
-  curl -X GET "$BASE_URL/api/v1/rankings/?category=RC&min_riders=10&ordering=rank"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Ranking Detail"
-  curl -X GET "$BASE_URL/api/v1/rankings/ride-slug-here/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Ranking History"
-  curl -X GET "$BASE_URL/api/v1/rankings/ride-slug-here/history/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Ranking Statistics"
-  curl -X GET "$BASE_URL/api/v1/rankings/statistics/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Ranking Comparisons"
-  curl -X GET "$BASE_URL/api/v1/rankings/ride-slug-here/comparisons/"
-  ((ENDPOINT_NUM++))
-fi
-
-if should_run_endpoint true false; then
-  echo -e "\n$ENDPOINT_NUM. Trigger Ranking Calculation"
-  curl -X POST "$BASE_URL/api/v1/rankings/calculate/" \
-    -H "Content-Type: application/json" \
-    -H "Authorization: Bearer YOUR_TOKEN_HERE" \
-    -d '{"category": "RC"}'
-  ((ENDPOINT_NUM++))
-fi
-
-# ============================================================================
-# PARKS API ENDPOINTS (/api/v1/parks/)
-# ============================================================================
-if should_run_endpoint false false || should_run_endpoint true false; then
-  echo -e "\n\n=== PARKS API ENDPOINTS ==="
-fi
-
-if should_run_endpoint false false; then
-  echo "$ENDPOINT_NUM. List Parks"
-  curl -X GET "$BASE_URL/api/v1/parks/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Park Filter Options"
-  curl -X GET "$BASE_URL/api/v1/parks/filter-options/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Park Company Search"
-  curl -X GET "$BASE_URL/api/v1/parks/search/companies/?q=disney"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Park Search Suggestions"
-  curl -X GET "$BASE_URL/api/v1/parks/search-suggestions/?q=magic"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Park Detail"
-  curl -X GET "$BASE_URL/api/v1/parks/1/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. List Park Photos"
-  curl -X GET "$BASE_URL/api/v1/parks/1/photos/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Park Photo Detail"
-  curl -X GET "$BASE_URL/api/v1/parks/1/photos/1/"
-  ((ENDPOINT_NUM++))
-fi
-
-if should_run_endpoint true false; then
-  echo -e "\n$ENDPOINT_NUM. Create Park"
-  curl -X POST "$BASE_URL/api/v1/parks/" \
-    -H "Content-Type: application/json" \
-    -H "Authorization: Bearer YOUR_TOKEN_HERE" \
-    -d '{"name": "Test Park", "location": "Test City"}'
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Update Park"
-  curl -X PUT "$BASE_URL/api/v1/parks/1/" \
-    -H "Content-Type: application/json" \
-    -H "Authorization: Bearer YOUR_TOKEN_HERE" \
-    -d '{"name": "Updated Park Name"}'
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Delete Park"
-  curl -X DELETE "$BASE_URL/api/v1/parks/1/" \
-    -H "Authorization: Bearer YOUR_TOKEN_HERE"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Create Park Photo"
-  curl -X POST "$BASE_URL/api/v1/parks/1/photos/" \
-    -H "Authorization: Bearer YOUR_TOKEN_HERE" \
-    -F "image=@/path/to/photo.jpg" \
-    -F "caption=Test photo"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Update Park Photo"
-  curl -X PUT "$BASE_URL/api/v1/parks/1/photos/1/" \
-    -H "Content-Type: application/json" \
-    -H "Authorization: Bearer YOUR_TOKEN_HERE" \
-    -d '{"caption": "Updated caption"}'
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Delete Park Photo"
-  curl -X DELETE "$BASE_URL/api/v1/parks/1/photos/1/" \
-    -H "Authorization: Bearer YOUR_TOKEN_HERE"
-  ((ENDPOINT_NUM++))
-fi
-
-# ============================================================================
-# RIDES API ENDPOINTS (/api/v1/rides/)
-# ============================================================================
-if should_run_endpoint false false || should_run_endpoint true false; then
-  echo -e "\n\n=== RIDES API ENDPOINTS ==="
-fi
-
-if should_run_endpoint false false; then
-  echo "$ENDPOINT_NUM. List Rides"
-  curl -X GET "$BASE_URL/api/v1/rides/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Ride Filter Options"
-  curl -X GET "$BASE_URL/api/v1/rides/filter-options/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Ride Company Search"
-  curl -X GET "$BASE_URL/api/v1/rides/search/companies/?q=intamin"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Ride Model Search"
-  curl -X GET "$BASE_URL/api/v1/rides/search/ride-models/?q=giga"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Ride Search Suggestions"
-  curl -X GET "$BASE_URL/api/v1/rides/search-suggestions/?q=millennium"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Ride Detail"
-  curl -X GET "$BASE_URL/api/v1/rides/1/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. List Ride Photos"
-  curl -X GET "$BASE_URL/api/v1/rides/1/photos/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Ride Photo Detail"
-  curl -X GET "$BASE_URL/api/v1/rides/1/photos/1/"
-  ((ENDPOINT_NUM++))
-fi
-
-if should_run_endpoint true false; then
-  echo -e "\n$ENDPOINT_NUM. Create Ride"
-  curl -X POST "$BASE_URL/api/v1/rides/" \
-    -H "Content-Type: application/json" \
-    -H "Authorization: Bearer YOUR_TOKEN_HERE" \
-    -d '{"name": "Test Coaster", "category": "RC", "park": 1}'
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Update Ride"
-  curl -X PUT "$BASE_URL/api/v1/rides/1/" \
-    -H "Content-Type: application/json" \
-    -H "Authorization: Bearer YOUR_TOKEN_HERE" \
-    -d '{"name": "Updated Ride Name"}'
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Delete Ride"
-  curl -X DELETE "$BASE_URL/api/v1/rides/1/" \
-    -H "Authorization: Bearer YOUR_TOKEN_HERE"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Create Ride Photo"
-  curl -X POST "$BASE_URL/api/v1/rides/1/photos/" \
-    -H "Authorization: Bearer YOUR_TOKEN_HERE" \
-    -F "image=@/path/to/photo.jpg" \
-    -F "caption=Test ride photo"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Update Ride Photo"
-  curl -X PUT "$BASE_URL/api/v1/rides/1/photos/1/" \
-    -H "Content-Type: application/json" \
-    -H "Authorization: Bearer YOUR_TOKEN_HERE" \
-    -d '{"caption": "Updated ride photo caption"}'
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Delete Ride Photo"
-  curl -X DELETE "$BASE_URL/api/v1/rides/1/photos/1/" \
-    -H "Authorization: Bearer YOUR_TOKEN_HERE"
-  ((ENDPOINT_NUM++))
-fi
-
-# ============================================================================
-# ACCOUNTS API ENDPOINTS (/api/v1/accounts/)
-# ============================================================================
-if should_run_endpoint false false || should_run_endpoint true false; then
-  echo -e "\n\n=== ACCOUNTS API ENDPOINTS ==="
-fi
-
-if should_run_endpoint false false; then
-  echo "$ENDPOINT_NUM. List User Profiles"
-  curl -X GET "$BASE_URL/api/v1/accounts/profiles/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. User Profile Detail"
-  curl -X GET "$BASE_URL/api/v1/accounts/profiles/1/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. List Top Lists"
-  curl -X GET "$BASE_URL/api/v1/accounts/toplists/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Top List Detail"
-  curl -X GET "$BASE_URL/api/v1/accounts/toplists/1/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. List Top List Items"
-  curl -X GET "$BASE_URL/api/v1/accounts/toplist-items/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Top List Item Detail"
-  curl -X GET "$BASE_URL/api/v1/accounts/toplist-items/1/"
-  ((ENDPOINT_NUM++))
-fi
-
-if should_run_endpoint true false; then
-  echo -e "\n$ENDPOINT_NUM. Update User Profile"
-  curl -X PUT "$BASE_URL/api/v1/accounts/profiles/1/" \
-    -H "Content-Type: application/json" \
-    -H "Authorization: Bearer YOUR_TOKEN_HERE" \
-    -d '{"bio": "Updated bio"}'
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Create Top List"
-  curl -X POST "$BASE_URL/api/v1/accounts/toplists/" \
-    -H "Content-Type: application/json" \
-    -H "Authorization: Bearer YOUR_TOKEN_HERE" \
-    -d '{"name": "My Top Coasters", "description": "My favorite roller coasters"}'
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Update Top List"
-  curl -X PUT "$BASE_URL/api/v1/accounts/toplists/1/" \
-    -H "Content-Type: application/json" \
-    -H "Authorization: Bearer YOUR_TOKEN_HERE" \
-    -d '{"name": "Updated Top List Name"}'
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Delete Top List"
-  curl -X DELETE "$BASE_URL/api/v1/accounts/toplists/1/" \
-    -H "Authorization: Bearer YOUR_TOKEN_HERE"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Create Top List Item"
-  curl -X POST "$BASE_URL/api/v1/accounts/toplist-items/" \
-    -H "Content-Type: application/json" \
-    -H "Authorization: Bearer YOUR_TOKEN_HERE" \
-    -d '{"toplist": 1, "ride": 1, "position": 1}'
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Update Top List Item"
-  curl -X PUT "$BASE_URL/api/v1/accounts/toplist-items/1/" \
-    -H "Content-Type: application/json" \
-    -H "Authorization: Bearer YOUR_TOKEN_HERE" \
-    -d '{"position": 2}'
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Delete Top List Item"
-  curl -X DELETE "$BASE_URL/api/v1/accounts/toplist-items/1/" \
-    -H "Authorization: Bearer YOUR_TOKEN_HERE"
-  ((ENDPOINT_NUM++))
-fi
-
-# ============================================================================
-# HISTORY API ENDPOINTS (/api/v1/history/)
-# ============================================================================
-if should_run_endpoint false false; then
-  echo -e "\n\n=== HISTORY API ENDPOINTS ==="
-
-  echo "$ENDPOINT_NUM. Park History List"
-  curl -X GET "$BASE_URL/api/v1/history/parks/park-slug/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Park History Detail"
-  curl -X GET "$BASE_URL/api/v1/history/parks/park-slug/detail/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Ride History List"
-  curl -X GET "$BASE_URL/api/v1/history/parks/park-slug/rides/ride-slug/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Ride History Detail"
-  curl -X GET "$BASE_URL/api/v1/history/parks/park-slug/rides/ride-slug/detail/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Unified Timeline"
-  curl -X GET "$BASE_URL/api/v1/history/timeline/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Unified Timeline Detail"
-  curl -X GET "$BASE_URL/api/v1/history/timeline/1/"
-  ((ENDPOINT_NUM++))
-fi
-
-# ============================================================================
-# EMAIL API ENDPOINTS (/api/v1/email/)
-# ============================================================================
-if should_run_endpoint true false; then
-  echo -e "\n\n=== EMAIL API ENDPOINTS ==="
-
-  echo "$ENDPOINT_NUM. Send Email"
-  curl -X POST "$BASE_URL/api/v1/email/send/" \
-    -H "Content-Type: application/json" \
-    -H "Authorization: Bearer YOUR_TOKEN_HERE" \
-    -d '{"to": "recipient@example.com", "subject": "Test", "message": "Test message"}'
-  ((ENDPOINT_NUM++))
-fi
-
-# ============================================================================
-# CORE API ENDPOINTS (/api/v1/core/)
-# ============================================================================
-if should_run_endpoint false false; then
-  echo -e "\n\n=== CORE API ENDPOINTS ==="
-
-  echo "$ENDPOINT_NUM. Entity Fuzzy Search"
-  curl -X GET "$BASE_URL/api/v1/core/entities/search/?q=disney"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Entity Not Found"
-  curl -X POST "$BASE_URL/api/v1/core/entities/not-found/" \
-    -H "Content-Type: application/json" \
-    -d '{"query": "nonexistent park", "type": "park"}'
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Entity Suggestions"
-  curl -X GET "$BASE_URL/api/v1/core/entities/suggestions/?q=magic"
-  ((ENDPOINT_NUM++))
-fi
-
-# ============================================================================
-# MAPS API ENDPOINTS (/api/v1/maps/)
-# ============================================================================
-if should_run_endpoint false false || should_run_endpoint true false; then
-  echo -e "\n\n=== MAPS API ENDPOINTS ==="
-fi
-
-if should_run_endpoint false false; then
-  echo "$ENDPOINT_NUM. Map Locations"
-  curl -X GET "$BASE_URL/api/v1/maps/locations/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Map Location Detail"
-  curl -X GET "$BASE_URL/api/v1/maps/locations/park/1/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Map Search"
-  curl -X GET "$BASE_URL/api/v1/maps/search/?q=disney"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Map Bounds Query"
-  curl -X GET "$BASE_URL/api/v1/maps/bounds/?north=40.7&south=40.6&east=-73.9&west=-74.0"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Map Statistics"
-  curl -X GET "$BASE_URL/api/v1/maps/stats/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Map Cache Status"
-  curl -X GET "$BASE_URL/api/v1/maps/cache/"
-  ((ENDPOINT_NUM++))
-fi
-
-if should_run_endpoint true false; then
-  echo -e "\n$ENDPOINT_NUM. Invalidate Map Cache"
-  curl -X POST "$BASE_URL/api/v1/maps/cache/invalidate/" \
-    -H "Authorization: Bearer YOUR_TOKEN_HERE"
-  ((ENDPOINT_NUM++))
-fi
-
-# ============================================================================
-# API DOCUMENTATION ENDPOINTS
-# ============================================================================
-if should_run_endpoint false true; then
-  echo -e "\n\n=== API DOCUMENTATION ENDPOINTS ==="
-
-  echo "$ENDPOINT_NUM. OpenAPI Schema"
-  curl -X GET "$BASE_URL/api/schema/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. Swagger UI"
-  curl -X GET "$BASE_URL/api/docs/"
-  ((ENDPOINT_NUM++))
-
-  echo -e "\n$ENDPOINT_NUM. ReDoc"
-  curl -X GET "$BASE_URL/api/redoc/"
-  ((ENDPOINT_NUM++))
-fi
-
-# ============================================================================
-# HEALTH CHECK (Django Health Check)
-# ============================================================================
-if should_run_endpoint false false; then
-  echo -e "\n\n=== DJANGO HEALTH CHECK ==="
-
-  echo "$ENDPOINT_NUM. Django Health Check"
-  curl -X GET "$BASE_URL/health/"
-  ((ENDPOINT_NUM++))
-fi
-
-echo -e "\n\n=== END OF API ENDPOINTS TEST SUITE ==="
-echo "Total endpoints tested: $((ENDPOINT_NUM - 1))"
-echo ""
-echo "Notes:"
-echo "- Replace YOUR_TOKEN_HERE with actual authentication tokens"
-echo "- Replace /path/to/photo.jpg with actual file paths for photo uploads"
-echo "- Replace numeric IDs (1, 2, etc.) with actual resource IDs"
-echo "- Replace slug placeholders (park-slug, ride-slug) with actual slugs"
-echo "- Adjust BASE_URL for your environment (localhost:8000, staging, production)"
-echo ""
-echo "Authentication required endpoints are marked with Authorization header"
-echo "File upload endpoints use multipart/form-data (-F flag)"
-echo "JSON endpoints use application/json content type"

apps/accounts/__init__.py

@@ -0,0 +1,2 @@
+# Import choices to trigger registration
+from .choices import *

apps/accounts/adapters.py

@@ -0,0 +1,95 @@
+from django.conf import settings
+from django.http import HttpRequest
+from typing import Optional, Any, Dict, Literal, TYPE_CHECKING, cast
+from allauth.account.adapter import DefaultAccountAdapter  # type: ignore[import]
+from allauth.account.models import EmailConfirmation, EmailAddress  # type: ignore[import]
+from allauth.socialaccount.adapter import DefaultSocialAccountAdapter  # type: ignore[import]
+from allauth.socialaccount.models import SocialLogin  # type: ignore[import]
+from django.contrib.auth import get_user_model
+from django.contrib.sites.shortcuts import get_current_site
+
+if TYPE_CHECKING:
+    from django.contrib.auth.models import AbstractUser
+
+User = get_user_model()
+
+
+class CustomAccountAdapter(DefaultAccountAdapter):
+    def is_open_for_signup(self, request: HttpRequest) -> Literal[True]:
+        """
+        Whether to allow sign ups.
+        """
+        return True
+
+    def get_email_confirmation_url(self, request: HttpRequest, emailconfirmation: EmailConfirmation) -> str:
+        """
+        Constructs the email confirmation (activation) url.
+        """
+        get_current_site(request)
+        # Ensure the key is treated as a string for the type checker
+        key = cast(str, getattr(emailconfirmation, "key", ""))
+        return f"{settings.LOGIN_REDIRECT_URL}verify-email?key={key}"
+
+    def send_confirmation_mail(self, request: HttpRequest, emailconfirmation: EmailConfirmation, signup: bool) -> None:
+        """
+        Sends the confirmation email.
+        """
+        current_site = get_current_site(request)
+        activate_url = self.get_email_confirmation_url(request, emailconfirmation)
+        # Cast key to str for typing consistency and template context
+        key = cast(str, getattr(emailconfirmation, "key", ""))
+
+        # Determine template early
+        if signup:
+            email_template = "account/email/email_confirmation_signup"
+        else:
+            email_template = "account/email/email_confirmation"
+
+        # Cast the possibly-unknown email_address to EmailAddress so the type checker knows its attributes
+        email_address = cast(EmailAddress, getattr(emailconfirmation, "email_address", None))
+
+        # Safely obtain email string (fallback to any top-level email on confirmation)
+        email_str = cast(str, getattr(email_address, "email", getattr(emailconfirmation, "email", "")))
+
+        # Safely obtain the user object, cast to the project's User model for typing
+        user_obj = cast("AbstractUser", getattr(email_address, "user", None))
+
+        # Explicitly type the context to avoid partial-unknown typing issues
+        ctx: Dict[str, Any] = {
+            "user": user_obj,
+            "activate_url": activate_url,
+            "current_site": current_site,
+            "key": key,
+        }
+        # Remove unnecessary cast; ctx is already Dict[str, Any]
+        self.send_mail(email_template, email_str, ctx)  # type: ignore
+
+
+class CustomSocialAccountAdapter(DefaultSocialAccountAdapter):
+    def is_open_for_signup(self, request: HttpRequest, sociallogin: SocialLogin) -> Literal[True]:
+        """
+        Whether to allow social account sign ups.
+        """
+        return True
+
+    def populate_user(
+        self, request: HttpRequest, sociallogin: SocialLogin, data: Dict[str, Any]
+    ) -> "AbstractUser":  # type: ignore[override]
+        """
+        Hook that can be used to further populate the user instance.
+        """
+        user = super().populate_user(request, sociallogin, data)  # type: ignore
+        if getattr(sociallogin.account, "provider", None) == "discord":  # type: ignore
+            user.discord_id = getattr(sociallogin.account, "uid", None)  # type: ignore
+        return cast("AbstractUser", user)  # Ensure return type is explicit
+
+    def save_user(
+        self, request: HttpRequest, sociallogin: SocialLogin, form: Optional[Any] = None
+    ) -> "AbstractUser":  # type: ignore[override]
+        """
+        Save the newly signed up social login.
+        """
+        user = super().save_user(request, sociallogin, form)  # type: ignore
+        if user is None:
+            raise ValueError("User creation failed")
+        return cast("AbstractUser", user)  # Ensure return type is explicit

apps/accounts/admin.py

@@ -1,7 +1,10 @@
+from typing import Any
 from django.contrib import admin
-from django.contrib.auth.admin import UserAdmin
+from django.contrib.auth.admin import UserAdmin as DjangoUserAdmin
 from django.utils.html import format_html
 from django.contrib.auth.models import Group
+from django.http import HttpRequest
+from django.db.models import QuerySet
 from .models import (
     User,
     UserProfile,
@@ -12,7 +15,7 @@ from .models import (
 )
 
 
-class UserProfileInline(admin.StackedInline):
+class UserProfileInline(admin.StackedInline[UserProfile, admin.options.AdminSite]):
     model = UserProfile
     can_delete = False
     verbose_name_plural = "Profile"
@@ -39,7 +42,7 @@ class UserProfileInline(admin.StackedInline):
     )
 
 
-class TopListItemInline(admin.TabularInline):
+class TopListItemInline(admin.TabularInline[TopListItem]):
     model = TopListItem
     extra = 1
     fields = ("content_type", "object_id", "rank", "notes")
@@ -47,7 +50,7 @@ class TopListItemInline(admin.TabularInline):
 
 
 @admin.register(User)
-class CustomUserAdmin(UserAdmin):
+class CustomUserAdmin(DjangoUserAdmin[User]):
     list_display = (
         "username",
         "email",
@@ -74,7 +77,7 @@ class CustomUserAdmin(UserAdmin):
         "ban_users",
         "unban_users",
     ]
-    inlines = [UserProfileInline]
+    inlines: list[type[admin.StackedInline[UserProfile]]] = [UserProfileInline]
 
     fieldsets = (
         (None, {"fields": ("username", "password")}),
@@ -126,75 +129,82 @@ class CustomUserAdmin(UserAdmin):
     )
 
     @admin.display(description="Avatar")
-    def get_avatar(self, obj):
+    def get_avatar(self, obj: User) -> str:
-        if obj.profile.avatar:
+        profile = getattr(obj, "profile", None)
+        if profile and getattr(profile, "avatar", None):
             return format_html(
-                '<img src="{}" width="30" height="30" style="border-radius:50%;" />',
+                '<img src="{0}" width="30" height="30" style="border-radius:50%;" />',
-                obj.profile.avatar.url,
+                getattr(profile.avatar, "url", ""),  # type: ignore
             )
         return format_html(
             '<div style="width:30px; height:30px; border-radius:50%; '
             "background-color:#007bff; color:white; display:flex; "
-            'align-items:center; justify-content:center;">{}</div>',
+            'align-items:center; justify-content:center;">{0}</div>',
-            obj.username[0].upper(),
+            getattr(obj, "username", "?")[0].upper(),  # type: ignore
         )
 
     @admin.display(description="Status")
-    def get_status(self, obj):
+    def get_status(self, obj: User) -> str:
-        if obj.is_banned:
+        if getattr(obj, "is_banned", False):
-            return format_html('<span style="color: red;">Banned</span>')
+            return format_html('<span style="color: red;">{}</span>', "Banned")
-        if not obj.is_active:
+        if not getattr(obj, "is_active", True):
-            return format_html('<span style="color: orange;">Inactive</span>')
+            return format_html('<span style="color: orange;">{}</span>', "Inactive")
-        if obj.is_superuser:
+        if getattr(obj, "is_superuser", False):
-            return format_html('<span style="color: purple;">Superuser</span>')
+            return format_html('<span style="color: purple;">{}</span>', "Superuser")
-        if obj.is_staff:
+        if getattr(obj, "is_staff", False):
-            return format_html('<span style="color: blue;">Staff</span>')
+            return format_html('<span style="color: blue;">{}</span>', "Staff")
-        return format_html('<span style="color: green;">Active</span>')
+        return format_html('<span style="color: green;">{}</span>', "Active")
 
     @admin.display(description="Ride Credits")
-    def get_credits(self, obj):
+    def get_credits(self, obj: User) -> str:
         try:
-            profile = obj.profile
+            profile = getattr(obj, "profile", None)
+            if not profile:
+                return "-"
             return format_html(
-                "RC: {}<br>DR: {}<br>FR: {}<br>WR: {}",
+                "RC: {0}<br>DR: {1}<br>FR: {2}<br>WR: {3}",
-                profile.coaster_credits,
+                getattr(profile, "coaster_credits", 0),
-                profile.dark_ride_credits,
+                getattr(profile, "dark_ride_credits", 0),
-                profile.flat_ride_credits,
+                getattr(profile, "flat_ride_credits", 0),
-                profile.water_ride_credits,
+                getattr(profile, "water_ride_credits", 0),
             )
         except UserProfile.DoesNotExist:
             return "-"
 
     @admin.action(description="Activate selected users")
-    def activate_users(self, request, queryset):
+    def activate_users(self, request: HttpRequest, queryset: QuerySet[User]) -> None:
         queryset.update(is_active=True)
 
     @admin.action(description="Deactivate selected users")
-    def deactivate_users(self, request, queryset):
+    def deactivate_users(self, request: HttpRequest, queryset: QuerySet[User]) -> None:
         queryset.update(is_active=False)
 
     @admin.action(description="Ban selected users")
-    def ban_users(self, request, queryset):
+    def ban_users(self, request: HttpRequest, queryset: QuerySet[User]) -> None:
         from django.utils import timezone
-
         queryset.update(is_banned=True, ban_date=timezone.now())
 
     @admin.action(description="Unban selected users")
-    def unban_users(self, request, queryset):
+    def unban_users(self, request: HttpRequest, queryset: QuerySet[User]) -> None:
         queryset.update(is_banned=False, ban_date=None, ban_reason="")
 
-    def save_model(self, request, obj, form, change):
+    def save_model(
+        self,
+        request: HttpRequest,
+        obj: User,
+        form: Any,
+        change: bool
+    ) -> None:
         creating = not obj.pk
         super().save_model(request, obj, form, change)
-        if creating and obj.role != User.Roles.USER:
+        if creating and getattr(obj, "role", "USER") != "USER":
-            # Ensure new user with role gets added to appropriate group
+            group = Group.objects.filter(name=getattr(obj, "role", None)).first()
-            group = Group.objects.filter(name=obj.role).first()
             if group:
-                obj.groups.add(group)
+                obj.groups.add(group)  # type: ignore[attr-defined]
 
 
 @admin.register(UserProfile)
-class UserProfileAdmin(admin.ModelAdmin):
+class UserProfileAdmin(admin.ModelAdmin[UserProfile]):
     list_display = (
         "user",
         "display_name",
@@ -235,7 +245,7 @@ class UserProfileAdmin(admin.ModelAdmin):
 
 
 @admin.register(EmailVerification)
-class EmailVerificationAdmin(admin.ModelAdmin):
+class EmailVerificationAdmin(admin.ModelAdmin[EmailVerification]):
     list_display = ("user", "created_at", "last_sent", "is_expired")
     list_filter = ("created_at", "last_sent")
     search_fields = ("user__username", "user__email", "token")
@@ -247,21 +257,21 @@ class EmailVerificationAdmin(admin.ModelAdmin):
     )
 
     @admin.display(description="Status")
-    def is_expired(self, obj):
+    def is_expired(self, obj: EmailVerification) -> str:
         from django.utils import timezone
         from datetime import timedelta
 
-        if timezone.now() - obj.last_sent > timedelta(days=1):
+        if timezone.now() - getattr(obj, "last_sent", timezone.now()) > timedelta(days=1):
-            return format_html('<span style="color: red;">Expired</span>')
+            return format_html('<span style="color: red;">{}</span>', "Expired")
-        return format_html('<span style="color: green;">Valid</span>')
+        return format_html('<span style="color: green;">{}</span>', "Valid")
 
 
 @admin.register(TopList)
-class TopListAdmin(admin.ModelAdmin):
+class TopListAdmin(admin.ModelAdmin[TopList]):
     list_display = ("title", "user", "category", "created_at", "updated_at")
     list_filter = ("category", "created_at", "updated_at")
     search_fields = ("title", "user__username", "description")
-    inlines = [TopListItemInline]
+    inlines: list[type[admin.TabularInline[TopListItem]]] = [TopListItemInline]
 
     fieldsets = (
         (
@@ -277,7 +287,7 @@ class TopListAdmin(admin.ModelAdmin):
 
 
 @admin.register(TopListItem)
-class TopListItemAdmin(admin.ModelAdmin):
+class TopListItemAdmin(admin.ModelAdmin[TopListItem]):
     list_display = ("top_list", "content_type", "object_id", "rank")
     list_filter = ("top_list__category", "rank")
     search_fields = ("top_list__title", "notes")
@@ -290,7 +300,7 @@ class TopListItemAdmin(admin.ModelAdmin):
 
 
 @admin.register(PasswordReset)
-class PasswordResetAdmin(admin.ModelAdmin):
+class PasswordResetAdmin(admin.ModelAdmin[PasswordReset]):
     """Admin interface for password reset tokens"""
 
     list_display = (
@@ -341,20 +351,19 @@ class PasswordResetAdmin(admin.ModelAdmin):
     )
 
     @admin.display(description="Status", boolean=True)
-    def is_expired(self, obj):
+    def is_expired(self, obj: PasswordReset) -> str:
-        """Display expiration status with color coding"""
         from django.utils import timezone
 
-        if obj.used:
+        if getattr(obj, "used", False):
-            return format_html('<span style="color: blue;">Used</span>')
+            return format_html('<span style="color: blue;">{}</span>', "Used")
-        elif timezone.now() > obj.expires_at:
+        elif timezone.now() > getattr(obj, "expires_at", timezone.now()):
-            return format_html('<span style="color: red;">Expired</span>')
+            return format_html('<span style="color: red;">{}</span>', "Expired")
-        return format_html('<span style="color: green;">Valid</span>')
+        return format_html('<span style="color: green;">{}</span>', "Valid")
 
-    def has_add_permission(self, request):
+    def has_add_permission(self, request: HttpRequest) -> bool:
         """Disable manual creation of password reset tokens"""
         return False
 
-    def has_change_permission(self, request, obj=None):
+    def has_change_permission(self, request: HttpRequest, obj: Any = None) -> bool:
         """Allow viewing but restrict editing of password reset tokens"""
         return getattr(request.user, "is_superuser", False)

apps/accounts/choices.py

@@ -0,0 +1,563 @@
+"""
+Rich Choice Objects for Accounts Domain
+
+This module defines all choice objects used in the accounts domain,
+replacing tuple-based choices with rich, metadata-enhanced choice objects.
+
+Last updated: 2025-01-15
+"""
+
+from apps.core.choices import RichChoice, ChoiceGroup, register_choices
+
+
+# =============================================================================
+# USER ROLES
+# =============================================================================
+
+user_roles = ChoiceGroup(
+    name="user_roles",
+    choices=[
+        RichChoice(
+            value="USER",
+            label="User",
+            description="Standard user with basic permissions to create content, reviews, and lists",
+            metadata={
+                "color": "blue",
+                "icon": "user",
+                "css_class": "text-blue-600 bg-blue-50",
+                "permissions": ["create_content", "create_reviews", "create_lists"],
+                "sort_order": 1,
+            }
+        ),
+        RichChoice(
+            value="MODERATOR",
+            label="Moderator",
+            description="Trusted user with permissions to moderate content and assist other users",
+            metadata={
+                "color": "green",
+                "icon": "shield-check",
+                "css_class": "text-green-600 bg-green-50",
+                "permissions": ["moderate_content", "review_submissions", "manage_reports"],
+                "sort_order": 2,
+            }
+        ),
+        RichChoice(
+            value="ADMIN",
+            label="Admin",
+            description="Administrator with elevated permissions to manage users and site configuration",
+            metadata={
+                "color": "purple",
+                "icon": "cog",
+                "css_class": "text-purple-600 bg-purple-50",
+                "permissions": ["manage_users", "site_configuration", "advanced_moderation"],
+                "sort_order": 3,
+            }
+        ),
+        RichChoice(
+            value="SUPERUSER",
+            label="Superuser",
+            description="Full system administrator with unrestricted access to all features",
+            metadata={
+                "color": "red",
+                "icon": "key",
+                "css_class": "text-red-600 bg-red-50",
+                "permissions": ["full_access", "system_administration", "database_access"],
+                "sort_order": 4,
+            }
+        ),
+    ]
+)
+
+
+# =============================================================================
+# THEME PREFERENCES
+# =============================================================================
+
+theme_preferences = ChoiceGroup(
+    name="theme_preferences",
+    choices=[
+        RichChoice(
+            value="light",
+            label="Light",
+            description="Light theme with bright backgrounds and dark text for daytime use",
+            metadata={
+                "color": "yellow",
+                "icon": "sun",
+                "css_class": "text-yellow-600 bg-yellow-50",
+                "preview_colors": {
+                    "background": "#ffffff",
+                    "text": "#1f2937",
+                    "accent": "#3b82f6"
+                },
+                "sort_order": 1,
+            }
+        ),
+        RichChoice(
+            value="dark",
+            label="Dark",
+            description="Dark theme with dark backgrounds and light text for nighttime use",
+            metadata={
+                "color": "gray",
+                "icon": "moon",
+                "css_class": "text-gray-600 bg-gray-50",
+                "preview_colors": {
+                    "background": "#1f2937",
+                    "text": "#f9fafb",
+                    "accent": "#60a5fa"
+                },
+                "sort_order": 2,
+            }
+        ),
+    ]
+)
+
+
+# =============================================================================
+# PRIVACY LEVELS
+# =============================================================================
+
+privacy_levels = ChoiceGroup(
+    name="privacy_levels",
+    choices=[
+        RichChoice(
+            value="public",
+            label="Public",
+            description="Profile and activity visible to all users and search engines",
+            metadata={
+                "color": "green",
+                "icon": "globe",
+                "css_class": "text-green-600 bg-green-50",
+                "visibility_scope": "everyone",
+                "search_indexable": True,
+                "implications": [
+                    "Profile visible to all users",
+                    "Activity appears in public feeds",
+                    "Searchable by search engines",
+                    "Can be found by username search"
+                ],
+                "sort_order": 1,
+            }
+        ),
+        RichChoice(
+            value="friends",
+            label="Friends Only",
+            description="Profile and activity visible only to accepted friends",
+            metadata={
+                "color": "blue",
+                "icon": "users",
+                "css_class": "text-blue-600 bg-blue-50",
+                "visibility_scope": "friends",
+                "search_indexable": False,
+                "implications": [
+                    "Profile visible only to friends",
+                    "Activity hidden from public feeds",
+                    "Not searchable by search engines",
+                    "Requires friend request approval"
+                ],
+                "sort_order": 2,
+            }
+        ),
+        RichChoice(
+            value="private",
+            label="Private",
+            description="Profile and activity completely private, visible only to you",
+            metadata={
+                "color": "red",
+                "icon": "lock",
+                "css_class": "text-red-600 bg-red-50",
+                "visibility_scope": "self",
+                "search_indexable": False,
+                "implications": [
+                    "Profile completely hidden",
+                    "No activity in any feeds",
+                    "Not discoverable by other users",
+                    "Maximum privacy protection"
+                ],
+                "sort_order": 3,
+            }
+        ),
+    ]
+)
+
+
+# =============================================================================
+# TOP LIST CATEGORIES
+# =============================================================================
+
+top_list_categories = ChoiceGroup(
+    name="top_list_categories",
+    choices=[
+        RichChoice(
+            value="RC",
+            label="Roller Coaster",
+            description="Top lists for roller coasters and thrill rides",
+            metadata={
+                "color": "red",
+                "icon": "roller-coaster",
+                "css_class": "text-red-600 bg-red-50",
+                "ride_category": "roller_coaster",
+                "typical_list_size": 10,
+                "sort_order": 1,
+            }
+        ),
+        RichChoice(
+            value="DR",
+            label="Dark Ride",
+            description="Top lists for dark rides and indoor attractions",
+            metadata={
+                "color": "purple",
+                "icon": "moon",
+                "css_class": "text-purple-600 bg-purple-50",
+                "ride_category": "dark_ride",
+                "typical_list_size": 10,
+                "sort_order": 2,
+            }
+        ),
+        RichChoice(
+            value="FR",
+            label="Flat Ride",
+            description="Top lists for flat rides and spinning attractions",
+            metadata={
+                "color": "blue",
+                "icon": "refresh",
+                "css_class": "text-blue-600 bg-blue-50",
+                "ride_category": "flat_ride",
+                "typical_list_size": 10,
+                "sort_order": 3,
+            }
+        ),
+        RichChoice(
+            value="WR",
+            label="Water Ride",
+            description="Top lists for water rides and splash attractions",
+            metadata={
+                "color": "cyan",
+                "icon": "droplet",
+                "css_class": "text-cyan-600 bg-cyan-50",
+                "ride_category": "water_ride",
+                "typical_list_size": 10,
+                "sort_order": 4,
+            }
+        ),
+        RichChoice(
+            value="PK",
+            label="Park",
+            description="Top lists for theme parks and amusement parks",
+            metadata={
+                "color": "green",
+                "icon": "map",
+                "css_class": "text-green-600 bg-green-50",
+                "entity_type": "park",
+                "typical_list_size": 10,
+                "sort_order": 5,
+            }
+        ),
+    ]
+)
+
+
+# =============================================================================
+# NOTIFICATION TYPES
+# =============================================================================
+
+notification_types = ChoiceGroup(
+    name="notification_types",
+    choices=[
+        # Submission related
+        RichChoice(
+            value="submission_approved",
+            label="Submission Approved",
+            description="Notification when user's submission is approved by moderators",
+            metadata={
+                "color": "green",
+                "icon": "check-circle",
+                "css_class": "text-green-600 bg-green-50",
+                "category": "submission",
+                "default_channels": ["email", "push", "inapp"],
+                "priority": "normal",
+                "sort_order": 1,
+            }
+        ),
+        RichChoice(
+            value="submission_rejected",
+            label="Submission Rejected",
+            description="Notification when user's submission is rejected by moderators",
+            metadata={
+                "color": "red",
+                "icon": "x-circle",
+                "css_class": "text-red-600 bg-red-50",
+                "category": "submission",
+                "default_channels": ["email", "push", "inapp"],
+                "priority": "normal",
+                "sort_order": 2,
+            }
+        ),
+        RichChoice(
+            value="submission_pending",
+            label="Submission Pending Review",
+            description="Notification when user's submission is pending moderator review",
+            metadata={
+                "color": "yellow",
+                "icon": "clock",
+                "css_class": "text-yellow-600 bg-yellow-50",
+                "category": "submission",
+                "default_channels": ["inapp"],
+                "priority": "low",
+                "sort_order": 3,
+            }
+        ),
+        # Review related
+        RichChoice(
+            value="review_reply",
+            label="Review Reply",
+            description="Notification when someone replies to user's review",
+            metadata={
+                "color": "blue",
+                "icon": "chat-bubble",
+                "css_class": "text-blue-600 bg-blue-50",
+                "category": "review",
+                "default_channels": ["email", "push", "inapp"],
+                "priority": "normal",
+                "sort_order": 4,
+            }
+        ),
+        RichChoice(
+            value="review_helpful",
+            label="Review Marked Helpful",
+            description="Notification when user's review is marked as helpful",
+            metadata={
+                "color": "green",
+                "icon": "thumbs-up",
+                "css_class": "text-green-600 bg-green-50",
+                "category": "review",
+                "default_channels": ["push", "inapp"],
+                "priority": "low",
+                "sort_order": 5,
+            }
+        ),
+        # Social related
+        RichChoice(
+            value="friend_request",
+            label="Friend Request",
+            description="Notification when user receives a friend request",
+            metadata={
+                "color": "blue",
+                "icon": "user-plus",
+                "css_class": "text-blue-600 bg-blue-50",
+                "category": "social",
+                "default_channels": ["email", "push", "inapp"],
+                "priority": "normal",
+                "sort_order": 6,
+            }
+        ),
+        RichChoice(
+            value="friend_accepted",
+            label="Friend Request Accepted",
+            description="Notification when user's friend request is accepted",
+            metadata={
+                "color": "green",
+                "icon": "user-check",
+                "css_class": "text-green-600 bg-green-50",
+                "category": "social",
+                "default_channels": ["push", "inapp"],
+                "priority": "low",
+                "sort_order": 7,
+            }
+        ),
+        RichChoice(
+            value="message_received",
+            label="Message Received",
+            description="Notification when user receives a private message",
+            metadata={
+                "color": "blue",
+                "icon": "mail",
+                "css_class": "text-blue-600 bg-blue-50",
+                "category": "social",
+                "default_channels": ["email", "push", "inapp"],
+                "priority": "normal",
+                "sort_order": 8,
+            }
+        ),
+        RichChoice(
+            value="profile_comment",
+            label="Profile Comment",
+            description="Notification when someone comments on user's profile",
+            metadata={
+                "color": "blue",
+                "icon": "chat",
+                "css_class": "text-blue-600 bg-blue-50",
+                "category": "social",
+                "default_channels": ["email", "push", "inapp"],
+                "priority": "normal",
+                "sort_order": 9,
+            }
+        ),
+        # System related
+        RichChoice(
+            value="system_announcement",
+            label="System Announcement",
+            description="Important announcements from the ThrillWiki team",
+            metadata={
+                "color": "purple",
+                "icon": "megaphone",
+                "css_class": "text-purple-600 bg-purple-50",
+                "category": "system",
+                "default_channels": ["email", "inapp"],
+                "priority": "normal",
+                "sort_order": 10,
+            }
+        ),
+        RichChoice(
+            value="account_security",
+            label="Account Security",
+            description="Security-related notifications for user's account",
+            metadata={
+                "color": "red",
+                "icon": "shield-exclamation",
+                "css_class": "text-red-600 bg-red-50",
+                "category": "system",
+                "default_channels": ["email", "push", "inapp"],
+                "priority": "high",
+                "sort_order": 11,
+            }
+        ),
+        RichChoice(
+            value="feature_update",
+            label="Feature Update",
+            description="Notifications about new features and improvements",
+            metadata={
+                "color": "blue",
+                "icon": "sparkles",
+                "css_class": "text-blue-600 bg-blue-50",
+                "category": "system",
+                "default_channels": ["email", "inapp"],
+                "priority": "low",
+                "sort_order": 12,
+            }
+        ),
+        RichChoice(
+            value="maintenance",
+            label="Maintenance Notice",
+            description="Scheduled maintenance and downtime notifications",
+            metadata={
+                "color": "yellow",
+                "icon": "wrench",
+                "css_class": "text-yellow-600 bg-yellow-50",
+                "category": "system",
+                "default_channels": ["email", "inapp"],
+                "priority": "normal",
+                "sort_order": 13,
+            }
+        ),
+        # Achievement related
+        RichChoice(
+            value="achievement_unlocked",
+            label="Achievement Unlocked",
+            description="Notification when user unlocks a new achievement",
+            metadata={
+                "color": "gold",
+                "icon": "trophy",
+                "css_class": "text-yellow-600 bg-yellow-50",
+                "category": "achievement",
+                "default_channels": ["push", "inapp"],
+                "priority": "low",
+                "sort_order": 14,
+            }
+        ),
+        RichChoice(
+            value="milestone_reached",
+            label="Milestone Reached",
+            description="Notification when user reaches a significant milestone",
+            metadata={
+                "color": "purple",
+                "icon": "flag",
+                "css_class": "text-purple-600 bg-purple-50",
+                "category": "achievement",
+                "default_channels": ["push", "inapp"],
+                "priority": "low",
+                "sort_order": 15,
+            }
+        ),
+    ]
+)
+
+
+# =============================================================================
+# NOTIFICATION PRIORITIES
+# =============================================================================
+
+notification_priorities = ChoiceGroup(
+    name="notification_priorities",
+    choices=[
+        RichChoice(
+            value="low",
+            label="Low",
+            description="Low priority notifications that can be delayed or batched",
+            metadata={
+                "color": "gray",
+                "icon": "arrow-down",
+                "css_class": "text-gray-600 bg-gray-50",
+                "urgency_level": 1,
+                "batch_eligible": True,
+                "delay_minutes": 60,
+                "sort_order": 1,
+            }
+        ),
+        RichChoice(
+            value="normal",
+            label="Normal",
+            description="Standard priority notifications sent in regular intervals",
+            metadata={
+                "color": "blue",
+                "icon": "minus",
+                "css_class": "text-blue-600 bg-blue-50",
+                "urgency_level": 2,
+                "batch_eligible": True,
+                "delay_minutes": 15,
+                "sort_order": 2,
+            }
+        ),
+        RichChoice(
+            value="high",
+            label="High",
+            description="High priority notifications sent immediately",
+            metadata={
+                "color": "orange",
+                "icon": "arrow-up",
+                "css_class": "text-orange-600 bg-orange-50",
+                "urgency_level": 3,
+                "batch_eligible": False,
+                "delay_minutes": 0,
+                "sort_order": 3,
+            }
+        ),
+        RichChoice(
+            value="urgent",
+            label="Urgent",
+            description="Critical notifications requiring immediate attention",
+            metadata={
+                "color": "red",
+                "icon": "exclamation",
+                "css_class": "text-red-600 bg-red-50",
+                "urgency_level": 4,
+                "batch_eligible": False,
+                "delay_minutes": 0,
+                "bypass_preferences": True,
+                "sort_order": 4,
+            }
+        ),
+    ]
+)
+
+
+# =============================================================================
+# REGISTER ALL CHOICE GROUPS
+# =============================================================================
+
+# Register each choice group individually
+register_choices("user_roles", user_roles.choices, "accounts", "User role classifications")
+register_choices("theme_preferences", theme_preferences.choices, "accounts", "Theme preference options")
+register_choices("privacy_levels", privacy_levels.choices, "accounts", "Privacy level settings")
+register_choices("top_list_categories", top_list_categories.choices, "accounts", "Top list category types")
+register_choices("notification_types", notification_types.choices, "accounts", "Notification type classifications")
+register_choices("notification_priorities", notification_priorities.choices, "accounts", "Notification priority levels")

apps/accounts/management/commands/setup_groups.py

@@ -15,17 +15,17 @@ class Command(BaseCommand):
             create_default_groups()
 
             # Sync existing users with groups based on their roles
-            users = User.objects.exclude(role=User.Roles.USER)
+            users = User.objects.exclude(role="USER")
             for user in users:
                 group = Group.objects.filter(name=user.role).first()
                 if group:
                     user.groups.add(group)
 
                     # Update staff/superuser status based on role
-                    if user.role == User.Roles.SUPERUSER:
+                    if user.role == "SUPERUSER":
                         user.is_superuser = True
                         user.is_staff = True
-                    elif user.role in [User.Roles.ADMIN, User.Roles.MODERATOR]:
+                    elif user.role in ["ADMIN", "MODERATOR"]:
                         user.is_staff = True
                     user.save()
 

apps/accounts/management/commands/setup_social_auth_admin.py

@@ -41,7 +41,7 @@ class Command(BaseCommand):
 Social auth setup instructions:
 
 1. Run the development server:
-   python manage.py runserver
+   uv run manage.py runserver_plus
 
 2. Go to the admin interface:
    http://localhost:8000/admin/

apps/accounts/migrations/0002_remove_userprofile_insert_insert_and_more.py

@@ -0,0 +1,76 @@
+# Generated by Django 5.2.6 on 2025-09-21 01:29
+
+import django.db.models.deletion
+import pgtrigger.compiler
+import pgtrigger.migrations
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("accounts", "0001_initial"),
+    ]
+
+    operations = [
+        pgtrigger.migrations.RemoveTrigger(
+            model_name="userprofile",
+            name="insert_insert",
+        ),
+        pgtrigger.migrations.RemoveTrigger(
+            model_name="userprofile",
+            name="update_update",
+        ),
+        migrations.AddField(
+            model_name="userprofile",
+            name="avatar",
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.SET_NULL,
+                to="django_cloudflareimages_toolkit.cloudflareimage",
+            ),
+        ),
+        migrations.AddField(
+            model_name="userprofileevent",
+            name="avatar",
+            field=models.ForeignKey(
+                blank=True,
+                db_constraint=False,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                related_query_name="+",
+                to="django_cloudflareimages_toolkit.cloudflareimage",
+            ),
+        ),
+        pgtrigger.migrations.AddTrigger(
+            model_name="userprofile",
+            trigger=pgtrigger.compiler.Trigger(
+                name="insert_insert",
+                sql=pgtrigger.compiler.UpsertTriggerSql(
+                    func='INSERT INTO "accounts_userprofileevent" ("avatar_id", "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_id", 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="a7ecdb1ac2821dea1fef4ec917eeaf6b8e4f09c8",
+                    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_id", "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_id", 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="81607e492ffea2a4c741452b860ee660374cc01d",
+                    operation="UPDATE",
+                    pgid="pgtrigger_update_update_87ef6",
+                    table="accounts_userprofile",
+                    when="AFTER",
+                ),
+            ),
+        ),
+    ]

apps/accounts/models.py

@@ -9,6 +9,7 @@ import secrets
 from datetime import timedelta
 from django.utils import timezone
 from apps.core.history import TrackedModel
+from apps.core.choices import RichChoiceField
 import pghistory
 
 
@@ -28,21 +29,6 @@ def generate_random_id(model_class, id_field):
 
 @pghistory.track()
 class User(AbstractUser):
-    class Roles(models.TextChoices):
-        USER = "USER", _("User")
-        MODERATOR = "MODERATOR", _("Moderator")
-        ADMIN = "ADMIN", _("Admin")
-        SUPERUSER = "SUPERUSER", _("Superuser")
-
-    class ThemePreference(models.TextChoices):
-        LIGHT = "light", _("Light")
-        DARK = "dark", _("Dark")
-
-    class PrivacyLevel(models.TextChoices):
-        PUBLIC = "public", _("Public")
-        FRIENDS = "friends", _("Friends Only")
-        PRIVATE = "private", _("Private")
-
     # Override inherited fields to remove them
     first_name = None
     last_name = None
@@ -58,19 +44,21 @@ class User(AbstractUser):
         ),
     )
 
-    role = models.CharField(
+    role = RichChoiceField(
+        choice_group="user_roles",
+        domain="accounts",
         max_length=10,
-        choices=Roles.choices,
+        default="USER",
-        default=Roles.USER,
     )
     is_banned = models.BooleanField(default=False)
     ban_reason = models.TextField(blank=True)
     ban_date = models.DateTimeField(null=True, blank=True)
     pending_email = models.EmailField(blank=True, null=True)
-    theme_preference = models.CharField(
+    theme_preference = RichChoiceField(
+        choice_group="theme_preferences",
+        domain="accounts",
         max_length=5,
-        choices=ThemePreference.choices,
+        default="light",
-        default=ThemePreference.LIGHT,
     )
 
     # Notification preferences
@@ -78,10 +66,11 @@ class User(AbstractUser):
     push_notifications = models.BooleanField(default=False)
 
     # Privacy settings
-    privacy_level = models.CharField(
+    privacy_level = RichChoiceField(
+        choice_group="privacy_levels",
+        domain="accounts",
         max_length=10,
-        choices=PrivacyLevel.choices,
+        default="public",
-        default=PrivacyLevel.PUBLIC,
     )
     show_email = models.BooleanField(default=False)
     show_real_name = models.BooleanField(default=True)
@@ -94,10 +83,11 @@ class User(AbstractUser):
     allow_messages = models.BooleanField(default=True)
     allow_profile_comments = models.BooleanField(default=False)
     search_visibility = models.BooleanField(default=True)
-    activity_visibility = models.CharField(
+    activity_visibility = RichChoiceField(
+        choice_group="privacy_levels",
+        domain="accounts",
         max_length=10,
-        choices=PrivacyLevel.choices,
+        default="friends",
-        default=PrivacyLevel.FRIENDS,
     )
 
     # Security settings
@@ -131,10 +121,6 @@ class User(AbstractUser):
         """Get the user's display name, falling back to username if not set"""
         if self.display_name:
             return self.display_name
-        # Fallback to profile display_name for backward compatibility
-        profile = getattr(self, "profile", None)
-        if profile and profile.display_name:
-            return profile.display_name
         return self.username
 
     def save(self, *args, **kwargs):
@@ -298,20 +284,17 @@ class PasswordReset(models.Model):
 
 
 class TopList(TrackedModel):
-    class Categories(models.TextChoices):
-        ROLLER_COASTER = "RC", _("Roller Coaster")
-        DARK_RIDE = "DR", _("Dark Ride")
-        FLAT_RIDE = "FR", _("Flat Ride")
-        WATER_RIDE = "WR", _("Water Ride")
-        PARK = "PK", _("Park")
-
     user = models.ForeignKey(
         User,
         on_delete=models.CASCADE,
         related_name="top_lists",  # Added related_name for User model access
     )
     title = models.CharField(max_length=100)
-    category = models.CharField(max_length=2, choices=Categories.choices)
+    category = RichChoiceField(
+        choice_group="top_list_categories",
+        domain="accounts",
+        max_length=2,
+    )
     description = models.TextField(blank=True)
     created_at = models.DateTimeField(auto_now_add=True)
     updated_at = models.DateTimeField(auto_now=True)
@@ -462,45 +445,15 @@ class UserNotification(TrackedModel):
     and other user-relevant notifications.
     """
 
-    class NotificationType(models.TextChoices):
-        # Submission related
-        SUBMISSION_APPROVED = "submission_approved", _("Submission Approved")
-        SUBMISSION_REJECTED = "submission_rejected", _("Submission Rejected")
-        SUBMISSION_PENDING = "submission_pending", _("Submission Pending Review")
-
-        # Review related
-        REVIEW_REPLY = "review_reply", _("Review Reply")
-        REVIEW_HELPFUL = "review_helpful", _("Review Marked Helpful")
-
-        # Social related
-        FRIEND_REQUEST = "friend_request", _("Friend Request")
-        FRIEND_ACCEPTED = "friend_accepted", _("Friend Request Accepted")
-        MESSAGE_RECEIVED = "message_received", _("Message Received")
-        PROFILE_COMMENT = "profile_comment", _("Profile Comment")
-
-        # System related
-        SYSTEM_ANNOUNCEMENT = "system_announcement", _("System Announcement")
-        ACCOUNT_SECURITY = "account_security", _("Account Security")
-        FEATURE_UPDATE = "feature_update", _("Feature Update")
-        MAINTENANCE = "maintenance", _("Maintenance Notice")
-
-        # Achievement related
-        ACHIEVEMENT_UNLOCKED = "achievement_unlocked", _("Achievement Unlocked")
-        MILESTONE_REACHED = "milestone_reached", _("Milestone Reached")
-
-    class Priority(models.TextChoices):
-        LOW = "low", _("Low")
-        NORMAL = "normal", _("Normal")
-        HIGH = "high", _("High")
-        URGENT = "urgent", _("Urgent")
-
     # Core fields
     user = models.ForeignKey(
         User, on_delete=models.CASCADE, related_name="notifications"
     )
 
-    notification_type = models.CharField(
+    notification_type = RichChoiceField(
-        max_length=30, choices=NotificationType.choices
+        choice_group="notification_types",
+        domain="accounts",
+        max_length=30,
     )
 
     title = models.CharField(max_length=200)
@@ -514,8 +467,11 @@ class UserNotification(TrackedModel):
     related_object = GenericForeignKey("content_type", "object_id")
 
     # Metadata
-    priority = models.CharField(
+    priority = RichChoiceField(
-        max_length=10, choices=Priority.choices, default=Priority.NORMAL
+        choice_group="notification_priorities",
+        domain="accounts",
+        max_length=10,
+        default="normal",
     )
 
     # Status tracking
@@ -675,4 +631,6 @@ class NotificationPreference(TrackedModel):
 def create_notification_preference(sender, instance, created, **kwargs):
     """Create notification preferences when a new user is created."""
     if created:
-        NotificationPreference.objects.create(user=instance)
+        NotificationPreference.objects.get_or_create(user=instance)
+
+# Signal moved to signals.py to avoid duplication

apps/accounts/services.py

@@ -31,7 +31,7 @@ class UserDeletionService:
                 "is_active": False,
                 "is_staff": False,
                 "is_superuser": False,
-                "role": User.Roles.USER,
+                "role": "USER",
                 "is_banned": True,
                 "ban_reason": "System placeholder for deleted users",
                 "ban_date": timezone.now(),
@@ -178,7 +178,7 @@ class UserDeletionService:
             return False, "Superuser accounts cannot be deleted for security reasons. Please contact system administrator or remove superuser privileges first."
 
         # Check if user has critical admin role
-        if user.role == User.Roles.ADMIN and user.is_staff:
+        if user.role == "ADMIN" and user.is_staff:
             return False, "Admin accounts with staff privileges cannot be deleted. Please remove admin privileges first or contact system administrator."
 
         # Add any other business rules here

apps/accounts/signals.py

@@ -10,59 +10,41 @@ from .models import User, UserProfile
 
 @receiver(post_save, sender=User)
 def create_user_profile(sender, instance, created, **kwargs):
-    """Create UserProfile for new users"""
+    """Create UserProfile for new users - unified signal handler"""
-    try:
+    if created:
-        if created:
-            # Create profile
-            profile = UserProfile.objects.create(user=instance)
-
-            # If user has a social account with avatar, download it
-            social_account = instance.socialaccount_set.first()
-            if social_account:
-                extra_data = social_account.extra_data
-                avatar_url = None
-
-                if social_account.provider == "google":
-                    avatar_url = extra_data.get("picture")
-                elif social_account.provider == "discord":
-                    avatar = extra_data.get("avatar")
-                    discord_id = extra_data.get("id")
-                    if avatar:
-                        avatar_url = f"https://cdn.discordapp.com/avatars/{discord_id}/{avatar}.png"
-
-                if avatar_url:
-                    try:
-                        response = requests.get(avatar_url, timeout=60)
-                        if response.status_code == 200:
-                            img_temp = NamedTemporaryFile(delete=True)
-                            img_temp.write(response.content)
-                            img_temp.flush()
-
-                            file_name = f"avatar_{instance.username}.png"
-                            profile.avatar.save(file_name, File(img_temp), save=True)
-                    except Exception as e:
-                        print(
-                            f"Error downloading avatar for user {instance.username}: {
-                                str(e)
-                            }"
-                        )
-    except Exception as e:
-        print(f"Error creating profile for user {instance.username}: {str(e)}")
-
-
-@receiver(post_save, sender=User)
-def save_user_profile(sender, instance, **kwargs):
-    """Ensure UserProfile exists and is saved"""
-    try:
-        # Try to get existing profile first
         try:
-            profile = instance.profile
+            # Use get_or_create to prevent duplicates
-            profile.save()
+            profile, profile_created = UserProfile.objects.get_or_create(user=instance)
-        except UserProfile.DoesNotExist:
+            
-            # Profile doesn't exist, create it
+            if profile_created:
-            UserProfile.objects.create(user=instance)
+                # If user has a social account with avatar, download it
-    except Exception as e:
+                try:
-        print(f"Error saving profile for user {instance.username}: {str(e)}")
+                    social_account = instance.socialaccount_set.first()
+                    if social_account:
+                        extra_data = social_account.extra_data
+                        avatar_url = None
+
+                        if social_account.provider == "google":
+                            avatar_url = extra_data.get("picture")
+                        elif social_account.provider == "discord":
+                            avatar = extra_data.get("avatar")
+                            discord_id = extra_data.get("id")
+                            if avatar:
+                                avatar_url = f"https://cdn.discordapp.com/avatars/{discord_id}/{avatar}.png"
+
+                        if avatar_url:
+                            response = requests.get(avatar_url, timeout=60)
+                            if response.status_code == 200:
+                                img_temp = NamedTemporaryFile(delete=True)
+                                img_temp.write(response.content)
+                                img_temp.flush()
+
+                                file_name = f"avatar_{instance.username}.png"
+                                profile.avatar.save(file_name, File(img_temp), save=True)
+                except Exception as e:
+                    print(f"Error downloading avatar for user {instance.username}: {str(e)}")
+        except Exception as e:
+            print(f"Error creating profile for user {instance.username}: {str(e)}")
 
 
 @receiver(pre_save, sender=User)
@@ -75,43 +57,43 @@ def sync_user_role_with_groups(sender, instance, **kwargs):
                 # Role has changed, update groups
                 with transaction.atomic():
                     # Remove from old role group if exists
-                    if old_instance.role != User.Roles.USER:
+                    if old_instance.role != "USER":
                         old_group = Group.objects.filter(name=old_instance.role).first()
                         if old_group:
                             instance.groups.remove(old_group)
 
                     # Add to new role group
-                    if instance.role != User.Roles.USER:
+                    if instance.role != "USER":
                         new_group, _ = Group.objects.get_or_create(name=instance.role)
                         instance.groups.add(new_group)
 
                         # Special handling for superuser role
-                        if instance.role == User.Roles.SUPERUSER:
+                        if instance.role == "SUPERUSER":
                             instance.is_superuser = True
                             instance.is_staff = True
-                        elif old_instance.role == User.Roles.SUPERUSER:
+                        elif old_instance.role == "SUPERUSER":
                             # If removing superuser role, remove superuser
                             # status
                             instance.is_superuser = False
                             if instance.role not in [
-                                User.Roles.ADMIN,
+                                "ADMIN",
-                                User.Roles.MODERATOR,
+                                "MODERATOR",
                             ]:
                                 instance.is_staff = False
 
                         # Handle staff status for admin and moderator roles
                         if instance.role in [
-                            User.Roles.ADMIN,
+                            "ADMIN",
-                            User.Roles.MODERATOR,
+                            "MODERATOR",
                         ]:
                             instance.is_staff = True
                         elif old_instance.role in [
-                            User.Roles.ADMIN,
+                            "ADMIN",
-                            User.Roles.MODERATOR,
+                            "MODERATOR",
                         ]:
                             # If removing admin/moderator role, remove staff
                             # status
-                            if instance.role not in [User.Roles.SUPERUSER]:
+                            if instance.role not in ["SUPERUSER"]:
                                 instance.is_staff = False
         except User.DoesNotExist:
             pass
@@ -130,7 +112,7 @@ def create_default_groups():
         from django.contrib.auth.models import Permission
 
         # Create Moderator group
-        moderator_group, _ = Group.objects.get_or_create(name=User.Roles.MODERATOR)
+        moderator_group, _ = Group.objects.get_or_create(name="MODERATOR")
         moderator_permissions = [
             # Review moderation permissions
             "change_review",
@@ -149,7 +131,7 @@ def create_default_groups():
         ]
 
         # Create Admin group
-        admin_group, _ = Group.objects.get_or_create(name=User.Roles.ADMIN)
+        admin_group, _ = Group.objects.get_or_create(name="ADMIN")
         admin_permissions = moderator_permissions + [
             # User management permissions
             "change_user",

apps/accounts/tests.py

@@ -109,7 +109,7 @@ class SignalsTestCase(TestCase):
 
         create_default_groups()
 
-        moderator_group = Group.objects.get(name=User.Roles.MODERATOR)
+        moderator_group = Group.objects.get(name="MODERATOR")
         self.assertIsNotNone(moderator_group)
         self.assertTrue(
             moderator_group.permissions.filter(codename="change_review").exists()
@@ -118,7 +118,7 @@ class SignalsTestCase(TestCase):
             moderator_group.permissions.filter(codename="change_user").exists()
         )
 
-        admin_group = Group.objects.get(name=User.Roles.ADMIN)
+        admin_group = Group.objects.get(name="ADMIN")
         self.assertIsNotNone(admin_group)
         self.assertTrue(
             admin_group.permissions.filter(codename="change_review").exists()

apps/accounts/tests/test_user_deletion.py

@@ -42,7 +42,7 @@ class UserDeletionServiceTest(TestCase):
         self.assertEqual(deleted_user.email, "deleted@thrillwiki.com")
         self.assertFalse(deleted_user.is_active)
         self.assertTrue(deleted_user.is_banned)
-        self.assertEqual(deleted_user.role, User.Roles.USER)
+        self.assertEqual(deleted_user.role, "USER")
 
         # Check profile was created
         self.assertTrue(hasattr(deleted_user, "profile"))

apps/core/__init__.py

@@ -0,0 +1,12 @@
+"""
+Core Django App
+
+This app handles core system functionality including health checks,
+system status, and other foundational features.
+"""
+
+# Import core choices to ensure they are registered with the global registry
+from .choices import core_choices
+
+# Ensure choices are registered on app startup
+__all__ = ['core_choices']

apps/core/choices/__init__.py

@@ -0,0 +1,32 @@
+"""
+Rich Choice Objects System
+
+This module provides a comprehensive system for managing choice fields throughout
+the ThrillWiki application. It replaces simple tuple-based choices with rich
+dataclass objects that support metadata, descriptions, categories, and deprecation.
+
+Key Components:
+- RichChoice: Base dataclass for choice objects
+- ChoiceRegistry: Centralized management of all choice definitions
+- RichChoiceField: Django model field for rich choices
+- RichChoiceSerializer: DRF serializer for API responses
+"""
+
+from .base import RichChoice, ChoiceCategory, ChoiceGroup
+from .registry import ChoiceRegistry, register_choices
+from .fields import RichChoiceField
+from .serializers import RichChoiceSerializer, RichChoiceOptionSerializer
+from .utils import validate_choice_value, get_choice_display
+
+__all__ = [
+    'RichChoice',
+    'ChoiceCategory',
+    'ChoiceGroup',
+    'ChoiceRegistry',
+    'register_choices',
+    'RichChoiceField',
+    'RichChoiceSerializer',
+    'RichChoiceOptionSerializer',
+    'validate_choice_value',
+    'get_choice_display',
+]

apps/core/choices/base.py

@@ -0,0 +1,154 @@
+"""
+Base Rich Choice Objects
+
+This module defines the core dataclass structures for rich choice objects.
+"""
+
+from dataclasses import dataclass, field
+from typing import Dict, Any, Optional
+from enum import Enum
+
+
+class ChoiceCategory(Enum):
+    """Categories for organizing choice types"""
+    STATUS = "status"
+    TYPE = "type"
+    CLASSIFICATION = "classification"
+    PREFERENCE = "preference"
+    PERMISSION = "permission"
+    PRIORITY = "priority"
+    ACTION = "action"
+    NOTIFICATION = "notification"
+    MODERATION = "moderation"
+    TECHNICAL = "technical"
+    BUSINESS = "business"
+    SECURITY = "security"
+    OTHER = "other"
+
+
+@dataclass(frozen=True)
+class RichChoice:
+    """
+    Rich choice object with metadata support.
+    
+    This replaces simple tuple choices with a comprehensive object that can
+    carry additional information like descriptions, colors, icons, and custom metadata.
+    
+    Attributes:
+        value: The stored value (equivalent to first element of tuple choice)
+        label: Human-readable display name (equivalent to second element of tuple choice)
+        description: Detailed description of what this choice means
+        metadata: Dictionary of additional properties (colors, icons, etc.)
+        deprecated: Whether this choice is deprecated and should not be used for new entries
+        category: Category for organizing related choices
+    """
+    value: str
+    label: str
+    description: str = ""
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    deprecated: bool = False
+    category: ChoiceCategory = ChoiceCategory.OTHER
+    
+    def __post_init__(self):
+        """Validate the choice object after initialization"""
+        if not self.value:
+            raise ValueError("Choice value cannot be empty")
+        if not self.label:
+            raise ValueError("Choice label cannot be empty")
+    
+    @property
+    def color(self) -> Optional[str]:
+        """Get the color from metadata if available"""
+        return self.metadata.get('color')
+    
+    @property
+    def icon(self) -> Optional[str]:
+        """Get the icon from metadata if available"""
+        return self.metadata.get('icon')
+    
+    @property
+    def css_class(self) -> Optional[str]:
+        """Get the CSS class from metadata if available"""
+        return self.metadata.get('css_class')
+    
+    @property
+    def sort_order(self) -> int:
+        """Get the sort order from metadata, defaulting to 0"""
+        return self.metadata.get('sort_order', 0)
+    
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary representation for API serialization"""
+        return {
+            'value': self.value,
+            'label': self.label,
+            'description': self.description,
+            'metadata': self.metadata,
+            'deprecated': self.deprecated,
+            'category': self.category.value,
+            'color': self.color,
+            'icon': self.icon,
+            'css_class': self.css_class,
+            'sort_order': self.sort_order,
+        }
+    
+    
+    def __str__(self) -> str:
+        return self.label
+    
+    def __repr__(self) -> str:
+        return f"RichChoice(value='{self.value}', label='{self.label}')"
+
+
+@dataclass
+class ChoiceGroup:
+    """
+    A group of related choices with shared metadata.
+    
+    This allows for organizing choices into logical groups with
+    common properties and behaviors.
+    """
+    name: str
+    choices: list[RichChoice]
+    description: str = ""
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    
+    def __post_init__(self):
+        """Validate the choice group after initialization"""
+        if not self.name:
+            raise ValueError("Choice group name cannot be empty")
+        if not self.choices:
+            raise ValueError("Choice group must contain at least one choice")
+        
+        # Validate that all choice values are unique within the group
+        values = [choice.value for choice in self.choices]
+        if len(values) != len(set(values)):
+            raise ValueError("All choice values within a group must be unique")
+    
+    def get_choice(self, value: str) -> Optional[RichChoice]:
+        """Get a choice by its value"""
+        for choice in self.choices:
+            if choice.value == value:
+                return choice
+        return None
+    
+    def get_choices_by_category(self, category: ChoiceCategory) -> list[RichChoice]:
+        """Get all choices in a specific category"""
+        return [choice for choice in self.choices if choice.category == category]
+    
+    def get_active_choices(self) -> list[RichChoice]:
+        """Get all non-deprecated choices"""
+        return [choice for choice in self.choices if not choice.deprecated]
+    
+    def to_tuple_choices(self) -> list[tuple[str, str]]:
+        """Convert to legacy tuple choices format"""
+        return [(choice.value, choice.label) for choice in self.choices]
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary representation for API serialization"""
+        return {
+            'name': self.name,
+            'description': self.description,
+            'metadata': self.metadata,
+            'choices': [choice.to_dict() for choice in self.choices]
+        }

apps/core/choices/core_choices.py

@@ -0,0 +1,158 @@
+"""
+Core System Rich Choice Objects
+
+This module defines all choice objects for core system functionality,
+including health checks, API statuses, and other system-level choices.
+"""
+
+from .base import RichChoice, ChoiceCategory
+from .registry import register_choices
+
+
+# Health Check Status Choices
+HEALTH_STATUSES = [
+    RichChoice(
+        value="healthy",
+        label="Healthy",
+        description="System is operating normally with no issues detected",
+        metadata={
+            'color': 'green',
+            'icon': 'check-circle',
+            'css_class': 'bg-green-100 text-green-800',
+            'sort_order': 1,
+            'http_status': 200
+        },
+        category=ChoiceCategory.STATUS
+    ),
+    RichChoice(
+        value="unhealthy",
+        label="Unhealthy",
+        description="System has detected issues that may affect functionality",
+        metadata={
+            'color': 'red',
+            'icon': 'x-circle',
+            'css_class': 'bg-red-100 text-red-800',
+            'sort_order': 2,
+            'http_status': 503
+        },
+        category=ChoiceCategory.STATUS
+    ),
+]
+
+# Simple Health Check Status Choices
+SIMPLE_HEALTH_STATUSES = [
+    RichChoice(
+        value="ok",
+        label="OK",
+        description="Basic health check passed",
+        metadata={
+            'color': 'green',
+            'icon': 'check',
+            'css_class': 'bg-green-100 text-green-800',
+            'sort_order': 1,
+            'http_status': 200
+        },
+        category=ChoiceCategory.STATUS
+    ),
+    RichChoice(
+        value="error",
+        label="Error",
+        description="Basic health check failed",
+        metadata={
+            'color': 'red',
+            'icon': 'x',
+            'css_class': 'bg-red-100 text-red-800',
+            'sort_order': 2,
+            'http_status': 500
+        },
+        category=ChoiceCategory.STATUS
+    ),
+]
+
+# Entity Type Choices for Search
+ENTITY_TYPES = [
+    RichChoice(
+        value="park",
+        label="Park",
+        description="Theme parks and amusement parks",
+        metadata={
+            'color': 'green',
+            'icon': 'map-pin',
+            'css_class': 'bg-green-100 text-green-800',
+            'sort_order': 1,
+            'search_weight': 1.0
+        },
+        category=ChoiceCategory.CLASSIFICATION
+    ),
+    RichChoice(
+        value="ride",
+        label="Ride",
+        description="Individual rides and attractions",
+        metadata={
+            'color': 'blue',
+            'icon': 'activity',
+            'css_class': 'bg-blue-100 text-blue-800',
+            'sort_order': 2,
+            'search_weight': 1.0
+        },
+        category=ChoiceCategory.CLASSIFICATION
+    ),
+    RichChoice(
+        value="company",
+        label="Company",
+        description="Manufacturers, operators, and designers",
+        metadata={
+            'color': 'purple',
+            'icon': 'building',
+            'css_class': 'bg-purple-100 text-purple-800',
+            'sort_order': 3,
+            'search_weight': 0.8
+        },
+        category=ChoiceCategory.CLASSIFICATION
+    ),
+    RichChoice(
+        value="user",
+        label="User",
+        description="User profiles and accounts",
+        metadata={
+            'color': 'orange',
+            'icon': 'user',
+            'css_class': 'bg-orange-100 text-orange-800',
+            'sort_order': 4,
+            'search_weight': 0.5
+        },
+        category=ChoiceCategory.CLASSIFICATION
+    ),
+]
+
+
+def register_core_choices():
+    """Register all core system choices with the global registry"""
+    
+    register_choices(
+        name="health_statuses",
+        choices=HEALTH_STATUSES,
+        domain="core",
+        description="Health check status options",
+        metadata={'domain': 'core', 'type': 'health_status'}
+    )
+    
+    register_choices(
+        name="simple_health_statuses",
+        choices=SIMPLE_HEALTH_STATUSES,
+        domain="core",
+        description="Simple health check status options",
+        metadata={'domain': 'core', 'type': 'simple_health_status'}
+    )
+    
+    register_choices(
+        name="entity_types",
+        choices=ENTITY_TYPES,
+        domain="core",
+        description="Entity type classifications for search functionality",
+        metadata={'domain': 'core', 'type': 'entity_type'}
+    )
+
+
+# Auto-register choices when module is imported
+register_core_choices()

apps/core/choices/fields.py

@@ -0,0 +1,198 @@
+"""
+Django Model Fields for Rich Choices
+
+This module provides Django model field implementations for rich choice objects.
+"""
+
+from typing import Any, Optional
+from django.db import models
+from django.core.exceptions import ValidationError
+from django.forms import ChoiceField
+from .base import RichChoice
+from .registry import registry
+
+
+class RichChoiceField(models.CharField):
+    """
+    Django model field for rich choice objects.
+    
+    This field stores the choice value as a CharField but provides
+    rich choice functionality through the registry system.
+    """
+    
+    def __init__(
+        self,
+        choice_group: str,
+        domain: str = "core",
+        max_length: int = 50,
+        allow_deprecated: bool = False,
+        **kwargs
+    ):
+        """
+        Initialize the RichChoiceField.
+        
+        Args:
+            choice_group: Name of the choice group in the registry
+            domain: Domain namespace for the choice group
+            max_length: Maximum length for the stored value
+            allow_deprecated: Whether to allow deprecated choices
+            **kwargs: Additional arguments passed to CharField
+        """
+        self.choice_group = choice_group
+        self.domain = domain
+        self.allow_deprecated = allow_deprecated
+        
+        # Set choices from registry for Django admin and forms
+        if self.allow_deprecated:
+            choices_list = registry.get_choices(choice_group, domain)
+        else:
+            choices_list = registry.get_active_choices(choice_group, domain)
+        
+        choices = [(choice.value, choice.label) for choice in choices_list]
+        
+        kwargs['choices'] = choices
+        kwargs['max_length'] = max_length
+        
+        super().__init__(**kwargs)
+    
+    def validate(self, value: Any, model_instance: Any) -> None:
+        """Validate the choice value"""
+        super().validate(value, model_instance)
+        
+        if value is None or value == '':
+            return
+        
+        # Check if choice exists in registry
+        choice = registry.get_choice(self.choice_group, value, self.domain)
+        if choice is None:
+            raise ValidationError(
+                f"'{value}' is not a valid choice for {self.choice_group}"
+            )
+        
+        # Check if deprecated choices are allowed
+        if choice.deprecated and not self.allow_deprecated:
+            raise ValidationError(
+                f"'{value}' is deprecated and cannot be used for new entries"
+            )
+    
+    def get_rich_choice(self, value: str) -> Optional[RichChoice]:
+        """Get the RichChoice object for a value"""
+        return registry.get_choice(self.choice_group, value, self.domain)
+    
+    def get_choice_display(self, value: str) -> str:
+        """Get the display label for a choice value"""
+        return registry.get_choice_display(self.choice_group, value, self.domain)
+    
+    def contribute_to_class(self, cls: Any, name: str, private_only: bool = False, **kwargs: Any) -> None:
+        """Add helper methods to the model class (signature compatible with Django Field)"""
+        super().contribute_to_class(cls, name, private_only=private_only, **kwargs)
+        
+        # Add get_FOO_rich_choice method
+        def get_rich_choice_method(instance):
+            value = getattr(instance, name)
+            return self.get_rich_choice(value) if value else None
+        
+        setattr(cls, f'get_{name}_rich_choice', get_rich_choice_method)
+        
+        # Add get_FOO_display method (Django provides this, but we enhance it)
+        def get_display_method(instance):
+            value = getattr(instance, name)
+            return self.get_choice_display(value) if value else ''
+        
+        setattr(cls, f'get_{name}_display', get_display_method)
+    
+    def deconstruct(self):
+        """Support for Django migrations"""
+        name, path, args, kwargs = super().deconstruct()
+        kwargs['choice_group'] = self.choice_group
+        kwargs['domain'] = self.domain
+        kwargs['allow_deprecated'] = self.allow_deprecated
+        return name, path, args, kwargs
+
+
+class RichChoiceFormField(ChoiceField):
+    """
+    Form field for rich choices with enhanced functionality.
+    """
+    
+    def __init__(
+        self,
+        choice_group: str,
+        domain: str = "core",
+        allow_deprecated: bool = False,
+        show_descriptions: bool = False,
+        **kwargs
+    ):
+        """
+        Initialize the form field.
+        
+        Args:
+            choice_group: Name of the choice group in the registry
+            domain: Domain namespace for the choice group
+            allow_deprecated: Whether to allow deprecated choices
+            show_descriptions: Whether to show descriptions in choice labels
+            **kwargs: Additional arguments passed to ChoiceField
+        """
+        self.choice_group = choice_group
+        self.domain = domain
+        self.allow_deprecated = allow_deprecated
+        self.show_descriptions = show_descriptions
+        
+        # Get choices from registry
+        if allow_deprecated:
+            choices_list = registry.get_choices(choice_group, domain)
+        else:
+            choices_list = registry.get_active_choices(choice_group, domain)
+        
+        # Format choices for display
+        choices = []
+        for choice in choices_list:
+            label = choice.label
+            if show_descriptions and choice.description:
+                label = f"{choice.label} - {choice.description}"
+            choices.append((choice.value, label))
+        
+        kwargs['choices'] = choices
+        super().__init__(**kwargs)
+    
+    def validate(self, value: Any) -> None:
+        """Validate the choice value"""
+        super().validate(value)
+        
+        if value is None or value == '':
+            return
+        
+        # Check if choice exists in registry
+        choice = registry.get_choice(self.choice_group, value, self.domain)
+        if choice is None:
+            raise ValidationError(
+                f"'{value}' is not a valid choice for {self.choice_group}"
+            )
+        
+        # Check if deprecated choices are allowed
+        if choice.deprecated and not self.allow_deprecated:
+            raise ValidationError(
+                f"'{value}' is deprecated and cannot be used"
+            )
+
+
+def create_rich_choice_field(
+    choice_group: str,
+    domain: str = "core",
+    max_length: int = 50,
+    allow_deprecated: bool = False,
+    **kwargs
+) -> RichChoiceField:
+    """
+    Factory function to create a RichChoiceField.
+    
+    This is useful for creating fields with consistent settings
+    across multiple models.
+    """
+    return RichChoiceField(
+        choice_group=choice_group,
+        domain=domain,
+        max_length=max_length,
+        allow_deprecated=allow_deprecated,
+        **kwargs
+    )

apps/core/choices/registry.py

@@ -0,0 +1,197 @@
+"""
+Choice Registry
+
+Centralized registry for managing all choice definitions across the application.
+"""
+
+from typing import Dict, List, Optional, Any
+from django.core.exceptions import ImproperlyConfigured
+from .base import RichChoice, ChoiceGroup
+
+
+class ChoiceRegistry:
+    """
+    Centralized registry for managing all choice definitions.
+    
+    This provides a single source of truth for all choice objects
+    throughout the application, with support for namespacing by domain.
+    """
+    
+    def __init__(self):
+        self._choices: Dict[str, ChoiceGroup] = {}
+        self._domains: Dict[str, List[str]] = {}
+    
+    def register(
+        self, 
+        name: str, 
+        choices: List[RichChoice], 
+        domain: str = "core",
+        description: str = "",
+        metadata: Optional[Dict[str, Any]] = None
+    ) -> ChoiceGroup:
+        """
+        Register a group of choices.
+        
+        Args:
+            name: Unique name for the choice group
+            choices: List of RichChoice objects
+            domain: Domain namespace (e.g., 'rides', 'parks', 'accounts')
+            description: Description of the choice group
+            metadata: Additional metadata for the group
+            
+        Returns:
+            The registered ChoiceGroup
+            
+        Raises:
+            ImproperlyConfigured: If name is already registered with different choices
+        """
+        full_name = f"{domain}.{name}"
+        
+        if full_name in self._choices:
+            # Check if the existing registration is identical
+            existing_group = self._choices[full_name]
+            existing_values = [choice.value for choice in existing_group.choices]
+            new_values = [choice.value for choice in choices]
+            
+            if existing_values == new_values:
+                # Same choices, return existing group (allow duplicate registration)
+                return existing_group
+            else:
+                # Different choices, this is an error
+                raise ImproperlyConfigured(
+                    f"Choice group '{full_name}' is already registered with different choices. "
+                    f"Existing: {existing_values}, New: {new_values}"
+                )
+        
+        choice_group = ChoiceGroup(
+            name=full_name,
+            choices=choices,
+            description=description,
+            metadata=metadata or {}
+        )
+        
+        self._choices[full_name] = choice_group
+        
+        # Track domain
+        if domain not in self._domains:
+            self._domains[domain] = []
+        self._domains[domain].append(name)
+        
+        return choice_group
+    
+    def get(self, name: str, domain: str = "core") -> Optional[ChoiceGroup]:
+        """Get a choice group by name and domain"""
+        full_name = f"{domain}.{name}"
+        return self._choices.get(full_name)
+    
+    def get_choice(self, group_name: str, value: str, domain: str = "core") -> Optional[RichChoice]:
+        """Get a specific choice by group name, value, and domain"""
+        choice_group = self.get(group_name, domain)
+        if choice_group:
+            return choice_group.get_choice(value)
+        return None
+    
+    def get_choices(self, name: str, domain: str = "core") -> List[RichChoice]:
+        """Get all choices in a group"""
+        choice_group = self.get(name, domain)
+        return choice_group.choices if choice_group else []
+    
+    def get_active_choices(self, name: str, domain: str = "core") -> List[RichChoice]:
+        """Get all non-deprecated choices in a group"""
+        choice_group = self.get(name, domain)
+        return choice_group.get_active_choices() if choice_group else []
+    
+    
+    def get_domains(self) -> List[str]:
+        """Get all registered domains"""
+        return list(self._domains.keys())
+    
+    def get_domain_choices(self, domain: str) -> Dict[str, ChoiceGroup]:
+        """Get all choice groups for a specific domain"""
+        if domain not in self._domains:
+            return {}
+        
+        return {
+            name: self._choices[f"{domain}.{name}"]
+            for name in self._domains[domain]
+        }
+    
+    def list_all(self) -> Dict[str, ChoiceGroup]:
+        """Get all registered choice groups"""
+        return self._choices.copy()
+    
+    def validate_choice(self, group_name: str, value: str, domain: str = "core") -> bool:
+        """Validate that a choice value exists in a group"""
+        choice = self.get_choice(group_name, value, domain)
+        return choice is not None and not choice.deprecated
+    
+    def get_choice_display(self, group_name: str, value: str, domain: str = "core") -> str:
+        """Get the display label for a choice value"""
+        choice = self.get_choice(group_name, value, domain)
+        if choice:
+            return choice.label
+        else:
+            raise ValueError(f"Choice value '{value}' not found in group '{group_name}' for domain '{domain}'")
+    
+    def clear_domain(self, domain: str) -> None:
+        """Clear all choices for a specific domain (useful for testing)"""
+        if domain in self._domains:
+            for name in self._domains[domain]:
+                full_name = f"{domain}.{name}"
+                if full_name in self._choices:
+                    del self._choices[full_name]
+            del self._domains[domain]
+    
+    def clear_all(self) -> None:
+        """Clear all registered choices (useful for testing)"""
+        self._choices.clear()
+        self._domains.clear()
+
+
+# Global registry instance
+registry = ChoiceRegistry()
+
+
+def register_choices(
+    name: str,
+    choices: List[RichChoice],
+    domain: str = "core",
+    description: str = "",
+    metadata: Optional[Dict[str, Any]] = None
+) -> ChoiceGroup:
+    """
+    Convenience function to register choices with the global registry.
+    
+    Args:
+        name: Unique name for the choice group
+        choices: List of RichChoice objects
+        domain: Domain namespace
+        description: Description of the choice group
+        metadata: Additional metadata for the group
+        
+    Returns:
+        The registered ChoiceGroup
+    """
+    return registry.register(name, choices, domain, description, metadata)
+
+
+def get_choices(name: str, domain: str = "core") -> List[RichChoice]:
+    """Get choices from the global registry"""
+    return registry.get_choices(name, domain)
+
+
+def get_choice(group_name: str, value: str, domain: str = "core") -> Optional[RichChoice]:
+    """Get a specific choice from the global registry"""
+    return registry.get_choice(group_name, value, domain)
+
+
+
+
+def validate_choice(group_name: str, value: str, domain: str = "core") -> bool:
+    """Validate a choice value using the global registry"""
+    return registry.validate_choice(group_name, value, domain)
+
+
+def get_choice_display(group_name: str, value: str, domain: str = "core") -> str:
+    """Get choice display label using the global registry"""
+    return registry.get_choice_display(group_name, value, domain)

apps/core/choices/serializers.py

@@ -0,0 +1,275 @@
+"""
+DRF Serializers for Rich Choices
+
+This module provides Django REST Framework serializer implementations
+for rich choice objects.
+"""
+
+from typing import Any, Dict, List
+from rest_framework import serializers
+from .base import RichChoice, ChoiceGroup
+from .registry import registry
+
+
+class RichChoiceSerializer(serializers.Serializer):
+    """
+    Serializer for individual RichChoice objects.
+    
+    This provides a consistent API representation for choice objects
+    with all their metadata.
+    """
+    value = serializers.CharField()
+    label = serializers.CharField()
+    description = serializers.CharField()
+    metadata = serializers.DictField()
+    deprecated = serializers.BooleanField()
+    category = serializers.CharField()
+    color = serializers.CharField(allow_null=True)
+    icon = serializers.CharField(allow_null=True)
+    css_class = serializers.CharField(allow_null=True)
+    sort_order = serializers.IntegerField()
+    
+    def to_representation(self, instance: RichChoice) -> Dict[str, Any]:
+        """Convert RichChoice to dictionary representation"""
+        return instance.to_dict()
+
+
+class RichChoiceOptionSerializer(serializers.Serializer):
+    """
+    Serializer for choice options in filter endpoints.
+    
+    This replaces the legacy FilterOptionSerializer with rich choice support.
+    """
+    value = serializers.CharField()
+    label = serializers.CharField()
+    description = serializers.CharField(allow_blank=True)
+    count = serializers.IntegerField(required=False, allow_null=True)
+    selected = serializers.BooleanField(default=False)
+    deprecated = serializers.BooleanField(default=False)
+    color = serializers.CharField(allow_null=True, required=False)
+    icon = serializers.CharField(allow_null=True, required=False)
+    css_class = serializers.CharField(allow_null=True, required=False)
+    metadata = serializers.DictField(required=False)
+    
+    def to_representation(self, instance) -> Dict[str, Any]:
+        """Convert choice option to dictionary representation"""
+        if isinstance(instance, RichChoice):
+            # Convert RichChoice to option format
+            return {
+                'value': instance.value,
+                'label': instance.label,
+                'description': instance.description,
+                'count': None,
+                'selected': False,
+                'deprecated': instance.deprecated,
+                'color': instance.color,
+                'icon': instance.icon,
+                'css_class': instance.css_class,
+                'metadata': instance.metadata,
+            }
+        elif isinstance(instance, dict):
+            # Handle dictionary input (for backwards compatibility)
+            return {
+                'value': instance.get('value', ''),
+                'label': instance.get('label', ''),
+                'description': instance.get('description', ''),
+                'count': instance.get('count'),
+                'selected': instance.get('selected', False),
+                'deprecated': instance.get('deprecated', False),
+                'color': instance.get('color'),
+                'icon': instance.get('icon'),
+                'css_class': instance.get('css_class'),
+                'metadata': instance.get('metadata', {}),
+            }
+        else:
+            return super().to_representation(instance)
+
+
+class ChoiceGroupSerializer(serializers.Serializer):
+    """
+    Serializer for ChoiceGroup objects.
+    
+    This provides API representation for entire choice groups
+    with all their choices and metadata.
+    """
+    name = serializers.CharField()
+    description = serializers.CharField()
+    metadata = serializers.DictField()
+    choices = RichChoiceSerializer(many=True)
+    
+    def to_representation(self, instance: ChoiceGroup) -> Dict[str, Any]:
+        """Convert ChoiceGroup to dictionary representation"""
+        return instance.to_dict()
+
+
+class RichChoiceFieldSerializer(serializers.CharField):
+    """
+    Serializer field for rich choice values.
+    
+    This field serializes the choice value but can optionally
+    include rich choice metadata in the response.
+    """
+    
+    def __init__(
+        self,
+        choice_group: str,
+        domain: str = "core",
+        include_metadata: bool = False,
+        **kwargs
+    ):
+        """
+        Initialize the serializer field.
+        
+        Args:
+            choice_group: Name of the choice group in the registry
+            domain: Domain namespace for the choice group
+            include_metadata: Whether to include rich choice metadata
+            **kwargs: Additional arguments passed to CharField
+        """
+        self.choice_group = choice_group
+        self.domain = domain
+        self.include_metadata = include_metadata
+        super().__init__(**kwargs)
+    
+    def to_representation(self, value: str) -> Any:
+        """Convert choice value to representation"""
+        if not value:
+            return value
+        
+        if self.include_metadata:
+            # Return rich choice object
+            choice = registry.get_choice(self.choice_group, value, self.domain)
+            if choice:
+                return RichChoiceSerializer(choice).data
+            else:
+                # Fallback for unknown values
+                return {
+                    'value': value,
+                    'label': value,
+                    'description': '',
+                    'metadata': {},
+                    'deprecated': False,
+                    'category': 'other',
+                    'color': None,
+                    'icon': None,
+                    'css_class': None,
+                    'sort_order': 0,
+                }
+        else:
+            # Return just the value
+            return value
+    
+    def to_internal_value(self, data: Any) -> str:
+        """Convert input data to choice value"""
+        if isinstance(data, dict) and 'value' in data:
+            # Handle rich choice object input
+            return data['value']
+        else:
+            # Handle string input
+            return super().to_internal_value(data)
+
+
+def create_choice_options_serializer(
+    choice_group: str,
+    domain: str = "core",
+    include_counts: bool = False,
+    queryset=None,
+    count_field: str = 'id'
+) -> List[Dict[str, Any]]:
+    """
+    Create choice options for filter endpoints.
+    
+    This function generates choice options with optional counts
+    for use in filter metadata endpoints.
+    
+    Args:
+        choice_group: Name of the choice group in the registry
+        domain: Domain namespace for the choice group
+        include_counts: Whether to include counts for each option
+        queryset: QuerySet to count against (required if include_counts=True)
+        count_field: Field to filter on for counting (default: 'id')
+        
+    Returns:
+        List of choice option dictionaries
+    """
+    choices = registry.get_active_choices(choice_group, domain)
+    options = []
+    
+    for choice in choices:
+        option_data = {
+            'value': choice.value,
+            'label': choice.label,
+            'description': choice.description,
+            'selected': False,
+            'deprecated': choice.deprecated,
+            'color': choice.color,
+            'icon': choice.icon,
+            'css_class': choice.css_class,
+            'metadata': choice.metadata,
+        }
+        
+        if include_counts and queryset is not None:
+            # Count items for this choice
+            try:
+                count = queryset.filter(**{count_field: choice.value}).count()
+                option_data['count'] = count
+            except Exception:
+                # If counting fails, set count to None
+                option_data['count'] = None
+        else:
+            option_data['count'] = None
+        
+        options.append(option_data)
+    
+    # Sort by sort_order, then by label
+    options.sort(key=lambda x: (
+        (lambda c: c.sort_order if (c is not None and hasattr(c, 'sort_order')) else 0)(
+            registry.get_choice(choice_group, x['value'], domain)
+        ),
+         x['label']
+     ))
+    
+    return options
+
+
+def serialize_choice_value(
+    value: str,
+    choice_group: str,
+    domain: str = "core",
+    include_metadata: bool = False
+) -> Any:
+    """
+    Serialize a single choice value.
+    
+    Args:
+        value: The choice value to serialize
+        choice_group: Name of the choice group in the registry
+        domain: Domain namespace for the choice group
+        include_metadata: Whether to include rich choice metadata
+        
+    Returns:
+        Serialized choice value (string or rich object)
+    """
+    if not value:
+        return value
+    
+    if include_metadata:
+        choice = registry.get_choice(choice_group, value, domain)
+        if choice:
+            return RichChoiceSerializer(choice).data
+        else:
+            # Fallback for unknown values
+            return {
+                'value': value,
+                'label': value,
+                'description': '',
+                'metadata': {},
+                'deprecated': False,
+                'category': 'other',
+                'color': None,
+                'icon': None,
+                'css_class': None,
+                'sort_order': 0,
+            }
+    else:
+        return value

apps/core/choices/utils.py

@@ -0,0 +1,318 @@
+"""
+Utility Functions for Rich Choices
+
+This module provides utility functions for working with rich choice objects.
+"""
+
+from typing import Any, Dict, List, Optional, Tuple
+from .base import RichChoice, ChoiceCategory
+from .registry import registry
+
+
+def validate_choice_value(
+    value: str,
+    choice_group: str,
+    domain: str = "core",
+    allow_deprecated: bool = False
+) -> bool:
+    """
+    Validate that a choice value is valid for a given choice group.
+    
+    Args:
+        value: The choice value to validate
+        choice_group: Name of the choice group in the registry
+        domain: Domain namespace for the choice group
+        allow_deprecated: Whether to allow deprecated choices
+        
+    Returns:
+        True if valid, False otherwise
+    """
+    if not value:
+        return True  # Allow empty values (handled by field's null/blank settings)
+    
+    choice = registry.get_choice(choice_group, value, domain)
+    if choice is None:
+        return False
+    
+    if choice.deprecated and not allow_deprecated:
+        return False
+    
+    return True
+
+
+def get_choice_display(
+    value: str,
+    choice_group: str,
+    domain: str = "core"
+) -> str:
+    """
+    Get the display label for a choice value.
+    
+    Args:
+        value: The choice value
+        choice_group: Name of the choice group in the registry
+        domain: Domain namespace for the choice group
+        
+    Returns:
+        Display label for the choice
+        
+    Raises:
+        ValueError: If the choice value is not found in the registry
+    """
+    if not value:
+        return ""
+    
+    choice = registry.get_choice(choice_group, value, domain)
+    if choice:
+        return choice.label
+    else:
+        raise ValueError(f"Choice value '{value}' not found in group '{choice_group}' for domain '{domain}'")
+
+
+
+
+def create_status_choices(
+    statuses: Dict[str, Dict[str, Any]],
+    category: ChoiceCategory = ChoiceCategory.STATUS
+) -> List[RichChoice]:
+    """
+    Create status choices with consistent color coding.
+    
+    Args:
+        statuses: Dictionary mapping status value to config dict
+        category: Choice category (defaults to STATUS)
+        
+    Returns:
+        List of RichChoice objects for statuses
+    """
+    choices = []
+    
+    for value, config in statuses.items():
+        metadata = config.get('metadata', {})
+        
+        # Add default status colors if not specified
+        if 'color' not in metadata:
+            if 'operating' in value.lower() or 'active' in value.lower():
+                metadata['color'] = 'green'
+            elif 'closed' in value.lower() or 'inactive' in value.lower():
+                metadata['color'] = 'red'
+            elif 'temp' in value.lower() or 'pending' in value.lower():
+                metadata['color'] = 'yellow'
+            elif 'construction' in value.lower():
+                metadata['color'] = 'blue'
+            else:
+                metadata['color'] = 'gray'
+        
+        choice = RichChoice(
+            value=value,
+            label=config['label'],
+            description=config.get('description', ''),
+            metadata=metadata,
+            deprecated=config.get('deprecated', False),
+            category=category
+        )
+        choices.append(choice)
+    
+    return choices
+
+
+def create_type_choices(
+    types: Dict[str, Dict[str, Any]],
+    category: ChoiceCategory = ChoiceCategory.TYPE
+) -> List[RichChoice]:
+    """
+    Create type/classification choices.
+    
+    Args:
+        types: Dictionary mapping type value to config dict
+        category: Choice category (defaults to TYPE)
+        
+    Returns:
+        List of RichChoice objects for types
+    """
+    choices = []
+    
+    for value, config in types.items():
+        choice = RichChoice(
+            value=value,
+            label=config['label'],
+            description=config.get('description', ''),
+            metadata=config.get('metadata', {}),
+            deprecated=config.get('deprecated', False),
+            category=category
+        )
+        choices.append(choice)
+    
+    return choices
+
+
+def merge_choice_metadata(
+    base_metadata: Dict[str, Any],
+    override_metadata: Dict[str, Any]
+) -> Dict[str, Any]:
+    """
+    Merge choice metadata dictionaries.
+    
+    Args:
+        base_metadata: Base metadata dictionary
+        override_metadata: Override metadata dictionary
+        
+    Returns:
+        Merged metadata dictionary
+    """
+    merged = base_metadata.copy()
+    merged.update(override_metadata)
+    return merged
+
+
+def filter_choices_by_category(
+    choices: List[RichChoice],
+    category: ChoiceCategory
+) -> List[RichChoice]:
+    """
+    Filter choices by category.
+    
+    Args:
+        choices: List of RichChoice objects
+        category: Category to filter by
+        
+    Returns:
+        Filtered list of choices
+    """
+    return [choice for choice in choices if choice.category == category]
+
+
+def sort_choices(
+    choices: List[RichChoice],
+    sort_by: str = "sort_order"
+) -> List[RichChoice]:
+    """
+    Sort choices by specified criteria.
+    
+    Args:
+        choices: List of RichChoice objects
+        sort_by: Sort criteria ("sort_order", "label", "value")
+        
+    Returns:
+        Sorted list of choices
+    """
+    if sort_by == "sort_order":
+        return sorted(choices, key=lambda x: (x.sort_order, x.label))
+    elif sort_by == "label":
+        return sorted(choices, key=lambda x: x.label)
+    elif sort_by == "value":
+        return sorted(choices, key=lambda x: x.value)
+    else:
+        return choices
+
+
+def get_choice_colors(
+    choice_group: str,
+    domain: str = "core"
+) -> Dict[str, str]:
+    """
+    Get a mapping of choice values to their colors.
+    
+    Args:
+        choice_group: Name of the choice group in the registry
+        domain: Domain namespace for the choice group
+        
+    Returns:
+        Dictionary mapping choice values to colors
+    """
+    choices = registry.get_choices(choice_group, domain)
+    return {
+        choice.value: choice.color
+        for choice in choices
+        if choice.color
+    }
+
+
+def validate_choice_group_data(
+    name: str,
+    choices: List[RichChoice],
+    domain: str = "core"
+) -> List[str]:
+    """
+    Validate choice group data and return list of errors.
+    
+    Args:
+        name: Choice group name
+        choices: List of RichChoice objects
+        domain: Domain namespace
+        
+    Returns:
+        List of validation error messages
+    """
+    errors = []
+    
+    if not name:
+        errors.append("Choice group name cannot be empty")
+    
+    if not choices:
+        errors.append("Choice group must contain at least one choice")
+        return errors
+    
+    # Check for duplicate values
+    values = [choice.value for choice in choices]
+    if len(values) != len(set(values)):
+        duplicates = [v for v in values if values.count(v) > 1]
+        errors.append(f"Duplicate choice values found: {', '.join(set(duplicates))}")
+    
+    # Validate individual choices
+    for i, choice in enumerate(choices):
+        try:
+            # This will trigger __post_init__ validation
+            RichChoice(
+                value=choice.value,
+                label=choice.label,
+                description=choice.description,
+                metadata=choice.metadata,
+                deprecated=choice.deprecated,
+                category=choice.category
+            )
+        except ValueError as e:
+            errors.append(f"Choice {i}: {str(e)}")
+    
+    return errors
+
+
+def create_choice_from_config(config: Dict[str, Any]) -> RichChoice:
+    """
+    Create a RichChoice from a configuration dictionary.
+    
+    Args:
+        config: Configuration dictionary with choice data
+        
+    Returns:
+        RichChoice object
+    """
+    return RichChoice(
+        value=config['value'],
+        label=config['label'],
+        description=config.get('description', ''),
+        metadata=config.get('metadata', {}),
+        deprecated=config.get('deprecated', False),
+        category=ChoiceCategory(config.get('category', 'other'))
+    )
+
+
+def export_choices_to_dict(
+    choice_group: str,
+    domain: str = "core"
+) -> Dict[str, Any]:
+    """
+    Export a choice group to a dictionary format.
+    
+    Args:
+        choice_group: Name of the choice group in the registry
+        domain: Domain namespace for the choice group
+        
+    Returns:
+        Dictionary representation of the choice group
+    """
+    group = registry.get(choice_group, domain)
+    if not group:
+        return {}
+    
+    return group.to_dict()

apps/core/management/commands/calculate_new_content.py

@@ -2,7 +2,7 @@
 Django management command to calculate new content.
 
 This replaces the Celery task for calculating new content.
-Run with: python manage.py calculate_new_content
+Run with: uv run manage.py calculate_new_content
 """
 
 import logging

apps/core/management/commands/calculate_trending.py

@@ -2,7 +2,7 @@
 Django management command to calculate trending content.
 
 This replaces the Celery task for calculating trending content.
-Run with: python manage.py calculate_trending
+Run with: uv run manage.py calculate_trending
 """
 
 import logging

apps/core/management/commands/setup_dev.py

@@ -94,7 +94,7 @@ class Command(BaseCommand):
         try:
             # Check if migrations are up to date
             result = subprocess.run(
-                [sys.executable, "manage.py", "migrate", "--check"],
+                ["uv", "run", "manage.py", "migrate", "--check"],
                 capture_output=True,
                 text=True,
             )
@@ -106,7 +106,7 @@ class Command(BaseCommand):
             else:
                 self.stdout.write("🔄 Running database migrations...")
                 subprocess.run(
-                    [sys.executable, "manage.py", "migrate", "--noinput"], check=True
+                    ["uv", "run", "manage.py", "migrate", "--noinput"], check=True
                 )
                 self.stdout.write(
                     self.style.SUCCESS("✅ Database migrations completed")
@@ -123,7 +123,7 @@ class Command(BaseCommand):
 
         try:
             subprocess.run(
-                [sys.executable, "manage.py", "seed_sample_data"], check=True
+                ["uv", "run", "manage.py", "seed_sample_data"], check=True
             )
             self.stdout.write(self.style.SUCCESS("✅ Sample data seeded"))
         except subprocess.CalledProcessError:
@@ -163,7 +163,7 @@ class Command(BaseCommand):
 
         try:
             subprocess.run(
-                [sys.executable, "manage.py", "collectstatic", "--noinput", "--clear"],
+                ["uv", "run", "manage.py", "collectstatic", "--noinput", "--clear"],
                 check=True,
             )
             self.stdout.write(self.style.SUCCESS("✅ Static files collected"))
@@ -182,7 +182,7 @@ class Command(BaseCommand):
 
             # Build Tailwind CSS
             subprocess.run(
-                [sys.executable, "manage.py", "tailwind", "build"], check=True
+                ["uv", "run", "manage.py", "tailwind", "build"], check=True
             )
             self.stdout.write(self.style.SUCCESS("✅ Tailwind CSS built"))
 
@@ -198,7 +198,7 @@ class Command(BaseCommand):
         self.stdout.write("🔍 Running system checks...")
 
         try:
-            subprocess.run([sys.executable, "manage.py", "check"], check=True)
+            subprocess.run(["uv", "run", "manage.py", "check"], check=True)
             self.stdout.write(self.style.SUCCESS("✅ System checks passed"))
         except subprocess.CalledProcessError:
             self.stdout.write(
@@ -220,5 +220,5 @@ class Command(BaseCommand):
         self.stdout.write("  - API Documentation: http://localhost:8000/api/docs/")
         self.stdout.write("")
         self.stdout.write("🌟 Ready to start development server with:")
-        self.stdout.write("   python manage.py runserver")
+        self.stdout.write("   uv run manage.py runserver_plus")
         self.stdout.write("")

apps/core/managers.py

@@ -6,8 +6,8 @@ Following Django styleguide best practices for database access.
 from typing import Optional, List, Union
 from django.db import models
 from django.db.models import Q, Count, Avg, Max
-from django.contrib.gis.geos import Point
+# from django.contrib.gis.geos import Point  # Disabled temporarily for setup
-from django.contrib.gis.measure import Distance
+# from django.contrib.gis.measure import Distance  # Disabled temporarily for setup
 from django.utils import timezone
 from datetime import timedelta
 
@@ -88,7 +88,7 @@ class BaseManager(models.Manager):
 class LocationQuerySet(BaseQuerySet):
     """QuerySet for location-based models with geographic functionality."""
 
-    def near_point(self, *, point: Point, distance_km: float = 50):
+    def near_point(self, *, point, distance_km: float = 50):  # Point type disabled for setup
         """Filter locations near a geographic point."""
         if hasattr(self.model, "point"):
             return (
@@ -134,7 +134,7 @@ class LocationManager(BaseManager):
     def get_queryset(self):
         return LocationQuerySet(self.model, using=self._db)
 
-    def near_point(self, *, point: Point, distance_km: float = 50):
+    def near_point(self, *, point, distance_km: float = 50):  # Point type disabled for setup
         return self.get_queryset().near_point(point=point, distance_km=distance_km)
 
     def within_bounds(self, *, north: float, south: float, east: float, west: float):