chore(cd): hardening of env settings

# Conflicts:
#	frontend/src/api/schema.d.ts
#	frontend/src/features/content/views/ContentItemDetailView.vue
#	frontend/src/features/workspaces/views/DashboardView.vue
#	shared/openapi/openapi.json

.gitea/workflows/deploy-socialize.yml

@@ -0,0 +1,75 @@
+name: deploy-socialize
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  image:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install Docker CLI
+        run: apt-get update && apt-get install -y docker.io
+      - name: Login to Gitea container registry
+        env:
+          REGISTRY_USER: ${{ secrets.REGISTRY_USER }}
+          REGISTRY_PASSWORD: ${{ secrets.REGISTRY_PASSWORD }}
+        run: printf '%s' "$REGISTRY_PASSWORD" | docker login git.mapachotes.com -u "$REGISTRY_USER" --password-stdin
+      - name: Build images
+        run: |
+          docker build \
+            -t git.mapachotes.com/jbourdon/socialize-api:${{ gitea.sha }} \
+            -t git.mapachotes.com/jbourdon/socialize-api:latest \
+            -f backend/src/Socialize.Api/Dockerfile .
+          docker build \
+            --build-arg VITE_API_URL=/ \
+            -t git.mapachotes.com/jbourdon/socialize-web:${{ gitea.sha }} \
+            -t git.mapachotes.com/jbourdon/socialize-web:latest \
+            -f frontend/Dockerfile .
+      - name: Push images
+        run: |
+          docker push git.mapachotes.com/jbourdon/socialize-api:${{ gitea.sha }}
+          docker push git.mapachotes.com/jbourdon/socialize-api:latest
+          docker push git.mapachotes.com/jbourdon/socialize-web:${{ gitea.sha }}
+          docker push git.mapachotes.com/jbourdon/socialize-web:latest
+
+  deploy:
+    needs: image
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install SSH client
+        run: apt-get update && apt-get install -y openssh-client
+      - name: Deploy on sobina
+        env:
+          DEPLOY_HOST: ${{ secrets.DEPLOY_HOST }}
+          DEPLOY_USER: ${{ secrets.DEPLOY_USER }}
+          DEPLOY_SSH_PRIVATE_KEY_B64: ${{ secrets.DEPLOY_SSH_PRIVATE_KEY_B64 }}
+          SOCIALIZE_IMAGE_TAG: ${{ gitea.sha }}
+        run: |
+          : "${SOCIALIZE_IMAGE_TAG:?SOCIALIZE_IMAGE_TAG is required}"
+
+          mkdir -p ~/.ssh
+          printf '%s' "$DEPLOY_SSH_PRIVATE_KEY_B64" | base64 -d > ~/.ssh/deploy_key
+          chmod 600 ~/.ssh/deploy_key
+
+          write_env_value() {
+            key="$1"
+            value="$2"
+            escaped_value="$(printf '%s' "$value" | sed "s/'/'\\\\''/g")"
+            printf "%s='%s'\n" "$key" "$escaped_value"
+          }
+
+          deploy_env="$(mktemp)"
+          {
+            write_env_value SOCIALIZE_IMAGE_TAG "$SOCIALIZE_IMAGE_TAG"
+          } > "$deploy_env"
+
+          scp -i ~/.ssh/deploy_key -o StrictHostKeyChecking=accept-new "$deploy_env" "$DEPLOY_USER@$DEPLOY_HOST:/srv/prod/socialize/.deploy.env"
+          rm -f "$deploy_env"
+          scp -i ~/.ssh/deploy_key -o StrictHostKeyChecking=accept-new deploy/compose.yml "$DEPLOY_USER@$DEPLOY_HOST:/srv/prod/socialize/compose.yml"
+
+          ssh -i ~/.ssh/deploy_key -o StrictHostKeyChecking=accept-new "$DEPLOY_USER@$DEPLOY_HOST" \
+            'test -r /etc/socialize/socialize.env && cd /srv/prod/socialize && ./deploy.sh'

.github/workflows/backend-ci.yml

@@ -1,39 +0,0 @@
-name: Backend CI/CD
-
-on:
-  push:
-    branches: 
-      - main
-
-env:
-  AZURE_WEBAPP_NAME: hutopy-backend-api
-  DOTNET_VERSION: '9.0.x'
-
-jobs:
-  build_and_deploy:
-    runs-on: ubuntu-latest
-    environment: dev
-    steps:
-
-      # Checkout the repository
-      - uses: actions/checkout@v2
-
-      # Setup .NET Core
-      - name: Setup .NET Core
-        uses: actions/setup-dotnet@v1
-        with:
-          dotnet-version: ${{ env.DOTNET_VERSION }}
-
-      # Run dotnet publish
-      - name: dotnet build and publish
-        run: |
-          cd backend
-          dotnet publish --configuration Release --artifacts-path ./publish/ backend.sln
-
-      # Deploy to Azure WebApp
-      - name: Deploy to Azure WebApp
-        uses: azure/webapps-deploy@v2
-        with:
-          app-name: ${{ env.AZURE_WEBAPP_NAME }} 
-          publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
-          package: './backend/publish/publish/Hutopy/release/'

.github/workflows/frontend-ci.yml

@@ -1,38 +0,0 @@
-name: Frontend CI/CD
-
-on:
-  push:
-    branches:
-      - main 
-
-env:
-  AZURE_SWA_NAME: hutopy-portal
-
-jobs:
-  build_and_deploy:
-    runs-on: ubuntu-latest
-    steps:
-      
-      # Checkout the repository
-      - uses: actions/checkout@v2
-     
-      # Npm install
-      - name: npm install
-        run: |
-          cd frontend
-          npm install
-      
-      # Npm run build
-      - name: npm run build
-        run: |
-          cd frontend
-          npm run build
-
-      # Deploy to Azure SWA
-      - name: Deploy to Azure SWA
-        uses: azure/static-web-apps-deploy@v1
-        with:
-          action: "upload"
-          app_location: 'frontend'
-          output_location: 'dist'
-          azure_static_web_apps_api_token: ${{ secrets.AZURE_SWA_TOKEN }}

.gitignore

@@ -19,13 +19,32 @@
 .DS_Store
 Thumbs.db
 
+# .NET
+bin/
+obj/
+**/[Bb]in/
+**/[Oo]bj/
+**/[Bb]in[\\]*
+**/[Oo]bj[\\]*
+TestResults/
+
+# Node
+node_modules/
+dist/
+.vite/
+
 # Local environment files
+.env
 *.local
 .env.local
 .env.*.local
+App_Data/
 
 # Local SSL certificates
 *.pem
 
-# Ai
+# AI agent local state
+.agents
+.agents/
 .codex
+.codex/

AGENTS.md

@@ -1,133 +1,124 @@
-# AGENTS.md
+# AGENTS
 
-## Purpose
+This repository is designed for human + AI agent collaboration.
-This document is a working guide for coding agents in this repository. It captures the current architecture, conventions, and safe execution workflow for making reliable changes.
 
-## Pair Working Mode
+## Read Order
-- Work as a pair with the repository owner, not as an isolated implementer.
+
-- Before substantial changes, restate the task briefly and inspect the existing code or docs first.
+Before meaningful code changes, read:
-- Surface assumptions, tradeoffs, and blockers early instead of silently picking risky directions.
+
-- Prefer small, reviewable increments when the product direction is still being shaped.
+1. `README.md`
-- When requirements are exploratory, help turn them into concrete workflows, domain language, and next implementation steps.
+2. `docs/AGENTIC_WORKFLOW.md`
-- Do not rewrite broad areas of the codebase without clear justification from the current task.
+3. `docs/ARCHITECTURE.md`
-- Preserve user changes in the worktree and treat uncommitted files as active collaboration unless told otherwise.
+4. `docs/DEVELOPMENT_WORKFLOW.md`
+5. `docs/PRODUCT.md`
+6. `docs/CONVENTIONS.md`
+7. Relevant file in `docs/FEATURES/`
+8. Relevant file in `docs/TASKS/`
+
+## Core Rules
+
+- Do not invent architecture.
+- Work from docs, feature specs, and task files instead of long chat history.
+- Keep backend code under `backend/src/Socialize.Api`.
+- The solution file is `backend/Socialize.slnx`.
+- Backend feature code currently follows FastEndpoints module folders under `Modules/<Feature>`.
+- Frontend feature-owned code belongs under `frontend/src/features/<feature>`.
+- Frontend runtime config must flow through `frontend/src/config.js`.
+- If backend contracts change, run `./scripts/update-openapi.sh` when the backend is running.
+- Dev servers use HTTP and bind to `0.0.0.0` for LAN access.
+- Avoid broad refactors unless the task explicitly asks for one.
 
 ## Repository Layout
-- `backend/`: ASP.NET Core (`net9.0`) API using FastEndpoints, EF Core (PostgreSQL), Stripe, Azure Blob Storage, and ASP.NET Identity.
+
-- `frontend/`: Vue 3 + Vite + Vuetify + Pinia + Vue Router + Tailwind CSS SPA.
+- `backend/src/Socialize.Api/`: ASP.NET Core `net10.0` API using FastEndpoints, EF Core, PostgreSQL, ASP.NET Identity, and workflow modules.
-- `.github/workflows/`: deploy pipelines for backend (Azure Web App) and frontend (Azure Static Web Apps).
+- `backend/tests/Socialize.Tests/`: backend test project scaffold.
+- `frontend/`: Vue 3 + Vite + Vuetify + Pinia SPA.
+- `docs/FEATURES/`: product and technical feature specs.
+- `docs/TASKS/`: implementation tickets for coding agents.
+- `docs/PROMPTS/`: reusable agent prompt templates.
+- `docs/DECISIONS/`: architecture and product decision records.
+- `shared/openapi/`: backend OpenAPI schema snapshots.
+- `scripts/`: root developer workflow commands.
+- `deploy/caddy/`: Caddy reverse proxy config for Docker Compose.
 
 ## Local Runbook
-### Backend
-- Prereqs: .NET 9 SDK, Docker, PostgreSQL container.
-- Start database:
-  - `cd backend`
-  - `./scripts/start-infrastructure.sh`
-- Run API:
-  - `dotnet run` (from `backend/`)
-- Swagger/OpenAPI UI in dev:
-  - `/api`
 
-### Frontend
+Start infrastructure:
-- Prereqs: Node/npm, local HTTPS cert files expected by Vite:
-  - `frontend/localhost-key.pem`
-  - `frontend/localhost.pem`
-- Commands:
-  - `cd frontend && npm install`
-  - `npm run dev`
-  - `npm run build`
 
-## Backend Architecture
+```bash
-### Composition Root
+./scripts/start-infrastructure.sh
-- Entry point: `backend/Program.cs`.
+```
-- Registers:
-  - Web services/auth (`backend/DependencyInjection.cs`)
-  - Infrastructure services (`backend/Infrastructure/DependencyInjection.cs`)
-  - Modules: Identity, Creators, Contents, Memberships, Tipping, Messaging.
-- Each module has:
-  - `Add{Module}Module(...)` to register DbContext/services.
-  - `Use{Module}ModuleAsync()` to auto-run migrations at startup.
 
-### API Style
+Run backend:
-- FastEndpoints-based handlers.
-- Pattern: request/response records + optional FluentValidation validator + handler class.
-- Tagging via `Options(o => o.WithTags("..."))`.
-- File upload handlers call `AllowFileUploads()`.
 
-### Data Boundaries
+```bash
-- Separate DbContext per module:
+./scripts/dev-backend.sh
-  - Identity, Creators, Contents, Memberships, Tipping, Messaging.
+```
-- Migrations are module-scoped under each `Modules/*/Migrations` folder.
 
-### Auth/Security
+Run frontend:
-- JWT is generated manually in `Infrastructure/Security/GenerateJwtToken.cs`.
-- Refresh-token flow is implemented in Identity handlers (`/api/users/login`, `/api/users/refresh`).
-- User claim helpers live in `Infrastructure/Security/ClaimsPrincipalExtensions.cs`.
 
-### Payments/Stripe
+```bash
-- Tip checkout: `Infrastructure/Payments/Stripe/Services/StripeTipProcessor.cs`.
+./scripts/dev-frontend.sh
-- Membership checkout: `Infrastructure/Payments/Stripe/Services/MembershipPaymentProcessor.cs`.
+```
-- Webhook endpoint: `Modules/Memberships/Handlers/StripeWebhookEndpoint.cs`.
-- Creator onboarding/status/revoke Stripe:
-  - `/api/stripe/connect`
-  - `/api/stripe/check-status`
-  - `DELETE /api/stripe`
 
-### Blob Storage
+Update OpenAPI:
-- `IBlobStorage` implemented by `AzureBlobStorage`.
-- Upload size/type checks are enforced there (10 MB max + content-type validation).
 
-## Frontend Architecture
+```bash
-### Bootstrap
+./scripts/update-openapi.sh
-- `frontend/src/main.js` wires Vue app + Pinia + Vuetify + Router + i18n + Google OAuth + Toasts.
+```
 
-### Routing
+## Current Domain Modules
-- Defined in `frontend/src/router/router.js`.
-- Route guards enforce:
-  - `meta.requiresAuth`
-  - `meta.notAuthenticated`
-- Creator public route convention: `/@:creator`.
 
-### State Management
+- `Identity`: authentication, refresh tokens, email verification, password reset, social login.
-- Pinia stores:
+- `Organizations`: SaaS account ownership, billing/subscription boundary, organization membership, connectors, data mappings, and owned workspaces.
-  - `authStore`: token lifecycle + refresh concurrency guard.
+- `Workspaces`: workspace membership, workspace settings, access scoping.
-  - `userProfileStore`: current user profile and account edits.
+- `Clients`: client records and primary contacts tied to workspaces.
-  - `creatorProfileStore`: creator-owned profile actions.
+- `Projects`: project pipeline and client/project relationships.
-  - `brandingStore`: creator page branding fetched from slug route param.
+- `ContentItems`: reviewable content records tied to clients/projects.
+- `Assets`: linked asset metadata and revision history.
+- `Comments`: discussion threads on reviewable work.
+- `Approvals`: review decisions and workflow state transitions.
+- `Notifications`: activity feed and unread workflow notifications.
+- `Feedback`: product feedback reports, screenshots, comments, activity, and developer review workflows.
 
-### API Client
+## Task Discipline
-- Axios client in `frontend/src/plugins/api.js`.
-- Injects bearer token, proactively refreshes near expiry, retries once on 401.
 
-## High-Value Domains
+Agents should work from task files in `docs/TASKS/`.
-- Identity and social login (`Modules/Identity/*`, `frontend/src/views/auth/*`).
-- Creator public profile and management (`Modules/Creators/*`, `frontend/src/views/creators/*`, `frontend/src/views/profile/*`).
-- Monetization:
-  - Tips (`Modules/Tipping/*`, creator donation UI)
-  - Memberships (`Modules/Memberships/*`, Stripe webhook orchestration)
-- Content albums/photo upload (`Modules/Contents/*`).
-- Messaging thread/replies (`Modules/Messaging/*`).
 
-## Agent Working Rules For This Repo
+A good task:
-1. Keep module boundaries intact. Do not couple DbContexts across modules.
-2. When adding endpoints, follow existing FastEndpoints pattern with validator + explicit route + tag.
-3. If schema changes are needed, generate migration in the matching module only.
-4. Preserve token refresh behavior in frontend client/store; avoid introducing parallel refresh races.
-5. For file uploads, enforce content-type/size limits and reuse blob path conventions.
-6. Keep creator route contract stable (`/@slug`) because frontend and backend both depend on it.
-7. Do not commit secrets. Existing appsettings include sensitive-looking values; treat as legacy and avoid propagating.
 
-## Validation Checklist Before Finishing
+- has a clear goal
-- Backend:
+- names the relevant feature spec
-  - `cd backend && dotnet build`
+- has a small scope
-  - run affected endpoint flows if change touches handlers/auth/payments/storage
+- lists likely files
-- Frontend:
+- lists validation commands
-  - `cd frontend && npm run build`
-  - validate affected route/store interactions in browser
-- If migrations were changed:
-  - ensure module context name/output directory remain consistent with `backend/scripts/add-migration.sh`.
 
-## Notes / Known Sharp Edges
+If no task exists, create one before implementing a meaningful feature.
-- Frontend expects `VITE_API_URL` in API plugin; `src/config.js` uses `VITE_APP_API_URL` naming. Keep env usage consistent when editing.
+
-- `GetReceivedTips` currently resolves tipper with `tip.CreatorId` instead of `tip.CreatedBy`; verify intent before refactoring.
+## Validation
-- Some style/formatting is inconsistent across JS/Vue/C# files; minimize churn to touched lines.
+
+Backend:
+
+```bash
+dotnet build backend/Socialize.slnx
+dotnet test backend/Socialize.slnx
+```
+
+Frontend:
+
+```bash
+cd frontend
+npm run build
+```
+
+Contract changes:
+
+```bash
+./scripts/update-openapi.sh
+```
+
+## Sharp Edges
+
+- Existing checked-in env and appsettings files may include legacy sensitive-looking values; do not propagate those values into new docs or templates.
+- The frontend is still JavaScript, not the TypeScript starter app generated by the bootstrap script. New OpenAPI scaffolding exists, but migrating app code to generated typed API calls should happen by task.
+- Feature-owned frontend route views and stores now live under `frontend/src/features/*`; keep future feature work there.

PLAN.md

@@ -1,429 +0,0 @@
-# PLAN
-
-## Purpose
-
-This document defines the build plan to close the gap between the current codebase and the target product described in [SOCIALIZE.md](/home/jbourdon/repos/social-media/SOCIALIZE.md).
-
-The current repository is a dead `Hutopy` codebase. The target product, temporarily named `Socialize`, is a workflow application for social media content review, revision, approval, and readiness for publication.
-
-This is a full product pivot, not a gradual feature expansion.
-
-## Goal
-
-Build a product that becomes the system of workflow for:
-
-- internal content review
-- provider collaboration
-- client approval
-- version tracking
-- audit trail
-- notification-driven progress
-- publication readiness handoff
-
-The first version should solve the approval pain cleanly before deeper integrations or scheduling features are added.
-
-## Gap Summary
-
-### Current Codebase
-
-The current repository contains:
-
-- backend modular structure with FastEndpoints and Entity Framework Core
-- authentication and infrastructure foundations
-- file storage patterns
-- frontend Vue application shell
-- legacy business modules centered on creators, tipping, memberships, and creator-facing experiences
-
-### Target Product
-
-The target product needs:
-
-- workspace and client management
-- provider and internal team collaboration
-- content item lifecycle management
-- asset and revision tracking
-- comments and approval workflow
-- workflow events and notifications
-- client-facing review portal
-- Google Drive-centered asset ownership
-- billing readiness for a future Software as a Service offering
-
-### Core Gap
-
-The codebase has technical scaffolding that can be reused, but the business domain is largely wrong for the target product.
-
-The main gap is not infrastructure. The main gap is domain shape, frontend surface, and workflow behavior.
-
-## Build Principles
-
-1. Reuse technical foundations when they help, but do not keep old business concepts for convenience.
-2. Keep the modular backend structure.
-3. Prefer clean domain language from day one over transitional naming.
-4. Build around Google Drive ownership first, not direct-upload-first assumptions.
-5. Deliver one vertical workflow before broad integrations.
-6. Remove legacy Hutopy product concepts early to reduce semantic drag.
-7. Keep changes reviewable and validate each phase before widening scope.
-
-## Keep, Replace, Remove
-
-### Keep
-
-- ASP.NET Core backend shell
-- FastEndpoints setup
-- modular registration pattern
-- Entity Framework Core with per-module context where useful
-- infrastructure wiring
-- authentication foundation if it can be adapted cleanly
-- payment infrastructure patterns and Stripe integration capability for future billing
-- blob or file-handling patterns that still apply
-- Vue, Vite, Pinia, router, and API client shell
-- deployment workflows if still useful for the new product
-
-### Replace
-
-- domain module set
-- route design
-- data model
-- frontend information architecture
-- user flows
-- branding and product language
-
-### Remove
-
-- creator domain concepts
-- creator public profile features
-- creator monetization flows
-- Hutopy naming across code and frontend copy
-- dead UI components and stores tied only to the old product
-
-### Retire And Rebuild
-
-- old tipping business flows
-- old membership business flows
-- creator-specific Stripe onboarding flows
-- payment routes and models that are tightly coupled to the dead Hutopy business model
-
-Keep the underlying payment capability, but rebuild the business-facing billing model around the new product when pricing and subscription design are ready.
-
-## Target Product Scope For Version 1
-
-Version 1 should own this workflow:
-
-1. Internal team creates a content item.
-2. Assets are linked from Google Drive.
-3. Publication message and metadata are attached.
-4. Internal reviewer or provider receives a request.
-5. Comments and revisions happen in one place.
-6. Client receives a review request.
-7. Client approves, rejects, or requests changes.
-8. Item becomes ready for publishing handoff.
-
-Not version 1:
-
-- full scheduling engine
-- full social publishing
-- advanced third-party synchronization
-- analytics suite
-- full digital asset management platform
-- full creative production tooling
-- customer billing and subscription management user flows
-
-## Target Backend Module Map
-
-Recommended backend modules:
-
-- `Identity`
-  - users, authentication, internal roles
-- `Workspaces`
-  - agencies or operating teams
-- `Clients`
-  - brands, creators, businesses served by a workspace
-- `Providers`
-  - external production partners
-- `Projects`
-  - grouped bodies of work for a client, which may later contain campaign concepts if needed
-- `ContentItems`
-  - reviewable units with metadata, copy, due dates, and status
-- `Assets`
-  - asset references, Google Drive linkage, versions, previews
-- `Approvals`
-  - review requests, approvers, decisions, status transitions
-- `Comments`
-  - threads, replies, resolution state, contextual discussion
-- `Notifications`
-  - workflow events, reminders, delivery preferences
-
-Possible later modules:
-
-- `Campaigns`
-- `Calendars`
-- `Integrations`
-- `Publishing`
-- `Analytics`
-- `Billing`
-
-## Target Frontend Surface
-
-Recommended frontend areas:
-
-- authentication
-- workspace switcher or workspace context
-- client list
-- project list
-- review queue dashboard
-- content item detail page
-- revision and comment timeline
-- approval status panel
-- notification center
-- external client review portal
-
-Later frontend areas:
-
-- calendar view
-- integration settings
-- publishing handoff dashboard
-- workflow analytics
-
-## Proposed Data Backbone
-
-### Content Item
-
-A content item should carry:
-
-- title
-- publication message
-- notes
-- project
-- client
-- creator or brand context where relevant
-- publication targets
-- publication dates by network when relevant
-- due date
-- current status
-- current active revision set
-
-### Asset
-
-An asset should carry:
-
-- asset type
-- source type
-- Google Drive file reference
-- preview metadata
-- current version
-- version history
-
-### Approval Request
-
-An approval request should carry:
-
-- target content item
-- requested reviewers
-- stage type
-- sent at
-- due at
-- decision state
-- decision history
-
-### Notification Event
-
-A notification event should carry:
-
-- event type
-- triggered by
-- target entity
-- recipients
-- delivery status
-- timestamps
-
-## Execution Strategy
-
-### Phase 0: Freeze Product Direction
-
-Deliverables:
-
-- validated worksheet in English
-- optional French mirror of the worksheet
-- agreed module map
-- agreed version 1 scope and anti-scope
-
-Exit criteria:
-
-- no ambiguity about the first workflow to build
-- no unresolved disagreement about Google Drive ownership
-
-### Phase 1: Remove Legacy Product Surface
-
-Goals:
-
-- reduce confusion from Hutopy concepts
-- make the codebase ready for the new domain
-
-Work:
-
-- remove or retire legacy frontend views tied to creators, tipping, and memberships
-- remove legacy backend modules that are clearly dead
-- rename product-facing strings, assets, and configuration references
-- identify infrastructure pieces that stay
-- preserve Stripe and payment infrastructure that can support future Software as a Service billing
-- identify backend modules that should be replaced instead of adapted
-
-Exit criteria:
-
-- codebase no longer communicates the old product direction
-- remaining code clearly supports reuse or is queued for replacement
-
-### Phase 2: Establish New Domain Skeleton
-
-Goals:
-
-- introduce the new product vocabulary into code
-- prepare clean module boundaries
-
-Work:
-
-- create new backend modules
-- define initial entities and contexts
-- wire modules in `Program.cs`
-- define route namespaces and tags
-- create frontend route skeleton for the new product
-- define new stores for auth, workspace context, review queue, and content items
-
-Exit criteria:
-
-- application compiles with the new module map in place
-- legacy domain is no longer the center of the app
-
-### Phase 3: Build The First Vertical Slice
-
-Vertical slice:
-
-- create content item
-- link Google Drive asset
-- add publication message and publication target data
-- request internal review
-- comment on item
-- request changes
-- upload or register a new revision
-- request client review
-- approve from client portal
-- mark ready to publish
-
-Backend work:
-
-- commands and queries for content item creation and retrieval
-- asset linkage and versioning
-- comment creation and retrieval
-- approval request and decision endpoints
-- status transition logic
-- workflow event emission
-
-Frontend work:
-
-- content item creation flow
-- content item detail view
-- comments panel
-- approval action UI
-- status timeline
-- simple client review page
-
-Exit criteria:
-
-- one item can move end-to-end from draft to approved
-- all actions are traceable in one place
-
-### Phase 4: Add Notification Backbone
-
-Goals:
-
-- make workflow movement visible without manual follow-up
-
-Work:
-
-- define notification event types
-- trigger events on comments, revisions, requests, and decisions
-- add email notifications
-- add in-app notification center or lightweight feed
-- add reminder jobs for pending reviews
-
-Exit criteria:
-
-- users are informed when workflow events occur
-- delayed approvals can be followed without manual chasing
-
-### Phase 5: Harden Version 1 For Real Usage
-
-Goals:
-
-- make the workflow usable for the first real client
-
-Work:
-
-- permissions and role hardening
-- validation and error handling
-- audit trail review
-- filtering and dashboard improvements
-- comment resolution
-- required approver logic if needed
-- publication dates by network support
-- quality pass on mobile review experience
-
-Exit criteria:
-
-- the first client can run a real approval cycle in the product
-
-### Phase 6: Evaluate Phase 2 Expansion
-
-Candidates:
-
-- calendar visibility
-- Google Drive sync improvements
-- Canva linkage
-- MailChimp approval path
-- scheduler handoff integrations
-- billing and subscription management for the Software as a Service offer
-
-Rule:
-
-Only start these after version 1 workflow is demonstrably useful.
-
-## Immediate Technical Tasks
-
-Recommended next implementation tasks:
-
-1. Rename the product and remove visible Hutopy branding.
-2. Inventory which backend modules are deleted versus replaced.
-3. Define the new backend module directories and initial project structure.
-4. Replace the frontend router with the new application surface.
-5. Model `ContentItem`, `Asset`, `AssetVersion`, `ApprovalRequest`, `ApprovalDecision`, `CommentThread`, and `NotificationEvent`.
-6. Implement the first vertical slice end to end.
-
-## Risks
-
-- scope creep into scheduling and publishing too early
-- forcing the new domain into old creator-centric structures
-- under-designing workflow status and revision semantics
-- overbuilding integrations before the core workflow is proven
-- making external review too heavy for clients
-
-## Validation Checklist
-
-Before claiming version 1 readiness:
-
-- a workspace can manage at least one client
-- a content item can include publication message and publication targets
-- assets can be linked from Google Drive
-- internal review can request changes
-- client review can approve or reject
-- status history is visible
-- notification events are triggered
-- the latest approved state is clear
-
-## Working Note
-
-This plan should be updated as soon as the first implementation decisions are made, especially:
-
-- exact module names
-- exact database boundaries
-- whether `Providers` stands alone or is modeled as a participant role
-- whether notifications are their own module or an infrastructure concern

README.md

@@ -1,110 +1,107 @@
-# Hutopy
+# Socialize
 
-## Patterns / strategy used
+Socialize is an organization-owned, workspace-based workflow application for social media content review, revision, approval, and publication readiness.
-- Clean Architecture ( with Infrastructure, Domain, Application and Web layers )
-- Minimal API endpoints.
 
-## Tools
+It is not a public social network. The product is for internal teams, providers, and client approvers coordinating content work before publication.
-- Install Docker : https://www.docker.com/get-started/
-- Install sql server management ( or preferred tool ) : https://learn.microsoft.com/en-us/sql/ssms/download-sql-server-management-studio-ssms?view=sql-server-ver16#download-ssms
 
-## Database setup in docker for local dev
+## Monorepo
-```
-docker run -e "ACCEPT_EULA=Y" -e "MSSQL_SA_PASSWORD=P@ssword123!" -p 1433:1433 -d mcr.microsoft.com/mssql/server:2022-latest
-```
 
-Or with a mounted volume to persist data on the computer instead ( persist data even if the container is deleted )
+- Backend: .NET 10 Web API in `backend/src/Socialize.Api`
-```
+- Backend tests: `backend/tests/Socialize.Tests`
-docker run -e 'ACCEPT_EULA=Y' -e 'MSSQL_SA_PASSWORD=P@ssword123!' -p 1433:1433 -v C:\dev\DockerVolumes\SqlServer-Utopy-1\data:/var/opt/mssql/data -v C:\dev\DockerVolumes\SqlServer-Utopy-1\log:/var/opt/mssql/log -v C:\dev\DockerVolumes\SqlServer-Utopy-1\secrets:/var/opt/mssql/secrets -d mcr.microsoft.com/mssql/server:2022-latest
+- Frontend: Vue 3 + Vite + Vuetify + Pinia in `frontend`
-```
+- API contract: OpenAPI snapshot in `shared/openapi`
+- Deployment: Docker Compose + Caddy
+- Agentic workflow: specs, task files, and prompt templates under `docs`
 
-## Postgres DB setup in docker for local dev
+## Local Development
-```
-docker run -p 5432:5432 --name Hutopy -e POSTGRES_PASSWORD=P@ssword123! -e POSTGRES_USER=sa -d postgres
 
-
+Terminal 1:
-```
-
-## Entity Framework
-
-Create a new migration :
-```
-./Ef.ps1 migrations add NomDeLaMigration
-```
-
-Update database :
-```
-./Ef.ps1 database update
-```
-
-## Secret Manager tool
-Go to Web project: cd src/Web
-
-Add a user secret for local development :
-```
-dotnet user-secrets set "DB_PASSWORD" "12345"
-```
-
-list your stored secrets :
-```
-dotnet user-secrets list
-```
-
-Delete a secret :
-```
-dotnet user-secrets remove "DB_PASSWORD"
-```
-
-## Build
-
-Run `dotnet build -tl` to build the solution.
-
-## Run
-
-To run the web application:
 
 ```bash
-cd .\src\Web\
+./scripts/start-infrastructure.sh
-dotnet watch run
+./scripts/dev-backend.sh
 ```
 
-Navigate to https://localhost:5001. The application will automatically reload if you change any of the source files.
+Terminal 2:
-
-## Code Styles & Formatting
-
-The template includes [EditorConfig](https://editorconfig.org/) support to help maintain consistent coding styles for multiple developers working on the same project across various editors and IDEs. The **.editorconfig** file defines the coding styles applicable to this solution.
-
-## Code Scaffolding
-
-Scaffold new commands and queries.
-
-Start in the `.\src\Application\` folder.
-
-Create a new command:
-
-```
-dotnet new ca-usecase --name CreateTodoList --feature-name TodoLists --usecase-type command --return-type int
-```
-
-Create a new query:
-
-```
-dotnet new ca-usecase -n GetTodos -fn TodoLists -ut query -rt TodosVm
-```
-
-If you encounter the error *"No templates or subcommands found matching: 'ca-usecase'."*, install the template and try again:
 
 ```bash
-dotnet new install Clean.Architecture.Solution.Template::8.0.4
+./scripts/dev-frontend.sh
 ```
 
-## Test
+Frontend:
 
-The solution contains unit, integration, and functional tests.
+```txt
+http://localhost:5173
+http://<this-machine-lan-ip>:5173
+```
 
-- Using Moq, Nunit, Respawn, FluentAssertions
+Backend:
+
+```txt
+http://localhost:5080
+http://<this-machine-lan-ip>:5080
+```
+
+Swagger UI:
+
+```txt
+http://localhost:5080/api
+```
+
+## Update Frontend API Types
+
+The backend must be running first.
 
-To run the tests:
 ```bash
-dotnet test
+./scripts/update-openapi.sh
 ```
+
+This writes:
+
+```txt
+shared/openapi/openapi.json
+frontend/src/api/schema.d.ts
+```
+
+## Docker Compose
+
+```bash
+docker compose up --build
+```
+
+Then open:
+
+```txt
+http://localhost:8080
+http://<this-machine-lan-ip>:8080
+```
+
+For preprod deployment, configure the `POSTGRES_PASSWORD`, `RESEND_API_KEY`,
+`RESEND_FROM_EMAIL`, and `JWT_SIGNING_KEY` Gitea secrets.
+The deploy workflow writes the remote `.env` file and syncs `deploy/compose.yml`
+before running the server deploy script.
+Use the raw Resend API key value for `RESEND_API_KEY`, without a `Bearer ` prefix.
+
+## Solution
+
+```bash
+dotnet build backend/Socialize.slnx
+dotnet test backend/Socialize.slnx
+```
+
+## Frontend Build
+
+```bash
+cd frontend
+npm run build
+```
+
+## Agentic Workflow
+
+Start here:
+
+```txt
+docs/AGENTIC_WORKFLOW.md
+```
+
+Use feature specs, task files, and prompt templates instead of asking agents to work from vague chat history.

SOCIALIZE.fr.md

@@ -1,328 +0,0 @@
-# Flux d'approbation pour les contenus de medias sociaux
-
-Nom temporaire du produit : `Socialize`
-
-## Intention du projet
-
-Construire `Socialize`, une application qui remplace le processus actuel d'approbation base sur Google Drive, les appels telephoniques, les courriels et les feuilles de calcul.
-
-Le produit n'est pas un reseau social public. C'est un outil de flux de travail interne/externe pour la revision de contenu, la collecte de commentaires, l'approbation et la preparation a la publication.
-
-## Vocabulaire partage
-
-- Flux d'approbation : le processus complet entre la creation d'un brouillon et l'approbation finale.
-- Element de contenu : l'unite a reviser qui regroupe les fichiers, le message de publication ou le texte, les dates et les canaux cibles.
-- Ressource : un fichier rattache a un element de contenu, par exemple une video, une image ou un document.
-- Revision : une nouvelle version d'une ressource ou d'un texte apres commentaires.
-- Reviseur externe : un client ou un partenaire qui revise du contenu sans faire partie de l'equipe interne.
-- Fournisseur : un partenaire de production externe, par exemple une equipe video, un photographe, un monteur ou un designer, qui peut livrer des brouillons et recevoir des demandes de modifications.
-- Software as a Service (SaaS) / logiciel en tant que service : un produit en ligne utilise via le web, comme Canva, MailChimp, HootSuite ou Metricool.
-- Minimum Viable Product (MVP) / produit minimum viable : la plus petite version du produit qui regle suffisamment bien le probleme principal pour valider le marche.
-- Service Level Agreement (SLA) / accord de niveau de service : une cible de service convenue, par exemple une date limite de revision ou un seuil d'escalade.
-
-## Enonce du probleme
-
-Les gestionnaires de medias sociaux et les equipes de production gerent actuellement les approbations de contenu de facon manuelle :
-
-- Les ressources sont stockees dans Google Drive.
-- Le gestionnaire de medias sociaux fait souvent des allers-retours autant avec les fournisseurs qu'avec les clients.
-- Les commentaires circulent par telephone, courriel, message et feuille de calcul.
-- L'historique des versions est flou.
-- Il est difficile de savoir quel fichier est le plus recent.
-- Les commentaires sont disperses sur plusieurs canaux.
-- Les approbations internes et celles des clients suivent des logiques semblables mais ne sont pas centralisees.
-- Les suivis sont manuels, ce qui retarde les approbations.
-
-Resultat : trop d'allers-retours, peu de tracabilite, des delais evitables et un risque de publier le mauvais fichier ou une version de texte perimee.
-
-## Outils observes actuellement
-
-- Google Drive pour les videos, images, calendriers et documents
-- Google Sheets ou equivalent pour suivre les commentaires et les statuts
-- Telephone et courriel pour les conversations de revision et d'approbation
-- HootSuite
-- Metricool
-- Canva
-- MailChimp
-
-## Utilisateurs principaux
-
-- Gestionnaire de medias sociaux
-- Gestionnaire de compte / service client
-- Approbateur cote client
-- Fournisseur externe / partenaire de production
-- Producteur interne
-- Employe interne / contributeur au contenu
-- Administrateur
-
-## Cas d'utilisation principaux
-
-### 1. Flux d'approbation client
-
-Un gestionnaire de medias sociaux prepare du contenu pour un client et le soumet pour approbation.
-
-Le client doit pouvoir :
-
-- consulter le lot de contenu
-- previsualiser les fichiers
-- lire les legendes, descriptions et notes de projet
-- laisser des commentaires
-- demander des modifications
-- approuver ou rejeter
-
-L'equipe doit pouvoir :
-
-- voir le statut d'approbation en temps reel
-- repondre aux commentaires dans leur contexte
-- televerser des versions revisees
-- conserver une piste d'audit claire indiquant qui a dit quoi et quand
-- savoir exactement quelle version est approuvee
-
-### 2. Flux de production interne
-
-Le meme flux doit fonctionner a l'interne pour les producteurs, employes et partenaires de production externes avant que le contenu soit montre au client ou planifie pour publication.
-
-Exemple :
-
-- un contributeur televerse un brouillon
-- un fournisseur externe peut televerser un brouillon ou une version revisee
-- un producteur revise et demande des modifications
-- un gestionnaire approuve pour la revision client
-- le client approuve
-- le contenu est marque pret pour la publication
-
-### 3. Revision d'un lot de contenu
-
-L'approbation ne doit pas se limiter a un seul fichier. Un element a reviser peut inclure :
-
-- video
-- image
-- document
-- message de publication / legende / texte
-- mots-clics
-- liens
-- dates de publication
-- canaux cibles ou reseaux sociaux
-
-## Resume du flux actuel
-
-Flux actuel typique :
-
-1. L'equipe cree les ressources media.
-2. Les fichiers sont places dans Google Drive par l'equipe ou par des fournisseurs externes.
-3. Un gestionnaire envoie les liens par courriel ou message aux fournisseurs, aux intervenants internes ou aux clients.
-4. Les commentaires reviennent par telephone, courriel, feuille de calcul ou clavardage.
-5. L'equipe consolide manuellement les commentaires provenant des fournisseurs et des clients.
-6. Une version revisee est televersee.
-7. Le cycle se repete jusqu'a ce que quelqu'un dise que c'est approuve.
-8. Le statut d'approbation est suivi manuellement ailleurs.
-
-Principaux points d'echec :
-
-- aucune source de verite unique
-- aucun etat d'approbation structure
-- aucun fil de commentaires centralise
-- aucun rappel d'echeance
-- aucune piste d'audit fiable
-- aucune barriere d'approbation avant publication
-
-## Flux cible
-
-1. Creer un projet et l'associer a un client.
-2. Creer un element de revision ou une demande d'approbation.
-3. Joindre des ressources ou les importer depuis Google Drive.
-4. Ajouter des metadonnees :
-   - titre
-   - message de publication / legende / texte
-   - plateforme cible ou reseau social
-   - dates de publication par reseau lorsque pertinent
-   - date d'echeance
-   - reviseur(s)
-5. Envoyer la demande de revision.
-6. Les reviseurs commentent directement sur l'element.
-7. L'equipe ou le fournisseur televerse une revision ou repond aux commentaires.
-8. Le systeme suit les versions, les changements de statut et les evenements du flux.
-9. Le reviseur approuve, rejette ou demande des modifications.
-10. Une fois toutes les approbations requises obtenues, l'element devient pret pour la planification ou la publication.
-
-## Objets de domaine principaux
-
-- Espace de travail : la frontiere principale du compte pour une agence ou une equipe operationnelle.
-- Client : l'entreprise, le createur ou la marque qui recoit le service et approuve le contenu.
-- Membre d'equipe : un utilisateur interne qui travaille sur le contenu, les revisions ou la coordination.
-- Reviseur : toute personne a qui l'on demande de reviser et d'approuver, qu'elle soit interne ou externe.
-- Fournisseur : un contributeur de production externe, comme un photographe, videaste, monteur ou designer.
-- Projet : le principal conteneur de travail pour un client, qui regroupe des elements de contenu, des notes, des participants et des echeances.
-- Element de contenu : l'unite a reviser qui contient les ressources, le message de publication, les canaux cibles, les dates d'echeance et l'etat d'approbation.
-- Ressource : un fichier joint, comme une video, une image ou un document, reference depuis Google Drive ou stocke directement.
-- Version de ressource : une revision precise d'une ressource, avec tracabilite de la personne qui l'a televersee et du moment.
-- Fil de commentaires : une discussion contextuelle rattachee a un element de contenu, une ressource ou une revision.
-- Demande d'approbation : l'action de demander a un ou plusieurs reviseurs de reviser une version precise.
-- Decision d'approbation : le resultat d'une demande de revision, par exemple approuve, rejete ou modifications demandees.
-- Historique des statuts : la piste d'audit des etats et transitions du flux dans le temps.
-- Cible de publication : la destination prevue pour la publication, par exemple Instagram, Facebook, LinkedIn ou une infolettre.
-- Evenement de notification : un evenement du flux qui informe les utilisateurs qu'un commentaire, une revision, une demande ou une approbation vient d'avoir lieu.
-
-## Modele de statuts suggere
-
-- Brouillon
-- En revision interne
-- Modifications demandees a l'interne
-- Modifications internes en cours
-- Pret pour revision client
-- En revision client
-- Modifications demandees par le client
-- Modifications client en cours
-- Approuve
-- Rejete
-- Pret a publier
-- Publie
-- Archive
-
-## Portee du Minimum Viable Product (MVP) / produit minimum viable
-
-La premiere version doit se concentrer sur le flux d'approbation, et non sur la publication directe.
-
-### Fonctionnalites MVP
-
-- authentification et roles utilisateurs
-- structure espace de travail / client / projet
-- creation d'un element de contenu avec metadonnees
-- televersement de ressources ou ajout de liens Google Drive tout en gardant Google Drive comme source de verite lorsque le client l'exige
-- suivi des versions pour les fichiers et les textes
-- commentaires centralises
-- decisions d'approbation : approuver, rejeter, demander des modifications
-- chronologie d'activite / piste d'audit
-- tableau de bord par client, projet et date d'echeance
-- notifications et rappels lorsque des actions sont completees ou que des evenements du flux surviennent
-- portail simple d'approbation pour les clients externes
-
-### Fonctionnalites candidates fortes pour le MVP
-
-- approbateurs obligatoires
-- date limite d'approbation
-- dates d'echeance par cible de publication ou reseau social
-- comparaison entre version courante et version precedente
-- indicateur de la "derniere version approuvee"
-- resolution des commentaires
-- filtres par statut, client, responsable et date d'echeance
-
-## Possibilites pour la phase 2
-
-- integration Google Drive avec synchronisation ou import de fichiers
-- export ou transfert vers HootSuite / Metricool
-- liaison avec les ressources Canva
-- flux d'approbation MailChimp pour les infolettres
-- integration calendrier pour la visibilite sur la planification des publications
-- commentaires annotes sur images ou sur horodatages video
-- modeles de flux d'approbation reutilisables par type de contenu
-- rappels et escalades bases sur les Service Level Agreements (SLA) / accords de niveau de service
-- analyses sur les temps de traitement et les goulots d'etranglement
-- approbation par lien recu par courriel
-- regles d'approbation a plusieurs etapes selon le client
-
-## Possibilites d'automatisation importantes
-
-- demander automatiquement une approbation lorsqu'un element atteint une etape definie
-- envoyer automatiquement des notifications lorsqu'une action est completee ou qu'un evenement du flux survient
-- envoyer automatiquement des rappels avant les echeances
-- escalader automatiquement lorsqu'une approbation est en retard
-- etiqueter automatiquement les versions
-- passer automatiquement a l'etat "pret a publier" lorsque toutes les approbations sont completees
-- conserver automatiquement une piste d'audit de chaque televersement, commentaire et decision
-- generer automatiquement un lien de revision cote client
-- notifier automatiquement lorsqu'une nouvelle revision repond aux modifications demandees
-
-## Decisions produit importantes
-
-### 1. Systeme de reference pour les ressources
-
-Options :
-
-- garder Google Drive comme stockage de fichiers et construire le flux autour
-- televerser les fichiers directement dans la nouvelle application
-- supporter les deux
-
-Premiere hypothese recommandee :
-
-Garder Google Drive comme source de verite lorsque le client exige d'en conserver la propriete, et supporter plus tard les televersements directs comme option. La premiere version doit fonctionner proprement avec les liens Drive et les metadonnees importees avant d'envisager une synchronisation plus poussee.
-
-### 2. Experience du reviseur externe
-
-Options :
-
-- compte reviseur obligatoire
-- acces par lien magique sans compte complet
-- les deux
-
-Premiere hypothese recommandee :
-
-Utiliser l'acces par lien magique pour les clients afin de reduire la friction.
-
-### 3. Granularite de l'approbation
-
-Unites d'approbation possibles :
-
-- element de contenu complet
-- par ressource
-- par legende / texte
-- par variation de canal
-
-Premiere hypothese recommandee :
-
-Approuver au niveau de l'element de contenu dans le Minimum Viable Product (MVP), avec des commentaires rattaches aux ressources et au texte.
-
-## Regles d'affaires a confirmer
-
-Ces points ne bloquent pas le cadrage initial, mais il faut les documenter tot pour que le comportement du produit corresponde bien au vrai processus d'approbation.
-
-- Un client peut-il approuver s'il reste des commentaires non resolus ?
-- L'approbation exige-t-elle un seul reviseur ou plusieurs reviseurs ?
-- L'approbation interne et l'approbation client peuvent-elles se faire en parallele ?
-- L'approbation est-elle valide seulement pour la version la plus recente ?
-- Un element approuve peut-il etre modifie sans rouvrir la revision ?
-- Des clients differents ont-ils besoin de flux differents ?
-- Les videos, images et documents sont-ils tous aussi importants des le jour 1 ?
-- La planification ou publication fait-elle partie de la portee, ou seulement le passage a l'etat "pret a publier" ?
-
-## Questions ouvertes pour la prochaine entrevue
-
-- Qui est l'acheteur : agence, travailleur autonome ou equipe marketing interne ?
-- Le premier marche cible est-il l'approbation agence-client, l'approbation interne ou les deux ?
-- Quels types de contenu sont prioritaires : video, image, documents, legende, infolettres ?
-- A quelle frequence les clients demandent-ils des modifications apres une approbation verbale ?
-- Quelle est aujourd'hui l'etape la plus douloureuse ?
-- Quels outils doivent absolument rester en place au lancement ?
-- Quelles approbations exigent une tracabilite legale ou de conformite ?
-- Combien de reviseurs participent habituellement a chaque element ?
-- Le bilinguisme est-il requis ?
-- La revision mobile est-elle importante au jour 1 ?
-
-## Criteres de succes du Minimum Viable Product (MVP) / produit minimum viable
-
-- reduire le temps necessaire pour obtenir une approbation
-- reduire les allers-retours entre courriels, telephone et feuilles de calcul
-- fournir une source de verite claire pour la derniere version et le statut courant
-- permettre a un client d'approuver sans formation
-- permettre a l'equipe de voir instantanement les elements bloques
-
-## Positionnement du produit
-
-Ce produit devrait etre positionne comme suit :
-
-"Un flux de revision et d'approbation pour le contenu de medias sociaux, et non un autre outil de creation de contenu."
-
-La valeur se trouve dans la coordination, la tracabilite et l'acceleration des cycles d'approbation.
-
-## Recommandation pour la premiere version
-
-Construire la premiere version autour de ce flux etroit :
-
-1. l'equipe cree un element de contenu
-2. l'equipe televerse les fichiers et le texte
-3. un reviseur interne commente et demande des modifications
-4. l'equipe soumet l'element au client
-5. le client commente et approuve via un lien simple
-6. l'element devient pret pour le transfert vers la publication
-
-Si ce flux fonctionne proprement, les integrations et la planification pourront etre ajoutees ensuite.

SOCIALIZE.md

@@ -1,328 +0,0 @@
-# Social Media Approval Workflow
-
-Temporary product name: `Socialize`
-
-## Project Intent
-
-Build `Socialize`, an application that replaces the current approval process based on Google Drive, phone calls, emails, and spreadsheets.
-
-The product is not a public social network. It is an internal/external workflow tool for content review, feedback, approval, and publication readiness.
-
-## Shared Vocabulary
-
-- Approval workflow: the end-to-end process from draft creation to final approval.
-- Content item: the reviewable unit that bundles assets, publication message or copy, dates, and channel targets.
-- Asset: a file attached to a content item, such as a video, image, or document.
-- Revision: a new version of an asset or copy after feedback.
-- External reviewer: a client or partner who reviews content without being part of the internal team.
-- Provider: an external production partner, such as a film crew, photographer, editor, or designer, who may deliver drafts and receive change requests.
-- Software as a Service (SaaS): a cloud-based product used through the web, such as Canva, MailChimp, HootSuite, or Metricool.
-- Minimum Viable Product (MVP): the smallest product version that solves the main pain point well enough to validate the market.
-- Service Level Agreement (SLA): an agreed service target, such as a review deadline or escalation threshold.
-
-## Problem Statement
-
-Social media managers and production teams currently manage content approvals manually:
-
-- Assets are stored in Google Drive.
-- The social media manager may have back-and-forth with both upstream providers and downstream clients.
-- Feedback is exchanged by phone, email, messages, and spreadsheets.
-- Version history is unclear.
-- It is hard to know which file is the latest one.
-- Comments are scattered across multiple channels.
-- Internal approvals and client approvals follow similar patterns but are not centralized.
-- Follow-ups are manual, so approvals get delayed.
-
-Result: too much back-and-forth, poor traceability, avoidable delays, and risk of publishing the wrong asset or outdated copy.
-
-## Existing Tools Observed
-
-- Google Drive for videos, images, calendars, and documents
-- Google Sheets or similar for tracking comments and status
-- Phone and email for review/approval conversations
-- HootSuite
-- Metricool
-- Canva
-- MailChimp
-
-## Primary Users
-
-- Social media manager
-- Account manager / customer success
-- Client approver
-- External provider / production partner
-- Internal producer
-- Internal employee / content contributor
-- Administrator
-
-## Core Use Cases
-
-### 1. Client Approval Workflow
-
-A social media manager prepares content for a client and sends it for approval.
-
-The client should be able to:
-
-- view the content package
-- preview files
-- read captions, descriptions, and project notes
-- leave comments
-- request changes
-- approve or reject
-
-The team should be able to:
-
-- see approval status in real time
-- answer comments in context
-- upload revised versions
-- keep a clear audit trail of who said what and when
-- know exactly which version is approved
-
-### 2. Internal Production Workflow
-
-The same workflow should work internally for producers, employees, and external production partners before the content is shown to the client or scheduled for publishing.
-
-Example:
-
-- contributor uploads draft
-- external provider can upload draft or revised media
-- producer reviews and requests changes
-- manager approves for client review
-- client approves
-- content is marked ready to publish
-
-### 3. Content Package Review
-
-Approval should not be limited to a single file. A review item may include:
-
-- video
-- image
-- document
-- publication message / caption / copy
-- hashtags
-- links
-- publication dates
-- target channels or social networks
-
-## Current Workflow Summary
-
-Typical current flow:
-
-1. Team creates media assets.
-2. Files are placed in Google Drive by the team or by external providers.
-3. A manager sends links by email or message to providers, internal stakeholders, or clients.
-4. Feedback comes back by phone, email, spreadsheet, or chat.
-5. Team manually consolidates comments across provider feedback and client feedback.
-6. A revised version is uploaded.
-7. The cycle repeats until someone says it is approved.
-8. Approval status is manually tracked elsewhere.
-
-Main failure points:
-
-- no single source of truth
-- no structured approval states
-- no centralized threaded comments
-- no deadline reminders
-- no reliable audit trail
-- no approval gate before publishing
-
-## Target Workflow
-
-1. Create a project and associate it with a client.
-2. Create a review item or approval request.
-3. Attach assets or import them from Google Drive.
-4. Add metadata:
-   - title
-   - publication message / caption / copy
-   - target platform or social network
-   - publication dates by network when relevant
-   - due date
-   - reviewer(s)
-5. Send review request.
-6. Reviewers comment directly on the item.
-7. Team or provider uploads a revision or responds to comments.
-8. System tracks versions, status changes, and workflow events.
-9. Reviewer approves, rejects, or requests changes.
-10. Once all required approvals are complete, item becomes ready for scheduling/publishing.
-
-## Core Domain Objects
-
-- Workspace: the top-level account boundary for one agency or one operating team.
-- Client: the business, creator, or brand receiving the service and approving content.
-- Team member: an internal user working on content, reviews, or coordination.
-- Reviewer: any person asked to review and approve, whether internal or external.
-- Provider: an external production contributor such as a photographer, videographer, editor, or designer.
-- Project: the main work container for a client, grouping related content items, notes, participants, and timelines.
-- Content item: the reviewable unit that contains assets, publication message, channel targets, due dates, and approval state.
-- Asset: an attached file, such as a video, image, or document, referenced from Google Drive or stored directly.
-- Asset version: a specific revision of an asset, with traceability to who uploaded it and when.
-- Comment thread: a contextual discussion attached to a content item, asset, or revision.
-- Approval request: the act of asking one or more reviewers to review a specific version.
-- Approval decision: the outcome of a review request, such as approved, rejected, or changes requested.
-- Status history: the audit trail of workflow states and transitions over time.
-- Publication target: the intended destination for publication, such as Instagram, Facebook, LinkedIn, or a newsletter.
-- Notification event: a workflow event that informs users something changed, such as a new comment, revision, request, or approval.
-
-## Suggested Status Model
-
-- Draft
-- In internal review
-- Changes requested internally
-- Internal changes in progress
-- Ready for client review
-- In client review
-- Changes requested by client
-- Client changes in progress
-- Approved
-- Rejected
-- Ready to publish
-- Published
-- Archived
-
-## Minimum Viable Product (MVP) Scope
-
-The first version should focus on approval workflow, not direct publishing.
-
-### MVP Features
-
-- authentication and user roles
-- workspace/client/project structure
-- create a content item with metadata
-- upload assets or attach Google Drive links while keeping Google Drive as the source of truth when required by the client
-- version tracking for files and copy
-- centralized comments
-- approval decisions: approve, reject, request changes
-- activity timeline / audit trail
-- status dashboard by client, project, and due date
-- notifications and reminders when actions are completed or workflow events occur
-- simple approval portal for external clients
-
-### Strong MVP Candidate Features
-
-- required approvers
-- approval deadline
-- due dates per publication target or social network
-- compare current version vs previous version
-- "latest approved version" indicator
-- comment resolution
-- filtering by status, client, assignee, due date
-
-## Phase 2 Opportunities
-
-- Google Drive integration with file sync/import
-- HootSuite / Metricool export or handoff
-- Canva asset linking
-- MailChimp approval workflow for newsletters
-- calendar integration for publication planning visibility
-- annotated comments on images or video timestamps
-- reusable approval templates by content type
-- Service Level Agreement (SLA) reminders and escalations
-- analytics on turnaround time and bottlenecks
-- approval by email link
-- multi-stage approval rules per client
-
-## Key Automation Opportunities
-
-- auto-request approval when a content item reaches a defined stage
-- automatic notifications when a workflow action is completed or a workflow event occurs
-- automatic reminders before approval deadlines
-- automatic escalation when approval is overdue
-- automatic version labeling
-- automatic "ready to publish" state when all approvals are complete
-- automatic audit trail for every upload, comment, and decision
-- automatic client-facing review link generation
-- automatic notification when a new revision addresses requested changes
-
-## Important Product Decisions
-
-### 1. System of record for assets
-
-Options:
-
-- keep Google Drive as file storage and build workflow around it
-- upload files directly into this new application
-- support both
-
-Recommended first assumption:
-
-Keep Google Drive as the source of truth when the client requires ownership there, and support direct uploads later as an option. The first version should work cleanly with Drive links and imported metadata before deeper synchronization is considered.
-
-### 2. External reviewer experience
-
-Options:
-
-- reviewer account required
-- magic-link access without full account
-- both
-
-Recommended first assumption:
-
-Use magic-link review access for clients to reduce friction.
-
-### 3. Approval granularity
-
-Possible approval units:
-
-- entire content item
-- per asset
-- per caption/copy
-- per channel variation
-
-Recommended first assumption:
-
-Approve at the content item level in the Minimum Viable Product (MVP), with comments attached to assets and copy.
-
-## Business Rules To Confirm
-
-These do not block initial scoping, but we should capture them early so the product behavior matches the real approval process.
-
-- Can a client approve with unresolved comments?
-- Does approval require one reviewer or multiple reviewers?
-- Can internal approval and client approval happen in parallel?
-- Is approval valid only for the latest version?
-- Can an approved item be edited without reopening review?
-- Do different clients require different workflows?
-- Are videos, images, and documents all equally important on day one?
-- Is scheduling/publishing inside scope, or only "approval-ready" handoff?
-
-## Open Questions For Next Interview
-
-- Who is the buyer: agency, freelancer, or in-house marketing team?
-- Is the first target market agency-to-client approval, internal team approval, or both?
-- What content types are highest priority: video, image, documents, captions, newsletters?
-- How often do clients request changes after verbal approval?
-- What is the most painful step today?
-- What tools must remain in place at launch?
-- What approvals need legal or compliance traceability?
-- How many reviewers usually participate per item?
-- Is bilingual support required?
-- Is mobile review important on day one?
-
-## Minimum Viable Product (MVP) Success Criteria
-
-- reduce approval turnaround time
-- reduce back-and-forth across email/phone/spreadsheets
-- give one clear source of truth for latest version and current status
-- let a client approve without training
-- let the team see blocked items instantly
-
-## Product Positioning
-
-This product should be positioned as:
-
-"A review and approval workflow for social media content, not another content creation tool."
-
-The value is coordination, traceability, and faster approval cycles.
-
-## First Build Recommendation
-
-Build the first release around this narrow flow:
-
-1. team creates content item
-2. team uploads files and copy
-3. internal reviewer comments and requests changes
-4. team submits to client
-5. client comments and approves via simple link
-6. item becomes ready for publishing handoff
-
-If this flow works cleanly, integrations and scheduling can be added later.

Stripe.md

@@ -1,30 +0,0 @@
-# Stripe
-
-## Events Workflow
-
-### Membership
-
-1. checkout.session.completed	    
-  - Store StripeSubscriptionId, UserId, CreatorId, TierId
-  - Save a new Subscription entity with the status "Pending"
-
-2. invoice.payment_succeeded        
-  - Grant access (set Subscription.Active = true or similar)
-  - Record transaction or set StartDate
-  - Notify Creator (e.g., new member)
-
-3. customer.subscription.updated    
-  - Update `EndDate = CancelAt ?? CanceledAt`
-
-4. customer.subscription.deleted	
-  - Revoke access
-  - Mark Subscription as inactive/ended
-
-### Tips
-
-1. checkout.session.completed	    
-  - Store TipId, StripeSessionId, TipperId, CreatorId
-  - PaymentIntentStatus == "paid"
-  - Status = "Paid"
-  - Notify creator
-  - Record transaction

TEMPLATE_PROMPT.md

@@ -0,0 +1,330 @@
+# PROMPT TEMPLATES
+ I need you to help me write a feature. First, we need to define it, so you will ask me questions one-by-one to make sure we have a shared understanding of the scope
+  and expectating. - The feature we want is a way for your clients to report bugs/suggestions/requests from within our app. It should not be intrusive. It should allow
+  them to take a screen capture, put annotation, describe their request and/or issue. Then, as a dev, i will want to collect and review them.
+
+## Purpose
+This document standardizes how we interact with AI coding agents (Codex, Claude, etc).
+
+Goals:
+- Reduce prompt variability
+- Prevent architectural drift
+- Improve consistency and reliability
+- Enable repeatable workflows
+
+---
+
+# 🧠 Core Principle
+
+The AI is NOT the source of truth.
+
+The source of truth is:
+- docs/PRODUCT.md
+- docs/ARCHITECTURE.md
+- docs/CONVENTIONS.md
+- docs/DECISIONS.md
+- docs/tasks/*.md
+
+All prompts MUST reference these.
+
+---
+
+# 🔁 Standard Workflow
+
+1. PLAN
+2. BREAKDOWN (optional)
+3. IMPLEMENT (step-by-step)
+4. REVIEW
+
+Never skip directly to implementation for non-trivial features.
+
+---
+
+# 🧩 Prompt Templates
+
+---
+
+## 1. PLAN (default starting point)
+
+### When to use
+- New feature
+- Complex change
+- Refactor
+- Anything unclear
+
+### Prompt
+
+You are working inside an existing repository.
+
+Before doing anything:
+1. Read:
+   - AGENTS.md
+   - docs/PRODUCT.md
+   - docs/ARCHITECTURE.md
+   - docs/CONVENTIONS.md
+   - docs/DECISIONS.md
+2. Read the task:
+   - docs/tasks/TASK-XXX.md
+
+Do NOT modify code.
+
+Output:
+1. Summary (<=10 lines)
+2. Relevant architecture
+3. Files likely involved
+4. Implementation plan
+5. Risks / ambiguities
+
+---
+
+## 2. BREAKDOWN
+
+### When to use
+- Task is too large
+- You want step-by-step execution
+
+### Prompt
+
+Break this task into atomic steps.
+
+For each step:
+- goal
+- files involved
+- dependencies
+- risks
+
+Constraints:
+- 3–7 steps max
+- each step must be independently implementable
+- keep changes small
+
+---
+
+## 3. IMPLEMENT
+
+### When to use
+- After plan is validated
+
+### Prompt
+
+Implement ONLY the agreed plan.
+
+Read first:
+- AGENTS.md
+- docs/*
+- docs/tasks/TASK-XXX.md
+
+Rules:
+- Minimal diff
+- No refactor outside scope
+- No new libraries
+- Respect architecture and conventions
+
+At the end:
+1. Modified files
+2. Summary of changes
+3. Commands to test
+4. Remaining risks
+
+---
+
+## 4. STEP IMPLEMENTATION
+
+### When to use
+- When using breakdown approach
+
+### Prompt
+
+Implement ONLY step X.
+
+Do not touch anything outside this step.
+
+Stop after completion.
+
+---
+
+## 5. REVIEW
+
+### When to use
+- Before commit
+- After major change
+
+### Prompt
+
+Review the implementation against:
+
+- docs/tasks/TASK-XXX.md
+- docs/ARCHITECTURE.md
+- docs/CONVENTIONS.md
+
+Check:
+- acceptance criteria
+- architecture violations
+- regression risks
+- missing edge cases
+
+Output:
+1. Issues
+2. Fix suggestions
+3. Risk level
+4. Ready to commit? (yes/no)
+
+---
+
+## 6. ANALYSIS (no code)
+
+### When to use
+- Debugging
+- Understanding codebase
+- Investigating issues
+
+### Prompt
+
+Do NOT modify code.
+
+Analyze:
+- architecture consistency
+- state management
+- API usage
+- potential bugs
+
+Output:
+- what is correct
+- what is fragile
+- what should be improved
+
+---
+
+## 7. TASK GENERATION
+
+### When to use
+- Turning feature idea into executable task
+
+### Prompt
+
+Generate a TASK.md file.
+
+Include:
+- Objective
+- Scope
+- Out of scope
+- Backend section
+- Frontend section
+- API contract
+- Files involved
+- Acceptance criteria
+- Edge cases
+- Constraints
+
+Must be:
+- clear
+- complete
+- self-contained
+
+---
+
+## 8. STRICT MODE
+
+### When to use
+- Agent starts drifting
+- Too many unexpected changes
+
+### Prompt
+
+STRICT MODE:
+
+- No assumptions
+- No extra features
+- No refactoring
+- No architecture changes
+
+Do ONLY what is defined.
+
+If unclear → stop and ask.
+
+---
+
+## 9. ANTI-HALLUCINATION
+
+### When to use
+- Missing info
+- Unclear requirements
+
+### Prompt
+
+If information is missing:
+- do NOT assume
+- do NOT invent
+
+Instead:
+- list missing info
+- propose options
+
+Wait for clarification.
+
+---
+
+## 10. STACK-SPECIFIC (Vue + .NET)
+
+### When to use
+- Reinforce stack constraints
+
+### Prompt
+
+You are working on:
+
+Frontend:
+- Vue 3
+- Pinia
+- Tailwind
+
+Backend:
+- .NET FastEndpoints
+- Modular DbContexts
+
+Rules:
+
+Backend:
+- follow FastEndpoints pattern
+- no cross-module DbContext coupling
+
+Frontend:
+- use Pinia for state
+- no business logic in components
+- use API client
+
+Always align with docs.
+
+---
+
+# 🚨 Rules
+
+- Never start coding without reading docs
+- Never trust conversation history alone
+- Always constrain scope
+- Always review before commit
+
+---
+
+# 🧭 Summary
+
+Bad:
+"Add profile feature"
+
+Good:
+- PLAN
+- IMPLEMENT step 1
+- REVIEW
+- repeat
+
+---
+
+# 🔥 Recommended Usage with CLI
+
+scripts/ai-task plan docs/tasks/TASK-XXX.md
+scripts/ai-task implement docs/tasks/TASK-XXX.md
+scripts/ai-task review docs/tasks/TASK-XXX.md
+
+---
+
+End of document.

backend/.github/workflows/build.yml

@@ -1,82 +0,0 @@
-name: Build
-
-on:
-  pull_request:
-    branches: [ main ]
-    paths-ignore:
-      - '.scripts/**'
-      - .gitignore
-      - CODE_OF_CONDUCT.md
-      - LICENSE
-      - README.md
-
-  workflow_call:
-    inputs:
-      build-artifacts:
-        type: boolean
-        required: true
-        default: false
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v3
-      name: Checkout code
-
-    - name: Cache NuGet packages
-      uses: actions/cache@v3
-      with:
-        path: ~/.nuget/packages
-        key: ${{ runner.os }}-nuget-${{ hashFiles('**/packages.lock.json') }}
-        restore-keys: |
-          ${{ runner.os }}-nuget-
-
-
-    - name: Install .NET
-      uses: actions/setup-dotnet@v3
-
-    - name: Restore solution
-      run: dotnet restore
-
-    - name: Build solution
-      run: dotnet build --no-restore --configuration Release
-      
-    - name: Test solution
-      run: dotnet test --no-build --configuration Release --filter "FullyQualifiedName!~AcceptanceTests"
-
-    - name: Publish website
-      if: ${{ inputs.build-artifacts == true }}
-      run: |
-        dotnet publish --configuration Release --runtime win-x86 --self-contained --output ./publish
-        cd publish
-        zip -r ./publish.zip .
-      working-directory: ./src/Web/
-
-    - name: Upload website artifact (website)
-      if: ${{ inputs.build-artifacts == true }}
-      uses: actions/upload-artifact@v3
-      with:
-        name: website
-        path: ./src/Web/publish/publish.zip
-        if-no-files-found: error
-    
-    - name: Create EF Core migrations bundle
-      if: ${{ inputs.build-artifacts == true }}
-      run: |
-        dotnet new tool-manifest
-        dotnet tool install dotnet-ef
-        dotnet ef migrations bundle --configuration Release -p ./src/Infrastructure/ -s ./src/Web/ -o efbundle.exe
-        zip -r ./efbundle.zip efbundle.exe
-      env:
-        SkipNSwag: True
-
-    - name: Upload EF Core migrations bundle artifact (efbundle)
-      if: ${{ inputs.build-artifacts == true }}
-      uses: actions/upload-artifact@v3
-      with:
-        name: efbundle
-        path: ./efbundle.zip
-        if-no-files-found: error

backend/.github/workflows/cicd.yml

@@ -1,42 +0,0 @@
-name: CICD
-
-on: 
-  push:
-    branches: [ main ]
-    paths-ignore:
-      - .gitignore
-      - CODE_OF_CONDUCT.md
-      - LICENSE
-      - README.md
-
-permissions:
-  id-token: write
-  contents: read
-
-jobs:
-
-  build:
-    uses: ./.github/workflows/build.yml
-    with:
-      build-artifacts: true
-
-  deploy-development:
-    uses: ./.github/workflows/deploy.yml
-    secrets: inherit
-    needs: [ build ]
-    with:
-      environmentName: Development
-
-  deploy-staging:
-    uses: ./.github/workflows/deploy.yml
-    secrets: inherit
-    needs: [ deploy-development ]
-    with:
-      environmentName: Staging
-
-  deploy-production:
-    uses: ./.github/workflows/deploy.yml
-    secrets: inherit
-    needs: [ deploy-staging ]
-    with:
-      environmentName: Production

backend/.github/workflows/deploy.yml

@@ -1,107 +0,0 @@
-name: Deploy
-
-on:
-  workflow_call:
-    inputs:
-      environmentName:
-        required: true
-        type: string
-
-permissions:
-  id-token: write
-  contents: read
-
-jobs:
-  
-  validate:
-     runs-on: ubuntu-latest
-     environment: ${{ inputs.environmentName }}
-
-     steps: 
-
-     - uses: actions/checkout@v3
-       name: Checkout code
-
-     - uses: azure/login@v1
-       name: Login to Azure
-       with:
-         client-id: ${{ vars.AZURE_CLIENT_ID }}
-         tenant-id: ${{ vars.AZURE_TENANT_ID }}
-         subscription-id: ${{ vars.AZURE_SUBSCRIPTION_ID }}
-
-     - if: inputs.environmentName == 'Development'
-       uses: azure/arm-deploy@v1
-       name: Run preflight validation
-       with:
-         deploymentName: ${{ github.run_number }}
-         resourceGroupName: ${{ vars.AZURE_RESOURCE_GROUP_NAME }}
-         template: ./.azure/bicep/main.bicep
-         parameters: >
-           environmentName=${{ inputs.environmentName }}
-           sqlAdministratorUsername=${{ vars.AZURE_SQL_ADMINISTRATOR_USERNAME }}
-           sqlAdministratorPassword=${{ secrets.AZURE_SQL_ADMINISTRATOR_PASSWORD }}
-           projectName=${{ vars.PROJECT_NAME }}
-         deploymentMode: Validate
-
-     - if: inputs.environmentName != 'Development'
-       uses: azure/arm-deploy@v1
-       name: Run what-if
-       with:
-         failOnStdErr: false
-         resourceGroupName: ${{ vars.AZURE_RESOURCE_GROUP_NAME }}
-         template: ./.azure/bicep/main.bicep
-         parameters: >
-           environmentName=${{ inputs.environmentName }}
-           sqlAdministratorUsername=${{ vars.AZURE_SQL_ADMINISTRATOR_USERNAME }}
-           sqlAdministratorPassword=${{ secrets.AZURE_SQL_ADMINISTRATOR_PASSWORD }}
-           projectName=${{ vars.PROJECT_NAME }}
-         additionalArguments: --what-if
- 
-  deploy:
-    needs: [ validate ]
-    runs-on: ubuntu-latest
-    environment: ${{ inputs.environmentName }}
-
-    steps:
-
-    - uses: actions/checkout@v3
-      name: Checkout code
-
-    - uses: actions/download-artifact@v3
-      name: Download artifacts
-
-    - name: Install .NET
-      uses: actions/setup-dotnet@v3
-
-    - uses: azure/login@v1
-      name: Login to Azure
-      with:
-        client-id: ${{ vars.AZURE_CLIENT_ID }}
-        tenant-id: ${{ vars.AZURE_TENANT_ID }}
-        subscription-id: ${{ vars.AZURE_SUBSCRIPTION_ID }}
-
-    - uses: azure/arm-deploy@v1
-      id: deploy
-      name: Deploy infrastructure
-      with:
-        failOnStdErr: false
-        deploymentName: ${{ github.run_number }}
-        resourceGroupName: ${{ vars.AZURE_RESOURCE_GROUP_NAME }}
-        template: ./.azure/bicep/main.bicep
-        parameters: >
-           environmentName=${{ inputs.environmentName }}
-           sqlAdministratorUsername=${{ vars.AZURE_SQL_ADMINISTRATOR_USERNAME }}
-           sqlAdministratorPassword=${{ secrets.AZURE_SQL_ADMINISTRATOR_PASSWORD }}
-           projectName=${{ vars.PROJECT_NAME }}
-
-    - name: Initialise database
-      run: |
-        unzip -o ./efbundle/efbundle.zip
-        echo '{ "ConnectionStrings": { "DefaultConnection": "" } }' > appsettings.json
-        ./efbundle.exe --connection "Server=${{ steps.deploy.outputs.sqlServerFullyQualifiedDomainName }};Initial Catalog=${{ steps.deploy.outputs.sqlDatabaseName }};Persist Security Info=False;User ID=${{ vars.AZURE_SQL_ADMINISTRATOR_USERNAME }};Password=${{ secrets.AZURE_SQL_ADMINISTRATOR_PASSWORD }};MultipleActiveResultSets=False;Encrypt=True;TrustServerCertificate=False;Connection Timeout=30;" --verbose
-
-    - uses: azure/webapps-deploy@v2
-      name: Deploy website
-      with:
-        app-name: ${{ steps.deploy.outputs.appServiceAppName }}
-        package: website/publish.zip

backend/Folder.DotSettings

@@ -1,5 +0,0 @@
-<wpf:ResourceDictionary xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-                        xmlns:s="clr-namespace:System;assembly=mscorlib"
-                        xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
-                        xml:space="preserve">
-	<s:Boolean x:Key="/Default/UserDictionary/Words/=hutopy/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

backend/GlobalUsings.cs

@@ -1,4 +0,0 @@
-global using FastEndpoints;
-global using FluentValidation;
-global using JetBrains.Annotations;
-global using Microsoft.EntityFrameworkCore;

backend/Infrastructure/BlobStorage/Contracts/ContainerNames.cs

@@ -1,7 +0,0 @@
-namespace Hutopy.Infrastructure.BlobStorage.Contracts;
-
-internal static class ContainerNames
-{
-    public const string Users = "users";
-    public const string Creators = "creators";
-}

backend/Infrastructure/BlobStorage/Services/AzureBlobStorage.cs

@@ -1,154 +0,0 @@
-using Azure;
-using Azure.Storage.Blobs;
-using Azure.Storage.Blobs.Models;
-using Hutopy.Infrastructure.BlobStorage.Contracts;
-
-namespace Hutopy.Infrastructure.BlobStorage.Services;
-
-public class AzureBlobStorage : IBlobStorage
-{
-    private const long MaxUploadSize = 10 * 1024 * 1024; // 10 MB in bytes
-
-    private readonly BlobServiceClient _blobServiceClient;
-    private readonly ILogger<AzureBlobStorage> _logger;
-
-    public AzureBlobStorage(IConfiguration configuration, ILogger<AzureBlobStorage> logger)
-    {
-        _logger = logger;
-        string? connectionString = configuration.GetConnectionString("AzureBlob");
-        _blobServiceClient = new BlobServiceClient(connectionString);
-    }
-
-    /// <summary>
-    ///     Upload a file to microsoft azure blob storage.
-    /// </summary>
-    /// <param name="containerName">The name of the container where the file is stored.</param>
-    /// <param name="blobName">The blob name (path within the container, include the file name).</param>
-    /// <param name="stream"></param>
-    /// <param name="contentType">The content type.</param>
-    /// <param name="ct">The cancellation token</param>
-    /// <returns></returns>
-    public async Task<string> UploadFileAsync(
-        string containerName,
-        string blobName,
-        Stream stream,
-        string contentType,
-        CancellationToken ct = default)
-    {
-        // Read the file stream into a memory stream to determine the length
-        // WATCH FOR MEMORY USAGE USING THE MEMORY STREAM.
-        stream.Position = 0;
-
-        // Check if the file size exceeds the maximum upload size
-        if (stream.Length > MaxUploadSize)
-        {
-            _logger.LogError(
-                $"Blob storage: File size exceeds the maximum allowed size of {MaxUploadSize} bytes.");
-            throw new InvalidOperationException(
-                $"Blob storage: File size exceeds the maximum allowed size of {MaxUploadSize} bytes.");
-        }
-
-        // Validate content type
-        if (!ContentTypes.IsAllowed(contentType, stream))
-        {
-            _logger.LogError(
-                $"Blob storage: Unsupported file type {contentType}.");
-            throw new InvalidOperationException("Unsupported file type.");
-        }
-
-        try
-        {
-            // Get a reference to a container
-            BlobContainerClient? containerClient = _blobServiceClient.GetBlobContainerClient(containerName);
-
-            // Create the container if it does not exist
-            await containerClient.CreateIfNotExistsAsync(
-                PublicAccessType.Blob,
-                cancellationToken: ct);
-
-            // Get a reference to a blob
-            BlobClient? blobClient = containerClient.GetBlobClient(blobName);
-
-            // Define the BlobHttpHeaders to include the content type
-            BlobHttpHeaders blobHttpHeaders = new() { ContentType = contentType };
-
-            // Upload the file
-            Response<BlobContentInfo>? response = await blobClient.UploadAsync(
-                stream,
-                new BlobUploadOptions { HttpHeaders = blobHttpHeaders },
-                ct);
-
-            string fileUri = blobClient.Uri.ToString();
-
-            _logger.LogInformation(
-                """
-                Blob storage: Status [   {ResponseStatus}   ] 
-                Uploaded [  {BlobName}  ] to the container [  {ContainerName}  ] 
-                with contentType [  {ContentType}  ] 
-                with a length of [   {StreamLength} bytes   ]
-                with the uri [   {FileUri}   ]
-                """,
-                response.GetRawResponse().Status.ToString(),
-                blobName,
-                containerName,
-                contentType,
-                stream.Length,
-                fileUri
-            );
-
-            // Return the URI of the uploaded blob
-            return fileUri;
-        }
-        catch (RequestFailedException ex)
-        {
-            _logger.LogError($"Blob storage: Azure Storage request failed: {ex.Message}");
-            throw;
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError($"Blob storage: An error occurred: {ex.Message}");
-            throw;
-        }
-    }
-
-    /// <summary>
-    ///     Download a file to microsoft's azure blob storage.
-    /// </summary>
-    /// <param name="blobName">The blob name (path within the container).</param>
-    /// <param name="containerName">The name of the container where the file is stored. (users)</param>
-    /// <param name="ct">The cancellation token for the request</param>
-    /// <returns></returns>
-    public async Task<MemoryStream> DownloadFileAsync(
-        string containerName,
-        string blobName,
-        CancellationToken ct = default)
-    {
-        try
-        {
-            // Get a reference to a container
-            BlobContainerClient? containerClient = _blobServiceClient.GetBlobContainerClient(containerName);
-
-            // Get a reference to a blob
-            BlobClient? blobClient = containerClient.GetBlobClient(blobName);
-
-            // Download the blob to a stream
-            BlobDownloadInfo download = await blobClient.DownloadAsync(ct);
-
-            MemoryStream memoryStream = new();
-            await download.Content.CopyToAsync(memoryStream, ct);
-            memoryStream.Position = 0; // Ensure the stream is at the beginning
-
-            return memoryStream;
-        }
-        catch (RequestFailedException ex)
-        {
-            _logger.LogError($"Azure Storage request failed: {ex.Message}");
-            throw;
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError($"An error occurred: {ex.Message}");
-            throw;
-        }
-    }
-}

backend/Infrastructure/Configuration/WebsiteOptions.cs

@@ -1,8 +0,0 @@
-namespace Hutopy.Infrastructure.Configuration;
-
-public class WebsiteOptions
-{
-    public const string SectionName = "Website";
-
-    public string FrontendBaseUrl { get; set; } = "https://localhost:5173";
-}

backend/Infrastructure/DependencyInjection.cs

@@ -1,40 +0,0 @@
-using Hutopy.Infrastructure.BlobStorage.Contracts;
-using Hutopy.Infrastructure.BlobStorage.Services;
-using Hutopy.Infrastructure.Configuration;
-using Hutopy.Infrastructure.Emailer.Configuration;
-using Hutopy.Infrastructure.Emailer.Contracts;
-using Hutopy.Infrastructure.Emailer.Services;
-using Hutopy.Infrastructure.Payments.Stripe.Configuration;
-using Hutopy.Infrastructure.Payments.Stripe.Services;
-using Hutopy.Modules.Memberships.Contracts;
-using Hutopy.Modules.Tipping.Contracts;
-
-namespace Hutopy.Infrastructure;
-
-public static class DependencyInjection
-{
-    public static WebApplicationBuilder AddInfrastructureModule(
-        this WebApplicationBuilder builder)
-    {
-        builder.Services.Configure<WebsiteOptions>(
-            builder.Configuration.GetRequiredSection(WebsiteOptions.SectionName));
-
-        builder.Services.AddTransient<IBlobStorage, AzureBlobStorage>();
-
-        builder.Services.AddTransient<ITipProcessor, StripeTipProcessor>();
-        builder.Services.AddTransient<IMembershipPaymentProcessor, MembershipPaymentProcessor>();
-        builder.Services.AddTransient<IMembershipCancellationProcessor, MembershipCancellationProcessor>();
-        builder.Services.AddTransient<IMembershipTierProcessor, MembershipTierProcessor>();
-        builder.Services.Configure<StripeOptions>(
-            builder.Configuration.GetSection(StripeOptions.ConfigurationSection));
-
-        builder.Services.Configure<EmailerOptions>(
-            builder.Configuration.GetSection(EmailerOptions.ConfigurationSection));
-        builder.Services.AddTransient<IEmailSender, ResendEmailSender>();
-        //builder.Services.AddTransient<IEmailSender, EmailSender>();
-
-        builder.Services.AddHttpClient();
-
-        return builder;
-    }
-}

backend/Infrastructure/Emailer/Services/LoggerEmailSender.cs

@@ -1,22 +0,0 @@
-using Hutopy.Infrastructure.Emailer.Contracts;
-
-namespace Hutopy.Infrastructure.Emailer.Services;
-
-public class LoggerEmailSender(ILogger<IEmailSender> logger)
-    : IEmailSender
-{
-    public async Task SendEmailAsync(string email, string subject, string message)
-    {
-        try
-        {
-            logger.LogInformation("Sending email to {Email} with subject: {Subject}", email, subject);
-            await Task.Delay(1000);
-            logger.LogInformation("Email sent successfully to {Email}", email);
-        }
-        catch (Exception ex)
-        {
-            logger.LogError(ex, "Failed to send email to {Email}", email);
-            throw;
-        }
-    }
-}

backend/Infrastructure/Payments/Stripe/Services/MembershipCancellationProcessor.cs

@@ -1,28 +0,0 @@
-using Hutopy.Modules.Memberships.Contracts;
-using Stripe;
-
-namespace Hutopy.Infrastructure.Payments.Stripe.Services;
-
-public sealed class MembershipCancellationProcessor
-    : IMembershipCancellationProcessor
-{
-    public async Task<DateTimeOffset?> CancelAsync(
-        string subscriptionId,
-        CancellationToken ct = default)
-    {
-        SubscriptionService subscriptionService = new();
-
-        // Stripe - Cancel Subscription immediately
-        // var subscription = await subscriptionService.CancelAsync(
-        //     subscriptionId,
-        //     cancellationToken: ct);
-
-        // Stripe - Cancel Subscription AtPeriodEnd
-        Subscription? subscription = await subscriptionService.UpdateAsync(
-            subscriptionId,
-            new SubscriptionUpdateOptions { CancelAtPeriodEnd = true },
-            cancellationToken: ct);
-
-        return subscription.CancelAt ?? subscription.CanceledAt;
-    }
-}

backend/Infrastructure/Payments/Stripe/Services/MembershipPaymentProcessor.cs

@@ -1,68 +0,0 @@
-using Hutopy.Infrastructure.Payments.Stripe.Configuration;
-using Hutopy.Modules.Creators.Contracts;
-using Hutopy.Modules.Memberships.Contracts;
-using Microsoft.Extensions.Options;
-using Stripe;
-using Stripe.Checkout;
-
-namespace Hutopy.Infrastructure.Payments.Stripe.Services;
-
-public class MembershipPaymentProcessor(
-    IOptions<StripeOptions> stripeOptions)
-    : IMembershipPaymentProcessor
-{
-    public async Task<MembershipCheckoutSession> CreateCheckoutSessionAsync(
-        Guid userId,
-        CreatorReference creatorReference,
-        Guid tierId,
-        string priceId,
-        string successUrl,
-        string cancelUrl)
-    {
-        StripeConfiguration.ApiKey = stripeOptions.Value.SecretKey;
-
-        // Create Stripe customer for the user if not already created
-        CustomerService customerService = new();
-        Customer? customer = await customerService.CreateAsync(
-            new CustomerCreateOptions
-            {
-                Metadata = new Dictionary<string, string> { { "userId", userId.ToString() } }
-            });
-
-        // Create Checkout Session for the subscription
-        SessionService sessionService = new();
-        Session? session = await sessionService.CreateAsync(
-            new SessionCreateOptions
-            {
-                Customer = customer.Id,
-                PaymentMethodTypes = ["card"],
-                LineItems =
-                [
-                    new SessionLineItemOptions { Price = priceId, Quantity = 1 }
-                ],
-                Mode = "subscription",
-                SubscriptionData = new SessionSubscriptionDataOptions
-                {
-                    ApplicationFeePercent = stripeOptions.Value.HutopyRate,
-                    TransferData =
-                        new SessionSubscriptionDataTransferDataOptions
-                        {
-                            Destination = creatorReference.StripeAccountId
-                        }
-                },
-                SuccessUrl = successUrl, // Redirect after successful payment
-                CancelUrl = cancelUrl, // Redirect after canceled payment
-                Metadata = new Dictionary<string, string>
-                {
-                    { "userId", userId.ToString() },
-                    { "creatorId", creatorReference.Id.ToString() },
-                    { "creatorName", creatorReference.Name },
-                    { "tierId", tierId.ToString() }
-                }
-            });
-
-        return new MembershipCheckoutSession(
-            session.Id,
-            session.Url);
-    }
-}

backend/Infrastructure/Payments/Stripe/Services/MembershipTierProcessor.cs

@@ -1,43 +0,0 @@
-using Hutopy.Infrastructure.Payments.Stripe.Configuration;
-using Hutopy.Modules.Memberships.Contracts;
-using Microsoft.Extensions.Options;
-using Stripe;
-
-namespace Hutopy.Infrastructure.Payments.Stripe.Services;
-
-public sealed class MembershipTierProcessor(
-    IOptions<StripeOptions> stripeOptions)
-    : IMembershipTierProcessor
-{
-    public async Task<string> CreateAsync(
-        Guid creatorId,
-        Guid tierId,
-        string productName,
-        string currencyCode,
-        decimal amount)
-    {
-        StripeConfiguration.ApiKey = stripeOptions.Value.SecretKey;
-
-        // Create the product
-        ProductService productService = new();
-        Product? product = await productService.CreateAsync(
-            new ProductCreateOptions
-            {
-                Name = productName,
-                Metadata = { { "creatorId", creatorId.ToString() }, { "tierId", tierId.ToString() } }
-            });
-
-        // Create the price for the product
-        PriceService priceService = new();
-        await priceService.CreateAsync(
-            new PriceCreateOptions
-            {
-                Product = product.Id,
-                UnitAmountDecimal = amount * 100, // Convert amount to cents
-                Currency = currencyCode,
-                Recurring = new PriceRecurringOptions { Interval = "month" }
-            });
-
-        return product.Id;
-    }
-}

backend/Infrastructure/Payments/Stripe/Services/StripeTipProcessor.cs

@@ -1,70 +0,0 @@
-using Hutopy.Infrastructure.Payments.Stripe.Configuration;
-using Hutopy.Modules.Creators.Contracts;
-using Hutopy.Modules.Tipping.Contracts;
-using Microsoft.Extensions.Options;
-using Stripe;
-using Stripe.Checkout;
-
-namespace Hutopy.Infrastructure.Payments.Stripe.Services;
-
-internal class StripeTipProcessor(
-    IOptions<StripeOptions> stripeOptions)
-    : ITipProcessor
-{
-    public async Task<TipCheckoutSession> CreateCheckoutSessionAsync(
-        Guid tipId,
-        CreatorReference creator,
-        decimal amount,
-        string currency,
-        string message,
-        Uri successUrl,
-        Uri cancelUrl,
-        CancellationToken ct = default)
-    {
-        var applicationFeeAmount = Convert.ToInt64(amount * stripeOptions.Value.HutopyRate);
-
-        StripeConfiguration.ApiKey = stripeOptions.Value.SecretKey;
-
-        var sessionService = new SessionService();
-
-        var options = new SessionCreateOptions
-        {
-            ClientReferenceId = tipId.ToString(),
-            Mode = "payment",
-            LineItems =
-            [
-                new SessionLineItemOptions
-                {
-                    PriceData = new SessionLineItemPriceDataOptions
-                    {
-                        Currency = currency,
-                        UnitAmountDecimal = amount, // Amount in cents
-                        ProductData = new SessionLineItemPriceDataProductDataOptions
-                        {
-                            Name = $"Tip for {creator.Name}",
-                            Metadata = new Dictionary<string, string> { { "creatorId", creator.Id.ToString() } }
-                        }
-                    },
-                    Quantity = 1
-                }
-            ],
-            PaymentIntentData = new SessionPaymentIntentDataOptions { ApplicationFeeAmount = applicationFeeAmount },
-            Metadata = new Dictionary<string, string>
-            {
-                { "creatorId", creator.Id.ToString() }, { "creatorName", creator.Name }, { "message", message }
-            },
-            SuccessUrl = successUrl.ToString(), // Redirect after successful payment
-            CancelUrl = cancelUrl.ToString(), // Redirect after canceled payment
-        };
-
-        var requestOptions = new RequestOptions { StripeAccount = creator.StripeAccountId };
-
-        var session = await sessionService.CreateAsync(
-                options,
-                requestOptions,
-                cancellationToken: ct)
-            .ConfigureAwait(false);
-
-        return new TipCheckoutSession(session.Id, session.Url);
-    }
-}

backend/Infrastructure/Security/KnownClaims.cs

@@ -1,7 +0,0 @@
-namespace Hutopy.Infrastructure.Security;
-
-public static class KnownClaims
-{
-    public const string Alias = "alias";
-    public const string PortraitUrl = "portraitUrl";
-}

backend/Modules/Contents/Data/Album.cs

@@ -1,11 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using Hutopy.Common.Domain;
-
-namespace Hutopy.Modules.Contents.Data;
-
-public class Album : Entity
-{
-    public bool IsDeleted { get; private set; } // private set → EF updates it
-    [MaxLength(255)] public required string Title { get; set; }
-    public IList<AlbumPhoto> Photos { get; set; } = new List<AlbumPhoto>();
-}

backend/Modules/Contents/Data/AlbumPhoto.cs

@@ -1,15 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using Hutopy.Common.Domain;
-
-namespace Hutopy.Modules.Contents.Data;
-
-public class AlbumPhoto : Entity
-{
-    public bool IsDeleted { get; private set; } // private set → EF updates it
-    public Guid AlbumId { get; set; }
-    public Album Album { get; init; } = null!;
-    [MaxLength(2048)] public required string OriginalUrl { get; set; }
-    [MaxLength(2048)] public required string ThumbnailUrl { get; set; }
-    [MaxLength(256)] public string? Caption { get; set; }
-    public int Order { get; set; }
-}

backend/Modules/Contents/Data/ContentsDbContext.cs

@@ -1,56 +0,0 @@
-namespace Hutopy.Modules.Contents.Data;
-
-public class ContentsDbContext(
-    DbContextOptions<ContentsDbContext> options)
-    : DbContext(options)
-{
-    public const string SchemaName = "Content";
-
-    public DbSet<Album> Albums => Set<Album>();
-    public DbSet<AlbumPhoto> AlbumPhotos => Set<AlbumPhoto>();
-
-    protected override void OnModelCreating(
-        ModelBuilder modelBuilder)
-    {
-        modelBuilder.HasDefaultSchema(SchemaName);
-
-        // Album configuration
-        modelBuilder
-            .Entity<Album>()
-            .Property(c => c.CreatedAt)
-            .ValueGeneratedOnAdd()
-            .HasDefaultValueSql("CURRENT_TIMESTAMP");
-
-        modelBuilder
-            .Entity<Album>()
-            .Property(c => c.IsDeleted)
-            .HasComputedColumnSql("\"DeletedAt\" IS NOT NULL", true);
-
-        modelBuilder
-            .Entity<Album>()
-            .HasQueryFilter(a => !a.IsDeleted);
-
-        // AlbumPhoto configuration
-        modelBuilder
-            .Entity<AlbumPhoto>()
-            .Property(c => c.CreatedAt)
-            .ValueGeneratedOnAdd()
-            .HasDefaultValueSql("CURRENT_TIMESTAMP");
-
-        modelBuilder
-            .Entity<AlbumPhoto>()
-            .Property(c => c.IsDeleted)
-            .HasComputedColumnSql("\"DeletedAt\" IS NOT NULL", true);
-
-        modelBuilder
-            .Entity<AlbumPhoto>()
-            .HasOne(ap => ap.Album)
-            .WithMany(a => a.Photos)
-            .HasForeignKey(ap => ap.AlbumId)
-            .IsRequired();
-
-        modelBuilder
-            .Entity<AlbumPhoto>()
-            .HasQueryFilter(ap => !ap.IsDeleted);
-    }
-}

backend/Modules/Contents/DependencyInjection.cs

@@ -1,27 +0,0 @@
-using Hutopy.Modules.Contents.Data;
-
-namespace Hutopy.Modules.Contents;
-
-public static class DependencyInjection
-{
-    public static WebApplicationBuilder AddContentModule(
-        this WebApplicationBuilder builder,
-        Action<DbContextOptionsBuilder>? configureAction = null)
-    {
-        builder.Services.AddDbContext<ContentsDbContext>(configureAction);
-
-        return builder;
-    }
-
-    public static async Task<IApplicationBuilder> UseContentModuleAsync(
-        this IApplicationBuilder app,
-        CancellationToken cancellationToken = default)
-    {
-        IServiceScopeFactory scopeFactory = app.ApplicationServices.GetRequiredService<IServiceScopeFactory>();
-        using IServiceScope scope = scopeFactory.CreateScope();
-        await using ContentsDbContext context = scope.ServiceProvider.GetRequiredService<ContentsDbContext>();
-        await context.Database.MigrateAsync(cancellationToken);
-
-        return app;
-    }
-}

backend/Modules/Contents/Features/AddPhotoToAlbum.cs

@@ -1,195 +0,0 @@
-using Hutopy.Infrastructure.BlobStorage.Contracts;
-using Hutopy.Infrastructure.Security;
-using Hutopy.Modules.Contents.Data;
-using SixLabors.ImageSharp;
-using SixLabors.ImageSharp.Processing;
-
-namespace Hutopy.Modules.Contents.Features;
-
-[PublicAPI]
-public record AddPhotoToAlbumRequest(
-    Guid AlbumId,
-    Guid PhotoId,
-    IFormFile File,
-    string? Caption = null);
-
-[PublicAPI]
-public record AddPhotoToAlbumResponse(
-    Guid PhotoId,
-    string OriginalUrl,
-    string ThumbnailUrl);
-
-[PublicAPI]
-public sealed class AddPhotoToAlbumRequestValidator : Validator<AddPhotoToAlbumRequest>
-{
-    private const int MaxFileSizeBytes = 10 * 1024 * 1024; // 10MB
-
-    private static readonly string[] AllowedImageTypes =
-    [
-        "image/jpeg",
-        "image/png",
-        "image/gif",
-        "image/webp"
-    ];
-
-    public AddPhotoToAlbumRequestValidator()
-    {
-        RuleFor(x => x.AlbumId)
-            .NotNull()
-            .NotEmpty();
-
-        RuleFor(x => x.PhotoId)
-            .NotNull()
-            .NotEmpty();
-
-        RuleFor(x => x.File)
-            .NotNull()
-            .NotEmpty()
-            .Must(file => AllowedImageTypes.Contains(file.ContentType))
-            .WithMessage("File must be a valid image (JPEG, PNG, GIF, or WebP)")
-            .Must(file => file.Length <= MaxFileSizeBytes)
-            .WithMessage($"File size must not exceed {MaxFileSizeBytes / 1024 / 1024}MB");
-
-        RuleFor(x => x.Caption)
-            .MaximumLength(255);
-    }
-}
-
-[PublicAPI]
-public class AddPhotoToAlbumHandler(
-    ContentsDbContext context,
-    IBlobStorage blobStorage)
-    : Endpoint<AddPhotoToAlbumRequest, AddPhotoToAlbumResponse>
-{
-    private const int MaxThumbnailWidth = 500;
-    private const int MaxThumbnailHeight = 500;
-
-    public override void Configure()
-    {
-        Post("/api/albums/{AlbumId}/photos");
-        Options(o => o.WithTags("Albums"));
-        AllowFileUploads();
-    }
-
-    public override async Task HandleAsync(
-        AddPhotoToAlbumRequest request,
-        CancellationToken ct)
-    {
-        Guid userId = User.GetUserId();
-
-        // Fetch the album we want to add photos to
-        Album? album = await context
-            .Albums
-            .SingleOrDefaultAsync(
-                a => a.Id == request.AlbumId && a.CreatedBy == userId,
-                ct);
-
-        if (album is null)
-        {
-            await SendNotFoundAsync(ct);
-            return;
-        }
-
-        // Check if a photo with the same ID already exists
-        bool existingPhoto = await context
-            .AlbumPhotos
-            .AnyAsync(p => p.Id == request.PhotoId, ct);
-
-        if (existingPhoto)
-        {
-            await SendErrorsAsync(409, ct);
-            return;
-        }
-
-        try
-        {
-            (string originalUrl, string thumbnailUrl) = await ProcessAndUploadImage(request, ct);
-
-            // Get the next order number
-            int nextOrder = await context
-                .AlbumPhotos
-                .Where(p => p.AlbumId == request.AlbumId)
-                .MaxAsync(p => (int?)p.Order, ct) ?? 0;
-
-            // Create the album photo
-            AlbumPhoto photo = new()
-            {
-                Id = request.PhotoId,
-                CreatedBy = userId,
-                AlbumId = request.AlbumId,
-                OriginalUrl = originalUrl,
-                ThumbnailUrl = thumbnailUrl,
-                Caption = request.Caption,
-                Order = nextOrder + 1
-            };
-
-            context.AlbumPhotos.Add(photo);
-            await context.SaveChangesAsync(ct);
-
-            await SendOkAsync(
-                new AddPhotoToAlbumResponse(photo.Id, originalUrl, thumbnailUrl),
-                ct);
-        }
-        catch (UnknownImageFormatException)
-        {
-            await SendStringAsync("Invalid image format", 400, cancellation: ct);
-        }
-        catch (Exception)
-        {
-            await SendStringAsync("Error processing image", 500, cancellation: ct);
-        }
-    }
-
-    private async Task<(string originalUrl, string thumbnailUrl)> ProcessAndUploadImage(
-        AddPhotoToAlbumRequest request,
-        CancellationToken ct)
-    {
-        string originalFileName = Path.GetFileName(request.File.FileName);
-        string nameWithoutExt = Path.GetFileNameWithoutExtension(originalFileName);
-        string extension = Path.GetExtension(originalFileName);
-
-        string filenameOriginal = $"{nameWithoutExt}{extension}";
-        string filenameThumbnail = $"{nameWithoutExt}.thumbnail{extension}";
-
-        string blobOriginal = $"{SubDirectoryNames.Albums}/{request.AlbumId}/{filenameOriginal}";
-        string blobThumbnail = $"{SubDirectoryNames.Albums}/{request.AlbumId}/{filenameThumbnail}";
-
-        // Process the original image
-        await using Stream originalStream = request.File.OpenReadStream();
-        using Image image = await Image.LoadAsync(originalStream, ct);
-
-        // Calculate target size while preserving the original aspect ratio
-        int originalWidth = image.Width;
-        int originalHeight = image.Height;
-
-        double ratioX = (double)MaxThumbnailWidth / originalWidth;
-        double ratioY = (double)MaxThumbnailHeight / originalHeight;
-        double ratio = Math.Min(ratioX, ratioY);
-
-        int newWidth = (int)(originalWidth * ratio);
-        int newHeight = (int)(originalHeight * ratio);
-
-        // Create thumbnail
-        using MemoryStream thumbnailStream = new();
-        image.Mutate(x => x.Resize(newWidth, newHeight));
-        await image.SaveAsync(thumbnailStream, image.Metadata.DecodedImageFormat!, ct);
-        thumbnailStream.Position = 0;
-
-        // Upload both versions
-        string originalUrl = await blobStorage.UploadFileAsync(
-            ContainerNames.Creators,
-            blobOriginal,
-            request.File.OpenReadStream(),
-            request.File.ContentType,
-            ct);
-
-        string thumbnailUrl = await blobStorage.UploadFileAsync(
-            ContainerNames.Creators,
-            blobThumbnail,
-            thumbnailStream,
-            request.File.ContentType,
-            ct);
-
-        return (originalUrl, thumbnailUrl);
-    }
-}

backend/Modules/Contents/Features/CreateAlbum.cs

@@ -1,70 +0,0 @@
-using Hutopy.Infrastructure.Security;
-using Hutopy.Modules.Contents.Data;
-
-namespace Hutopy.Modules.Contents.Features;
-
-[PublicAPI]
-public record CreateAlbumRequest(
-    Guid AlbumId,
-    string Title,
-    string? Description = null);
-
-[PublicAPI]
-public record CreateAlbumResponse(
-    Guid AlbumId);
-
-[PublicAPI]
-public sealed class CreateAlbumRequestValidator : Validator<CreateAlbumRequest>
-{
-    public CreateAlbumRequestValidator()
-    {
-        RuleFor(x => x.AlbumId)
-            .NotNull()
-            .NotEmpty();
-
-        RuleFor(x => x.Title)
-            .NotNull()
-            .NotEmpty()
-            .MaximumLength(255);
-
-        RuleFor(x => x.Description)
-            .MaximumLength(1000);
-    }
-}
-
-[PublicAPI]
-public class CreateAlbumHandler(
-    ContentsDbContext context)
-    : Endpoint<CreateAlbumRequest, CreateAlbumResponse>
-{
-    public override void Configure()
-    {
-        Post("/api/albums");
-        Options(o => o.WithTags("Albums"));
-    }
-
-    public override async Task HandleAsync(
-        CreateAlbumRequest request,
-        CancellationToken ct)
-    {
-        // Check if an album with the same ID already exists
-        bool existingAlbum = await context
-            .Albums
-            .AnyAsync(a => a.Id == request.AlbumId, ct);
-
-        if (existingAlbum)
-        {
-            await SendErrorsAsync(409, ct);
-            return;
-        }
-
-        Album album = new() { Id = request.AlbumId, CreatedBy = User.GetUserId(), Title = request.Title };
-
-        context.Albums.Add(album);
-        await context.SaveChangesAsync(ct);
-
-        await SendOkAsync(
-            new CreateAlbumResponse(album.Id),
-            ct);
-    }
-}

backend/Modules/Contents/Features/GetAlbum.cs

@@ -1,83 +0,0 @@
-using Hutopy.Modules.Contents.Data;
-
-namespace Hutopy.Modules.Contents.Features;
-
-[PublicAPI]
-public record GetAlbumRequest(
-    Guid AlbumId);
-
-[PublicAPI]
-public record AlbumPhotoDto(
-    Guid Id,
-    string OriginalUrl,
-    string ThumbnailUrl,
-    string? Caption,
-    int Order,
-    DateTimeOffset CreatedAt);
-
-[PublicAPI]
-public record GetAlbumResponse(
-    Guid Id,
-    string Title,
-    IReadOnlyList<AlbumPhotoDto> Photos,
-    DateTimeOffset CreatedAt);
-
-[PublicAPI]
-public sealed class GetAlbumRequestValidator : Validator<GetAlbumRequest>
-{
-    public GetAlbumRequestValidator()
-    {
-        RuleFor(x => x.AlbumId)
-            .NotNull()
-            .NotEmpty();
-    }
-}
-
-[PublicAPI]
-public class GetAlbumHandler(
-    ContentsDbContext context)
-    : Endpoint<GetAlbumRequest, GetAlbumResponse>
-{
-    public override void Configure()
-    {
-        AllowAnonymous();
-        Get("/api/albums/{AlbumId}");
-        Options(o => o.WithTags("Albums"));
-    }
-
-    public override async Task HandleAsync(
-        GetAlbumRequest request,
-        CancellationToken ct)
-    {
-        Album? album = await context
-            .Albums
-            .Include(a => a.Photos.OrderBy(p => p.Order))
-            .SingleOrDefaultAsync(
-                a => a.Id == request.AlbumId,
-                ct);
-
-        if (album is null)
-        {
-            await SendNotFoundAsync(ct);
-            return;
-        }
-
-        List<AlbumPhotoDto> photos = album.Photos
-            .Select(p => new AlbumPhotoDto(
-                p.Id,
-                p.OriginalUrl,
-                p.ThumbnailUrl,
-                p.Caption,
-                p.Order,
-                p.CreatedAt))
-            .ToList();
-
-        await SendOkAsync(
-            new GetAlbumResponse(
-                album.Id,
-                album.Title,
-                photos,
-                album.CreatedAt),
-            ct);
-    }
-}

backend/Modules/Contents/Features/RemoveAlbum.cs

@@ -1,66 +0,0 @@
-using Hutopy.Infrastructure.Security;
-using Hutopy.Modules.Contents.Data;
-
-namespace Hutopy.Modules.Contents.Features;
-
-[PublicAPI]
-public record RemoveAlbumRequest(
-    Guid AlbumId);
-
-[PublicAPI]
-public sealed class RemoveAlbumRequestValidator : Validator<RemoveAlbumRequest>
-{
-    public RemoveAlbumRequestValidator()
-    {
-        RuleFor(x => x.AlbumId)
-            .NotNull()
-            .NotEmpty();
-    }
-}
-
-[PublicAPI]
-public class RemoveAlbumHandler(
-    ContentsDbContext context)
-    : Endpoint<RemoveAlbumRequest>
-{
-    public override void Configure()
-    {
-        Delete("/api/albums/{AlbumId}");
-        Options(o => o.WithTags("Albums"));
-    }
-
-    public override async Task HandleAsync(
-        RemoveAlbumRequest request,
-        CancellationToken ct)
-    {
-        Guid userId = User.GetUserId();
-
-        Album? album = await context
-            .Albums
-            .Include(a => a.Photos)
-            .SingleOrDefaultAsync(
-                a => a.Id == request.AlbumId && a.CreatedBy == userId,
-                ct);
-
-        if (album is null)
-        {
-            await SendNotFoundAsync(ct);
-            return;
-        }
-
-        // Soft delete the album
-        album.DeletedBy = userId;
-        album.DeletedAt = DateTimeOffset.UtcNow;
-
-        // Soft delete all photos in the album
-        foreach (AlbumPhoto photo in album.Photos)
-        {
-            photo.DeletedBy = userId;
-            photo.DeletedAt = DateTimeOffset.UtcNow;
-        }
-
-        await context.SaveChangesAsync(ct);
-
-        await SendNoContentAsync(ct);
-    }
-}

backend/Modules/Contents/Features/RemovePhotoFromAlbum.cs

@@ -1,73 +0,0 @@
-using Hutopy.Infrastructure.Security;
-using Hutopy.Modules.Contents.Data;
-
-namespace Hutopy.Modules.Contents.Features;
-
-[PublicAPI]
-public record RemovePhotoFromAlbumRequest(
-    Guid AlbumId,
-    Guid PhotoId);
-
-[PublicAPI]
-public sealed class RemovePhotoFromAlbumRequestValidator : Validator<RemovePhotoFromAlbumRequest>
-{
-    public RemovePhotoFromAlbumRequestValidator()
-    {
-        RuleFor(x => x.AlbumId)
-            .NotNull()
-            .NotEmpty();
-
-        RuleFor(x => x.PhotoId)
-            .NotNull()
-            .NotEmpty();
-    }
-}
-
-[PublicAPI]
-public class RemovePhotoFromAlbumHandler(
-    ContentsDbContext context)
-    : Endpoint<RemovePhotoFromAlbumRequest>
-{
-    public override void Configure()
-    {
-        Delete("/api/albums/{AlbumId}/photos/{PhotoId}");
-        Options(o => o.WithTags("Albums"));
-    }
-
-    public override async Task HandleAsync(
-        RemovePhotoFromAlbumRequest request,
-        CancellationToken ct)
-    {
-        Guid userId = User.GetUserId();
-
-        Album? album = await context
-            .Albums
-            .Include(a => a.Photos)
-            .SingleOrDefaultAsync(
-                a => a.Id == request.AlbumId && a.CreatedBy == userId,
-                ct);
-
-        if (album is null)
-        {
-            await SendNotFoundAsync(ct);
-            return;
-        }
-
-        AlbumPhoto? photo = album.Photos
-            .SingleOrDefault(p => p.Id == request.PhotoId);
-
-        if (photo is null)
-        {
-            await SendNotFoundAsync(ct);
-            return;
-        }
-
-        // Soft delete the photo
-        photo.DeletedBy = userId;
-        photo.DeletedAt = DateTimeOffset.UtcNow;
-
-        await context.SaveChangesAsync(ct);
-
-        await SendNoContentAsync(ct);
-    }
-}

backend/Modules/Contents/Migrations/20250609212411_Initial.Designer.cs

@@ -1,134 +0,0 @@
-// <auto-generated />
-using System;
-using Hutopy.Modules.Contents.Data;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Infrastructure;
-using Microsoft.EntityFrameworkCore.Migrations;
-using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
-using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
-
-#nullable disable
-
-namespace Hutopy.Modules.Contents.Migrations
-{
-    [DbContext(typeof(ContentsDbContext))]
-    [Migration("20250609212411_Initial")]
-    partial class Initial
-    {
-        /// <inheritdoc />
-        protected override void BuildTargetModel(ModelBuilder modelBuilder)
-        {
-#pragma warning disable 612, 618
-            modelBuilder
-                .HasDefaultSchema("Content")
-                .HasAnnotation("ProductVersion", "9.0.3")
-                .HasAnnotation("Relational:MaxIdentifierLength", 63);
-
-            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
-
-            modelBuilder.Entity("Hutopy.Modules.Contents.Data.Album", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTimeOffset>("CreatedAt")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("timestamp with time zone")
-                        .HasDefaultValueSql("CURRENT_TIMESTAMP");
-
-                    b.Property<Guid>("CreatedBy")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTimeOffset?>("DeletedAt")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<Guid?>("DeletedBy")
-                        .HasColumnType("uuid");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAddOrUpdate()
-                        .HasColumnType("boolean")
-                        .HasComputedColumnSql("\"DeletedAt\" IS NOT NULL", true);
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasMaxLength(255)
-                        .HasColumnType("character varying(255)");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Albums", "Content");
-                });
-
-            modelBuilder.Entity("Hutopy.Modules.Contents.Data.AlbumPhoto", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("AlbumId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("Caption")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<DateTimeOffset>("CreatedAt")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("timestamp with time zone")
-                        .HasDefaultValueSql("CURRENT_TIMESTAMP");
-
-                    b.Property<Guid>("CreatedBy")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTimeOffset?>("DeletedAt")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<Guid?>("DeletedBy")
-                        .HasColumnType("uuid");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAddOrUpdate()
-                        .HasColumnType("boolean")
-                        .HasComputedColumnSql("\"DeletedAt\" IS NOT NULL", true);
-
-                    b.Property<int>("Order")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("OriginalUrl")
-                        .IsRequired()
-                        .HasMaxLength(2048)
-                        .HasColumnType("character varying(2048)");
-
-                    b.Property<string>("ThumbnailUrl")
-                        .IsRequired()
-                        .HasMaxLength(2048)
-                        .HasColumnType("character varying(2048)");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("AlbumId");
-
-                    b.ToTable("AlbumPhotos", "Content");
-                });
-
-            modelBuilder.Entity("Hutopy.Modules.Contents.Data.AlbumPhoto", b =>
-                {
-                    b.HasOne("Hutopy.Modules.Contents.Data.Album", "Album")
-                        .WithMany("Photos")
-                        .HasForeignKey("AlbumId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Album");
-                });
-
-            modelBuilder.Entity("Hutopy.Modules.Contents.Data.Album", b =>
-                {
-                    b.Navigation("Photos");
-                });
-#pragma warning restore 612, 618
-        }
-    }
-}

backend/Modules/Contents/Migrations/20250609212411_Initial.cs

@@ -1,83 +0,0 @@
-using System;
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace Hutopy.Modules.Contents.Migrations
-{
-    /// <inheritdoc />
-    public partial class Initial : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.EnsureSchema(
-                name: "Content");
-
-            migrationBuilder.CreateTable(
-                name: "Albums",
-                schema: "Content",
-                columns: table => new
-                {
-                    Id = table.Column<Guid>(type: "uuid", nullable: false),
-                    IsDeleted = table.Column<bool>(type: "boolean", nullable: false, computedColumnSql: "\"DeletedAt\" IS NOT NULL", stored: true),
-                    Title = table.Column<string>(type: "character varying(255)", maxLength: 255, nullable: false),
-                    CreatedBy = table.Column<Guid>(type: "uuid", nullable: false),
-                    CreatedAt = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false, defaultValueSql: "CURRENT_TIMESTAMP"),
-                    DeletedBy = table.Column<Guid>(type: "uuid", nullable: true),
-                    DeletedAt = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: true)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_Albums", x => x.Id);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "AlbumPhotos",
-                schema: "Content",
-                columns: table => new
-                {
-                    Id = table.Column<Guid>(type: "uuid", nullable: false),
-                    IsDeleted = table.Column<bool>(type: "boolean", nullable: false, computedColumnSql: "\"DeletedAt\" IS NOT NULL", stored: true),
-                    AlbumId = table.Column<Guid>(type: "uuid", nullable: false),
-                    OriginalUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: false),
-                    ThumbnailUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: false),
-                    Caption = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
-                    Order = table.Column<int>(type: "integer", nullable: false),
-                    CreatedBy = table.Column<Guid>(type: "uuid", nullable: false),
-                    CreatedAt = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false, defaultValueSql: "CURRENT_TIMESTAMP"),
-                    DeletedBy = table.Column<Guid>(type: "uuid", nullable: true),
-                    DeletedAt = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: true)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_AlbumPhotos", x => x.Id);
-                    table.ForeignKey(
-                        name: "FK_AlbumPhotos_Albums_AlbumId",
-                        column: x => x.AlbumId,
-                        principalSchema: "Content",
-                        principalTable: "Albums",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateIndex(
-                name: "IX_AlbumPhotos_AlbumId",
-                schema: "Content",
-                table: "AlbumPhotos",
-                column: "AlbumId");
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropTable(
-                name: "AlbumPhotos",
-                schema: "Content");
-
-            migrationBuilder.DropTable(
-                name: "Albums",
-                schema: "Content");
-        }
-    }
-}

backend/Modules/Contents/Migrations/ContentsDbContextModelSnapshot.cs

@@ -1,131 +0,0 @@
-// <auto-generated />
-using System;
-using Hutopy.Modules.Contents.Data;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Infrastructure;
-using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
-using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
-
-#nullable disable
-
-namespace Hutopy.Modules.Contents.Migrations
-{
-    [DbContext(typeof(ContentsDbContext))]
-    partial class ContentsDbContextModelSnapshot : ModelSnapshot
-    {
-        protected override void BuildModel(ModelBuilder modelBuilder)
-        {
-#pragma warning disable 612, 618
-            modelBuilder
-                .HasDefaultSchema("Content")
-                .HasAnnotation("ProductVersion", "9.0.3")
-                .HasAnnotation("Relational:MaxIdentifierLength", 63);
-
-            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
-
-            modelBuilder.Entity("Hutopy.Modules.Contents.Data.Album", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTimeOffset>("CreatedAt")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("timestamp with time zone")
-                        .HasDefaultValueSql("CURRENT_TIMESTAMP");
-
-                    b.Property<Guid>("CreatedBy")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTimeOffset?>("DeletedAt")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<Guid?>("DeletedBy")
-                        .HasColumnType("uuid");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAddOrUpdate()
-                        .HasColumnType("boolean")
-                        .HasComputedColumnSql("\"DeletedAt\" IS NOT NULL", true);
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasMaxLength(255)
-                        .HasColumnType("character varying(255)");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Albums", "Content");
-                });
-
-            modelBuilder.Entity("Hutopy.Modules.Contents.Data.AlbumPhoto", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("AlbumId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("Caption")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<DateTimeOffset>("CreatedAt")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("timestamp with time zone")
-                        .HasDefaultValueSql("CURRENT_TIMESTAMP");
-
-                    b.Property<Guid>("CreatedBy")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTimeOffset?>("DeletedAt")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<Guid?>("DeletedBy")
-                        .HasColumnType("uuid");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAddOrUpdate()
-                        .HasColumnType("boolean")
-                        .HasComputedColumnSql("\"DeletedAt\" IS NOT NULL", true);
-
-                    b.Property<int>("Order")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("OriginalUrl")
-                        .IsRequired()
-                        .HasMaxLength(2048)
-                        .HasColumnType("character varying(2048)");
-
-                    b.Property<string>("ThumbnailUrl")
-                        .IsRequired()
-                        .HasMaxLength(2048)
-                        .HasColumnType("character varying(2048)");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("AlbumId");
-
-                    b.ToTable("AlbumPhotos", "Content");
-                });
-
-            modelBuilder.Entity("Hutopy.Modules.Contents.Data.AlbumPhoto", b =>
-                {
-                    b.HasOne("Hutopy.Modules.Contents.Data.Album", "Album")
-                        .WithMany("Photos")
-                        .HasForeignKey("AlbumId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Album");
-                });
-
-            modelBuilder.Entity("Hutopy.Modules.Contents.Data.Album", b =>
-                {
-                    b.Navigation("Photos");
-                });
-#pragma warning restore 612, 618
-        }
-    }
-}

backend/Modules/Contents/Models/ContentModel.cs

@@ -1,18 +0,0 @@
-namespace Hutopy.Modules.Contents.Models;
-
-[PublicAPI]
-public class ContentModel
-{
-    public required Guid Id { get; init; }
-    public required Guid CreatedBy { get; init; }
-    public required string CreatedByName { get; init; }
-    public required string? CreatedByPortraitUrl { get; init; }
-    public required DateTimeOffset CreatedAt { get; init; }
-    public Guid? DeletedBy { get; init; }
-    public DateTimeOffset? DeletedAt { get; init; }
-    public required string Title { get; init; }
-    public required string Description { get; init; }
-    public string HtmlFileUrl { get; init; } = "";
-    public required string[]? Urls { get; init; }
-    public string? ThumbnailUrl { get; init; }
-}

backend/Modules/Contents/Models/FollowModel.cs

@@ -1,7 +0,0 @@
-namespace Hutopy.Modules.Contents.Models;
-
-[PublicAPI]
-public record FollowModel(
-    Guid CreatorId,
-    string CreatorName,
-    string? CreatorPortraitUrl);

backend/Modules/Creators/Configuration/CreatorOptions.cs

@@ -1,8 +0,0 @@
-namespace Hutopy.Modules.Creators.Configuration;
-
-public class CreatorOptions
-{
-    public const string ConfigurationSection = "Creators";
-
-    public TimeSpan SlugReservationDuration { get; set; }
-}

backend/Modules/Creators/Contracts/CreatorReference.cs

@@ -1,9 +0,0 @@
-namespace Hutopy.Modules.Creators.Contracts;
-
-public record CreatorReference(
-    Guid Id,
-    string Name,
-    string? PortraitUrl,
-    bool OnboardingComplete,
-    bool AcceptCharges,
-    string? StripeAccountId);

backend/Modules/Creators/Contracts/ICreatorLookup.cs

@@ -1,6 +0,0 @@
-namespace Hutopy.Modules.Creators.Contracts;
-
-public interface ICreatorLookup
-{
-    Task<CreatorReference?> GetCreatorAsync(Guid creatorId, CancellationToken cancellationToken = default);
-}

backend/Modules/Creators/Data/Creator.cs

@@ -1,32 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-
-namespace Hutopy.Modules.Creators.Data;
-
-public class Creator
-{
-    public Guid Id { get; set; }
-
-    public Guid CreatedBy { get; set; }
-    public DateTimeOffset CreatedAt { get; init; }
-    public Guid? DeletedBy { get; set; }
-    public DateTimeOffset? DeletedAt { get; set; }
-
-    /// <summary>
-    ///     Soft‑delete flag (false by default, true once DeletedAt is set)
-    /// </summary>
-    public bool IsDeleted { get; private set; } // private set → EF updates it
-
-    [MaxLength(2048)] public string? BannerUrl { get; set; }
-    [MaxLength(2048)] public string? PortraitUrl { get; set; }
-    public bool Verified { get; set; }
-    [MaxLength(256)] public required string Name { get; set; }
-    [MaxLength(128)] public required string Slug { get; set; }
-    [MaxLength(256)] public string? Title { get; set; }
-
-    [MaxLength(21)] public string? StripeAccountId { get; set; }
-    public bool IsStripeDetailsSubmitted { get; set; }
-    public bool IsStripePayoutReady { get; set; }
-    public bool IsStripeChargesEnabled { get; set; }
-    public Socials Socials { get; set; } = new();
-    public Presentation Presentation { get; set; } = new() { Description = "Welcome to my profile!" };
-}

backend/Modules/Creators/Data/CreatorsDbContext.cs

@@ -1,46 +0,0 @@
-namespace Hutopy.Modules.Creators.Data;
-
-public class CreatorsDbContext(
-    DbContextOptions<CreatorsDbContext> options)
-    : DbContext(options)
-{
-    public const string SchemaName = "Creators";
-
-    public DbSet<Creator> Creators => Set<Creator>();
-    public DbSet<Slugs> Slugs => Set<Slugs>();
-
-    protected override void OnModelCreating(
-        ModelBuilder modelBuilder)
-    {
-        modelBuilder.HasDefaultSchema(SchemaName);
-
-        modelBuilder
-            .Entity<Slugs>()
-            .Property(x => x.NormalizedName)
-            .HasComputedColumnSql("LOWER(\"Name\")", true);
-
-        modelBuilder
-            .Entity<Slugs>()
-            .HasIndex(x => x.NormalizedName)
-            .IsUnique();
-
-        modelBuilder
-            .Entity<Creator>()
-            .Property(c => c.IsDeleted)
-            .HasComputedColumnSql("\"DeletedAt\" IS NOT NULL", true); // bool
-
-        modelBuilder
-            .Entity<Creator>()
-            .OwnsOne<Socials>(x => x.Socials)
-            .ToTable(nameof(Socials));
-
-        modelBuilder
-            .Entity<Creator>()
-            .OwnsOne<Presentation>(x => x.Presentation)
-            .ToTable(nameof(Presentation));
-
-        modelBuilder
-            .Entity<Creator>()
-            .HasQueryFilter(c => !c.IsDeleted);
-    }
-}

backend/Modules/Creators/Data/Presentation.cs

@@ -1,11 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-
-namespace Hutopy.Modules.Creators.Data;
-
-public class Presentation
-{
-    public string Description { get; set; } = null!;
-    [MaxLength(2048)] public string? VideoUrl { get; set; }
-    [MaxLength(256)] public string? PhoneNumber { get; set; }
-    [MaxLength(256)] public string? Email { get; set; }
-}

backend/Modules/Creators/Data/Slugs.cs

@@ -1,14 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-
-namespace Hutopy.Modules.Creators.Data;
-
-public class Slugs
-{
-    public Guid Id { get; set; }
-    public Guid CreatedBy { get; set; }
-    public DateTimeOffset CreatedAt { get; init; }
-    public Guid? UsedBy { get; set; }
-    [MaxLength(128)] public string Name { get; set; } = null!;
-    [MaxLength(128)] public string NormalizedName { get; set; } = null!;
-    public DateTimeOffset ReservedUntil { get; set; }
-}

backend/Modules/Creators/Data/Socials.cs

@@ -1,15 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-
-namespace Hutopy.Modules.Creators.Data;
-
-public class Socials
-{
-    [MaxLength(2048)] public string? FacebookUrl { get; set; }
-    [MaxLength(2048)] public string? InstagramUrl { get; set; }
-    [MaxLength(2048)] public string? XUrl { get; set; }
-    [MaxLength(2048)] public string? LinkedInUrl { get; set; }
-    [MaxLength(2048)] public string? TikTokUrl { get; set; }
-    [MaxLength(2048)] public string? YoutubeUrl { get; set; }
-    [MaxLength(2048)] public string? RedditUrl { get; set; }
-    [MaxLength(2048)] public string? WebsiteUrl { get; set; }
-}

backend/Modules/Creators/DependencyInjection.cs

@@ -1,35 +0,0 @@
-using Hutopy.Modules.Creators.Configuration;
-using Hutopy.Modules.Creators.Contracts;
-using Hutopy.Modules.Creators.Data;
-using Hutopy.Modules.Creators.Services;
-
-namespace Hutopy.Modules.Creators;
-
-public static class DependencyInjection
-{
-    public static WebApplicationBuilder AddCreatorModule(
-        this WebApplicationBuilder builder,
-        Action<DbContextOptionsBuilder>? configureAction = null)
-    {
-        builder.Services.Configure<CreatorOptions>(
-            builder.Configuration.GetSection(CreatorOptions.ConfigurationSection));
-        builder.Services.AddScoped<SlugPurger>();
-
-        builder.Services.AddDbContext<CreatorsDbContext>(configureAction);
-        builder.Services.AddTransient<ICreatorLookup, CreatorLookup>();
-
-        return builder;
-    }
-
-    public static async Task<IApplicationBuilder> UseCreatorModuleAsync(
-        this IApplicationBuilder app,
-        CancellationToken cancellationToken = default)
-    {
-        IServiceScopeFactory scopeFactory = app.ApplicationServices.GetRequiredService<IServiceScopeFactory>();
-        using IServiceScope scope = scopeFactory.CreateScope();
-        await using CreatorsDbContext context = scope.ServiceProvider.GetRequiredService<CreatorsDbContext>();
-        await context.Database.MigrateAsync(cancellationToken);
-
-        return app;
-    }
-}

backend/Modules/Creators/Features/ChangeBanner.cs

@@ -1,60 +0,0 @@
-using Hutopy.Infrastructure.BlobStorage.Contracts;
-using Hutopy.Modules.Creators.Data;
-
-namespace Hutopy.Modules.Creators.Features;
-
-[PublicAPI]
-public static class ChangeBanner
-{
-    public record Request(
-        Guid CreatorId,
-        IFormFile File);
-
-    public record Response(
-        string BlobUrl);
-
-    public class Handler(
-        CreatorsDbContext context,
-        IBlobStorage blobStorage)
-        : Endpoint<Request, Response>
-    {
-        public override void Configure()
-        {
-            Post("/api/creators/{CreatorId}/banner");
-            Options(o => o.WithTags("Creators"));
-            AllowFileUploads();
-        }
-
-        public override async Task HandleAsync(
-            Request request,
-            CancellationToken ct)
-        {
-            Creator? creator = await context
-                .Creators
-                .SingleOrDefaultAsync(
-                    c => c.Id == request.CreatorId,
-                    ct);
-
-            if (creator is null)
-            {
-                await SendNotFoundAsync(ct);
-                return;
-            }
-
-            string blobUrl = await blobStorage.UploadFileAsync(
-                ContainerNames.Creators,
-                $"{request.CreatorId}/{SubDirectoryNames.Profile}/{CommonFileNames.BannerPicture}",
-                request.File.OpenReadStream(),
-                request.File.ContentType,
-                ct);
-
-            creator.BannerUrl = $"{blobUrl}?t={DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()}";
-
-            await context.SaveChangesAsync(ct);
-
-            await SendOkAsync(
-                new Response(blobUrl),
-                ct);
-        }
-    }
-}

backend/Modules/Creators/Features/ChangeEmail.cs

@@ -1,67 +0,0 @@
-using Hutopy.Infrastructure.Security;
-using Hutopy.Modules.Creators.Data;
-
-namespace Hutopy.Modules.Creators.Features;
-
-[PublicAPI]
-public record ChangeEmailRequest(
-    Guid CreatorId,
-    string? Email);
-
-[PublicAPI]
-public sealed class ChangeEmailRequestValidator : Validator<ChangeEmailRequest>
-{
-    public ChangeEmailRequestValidator()
-    {
-        RuleFor(x => x.CreatorId)
-            .NotEmpty()
-            .WithMessage("Creator ID is required");
-
-        RuleFor(x => x.Email)
-            .Must(email => email == null || !string.IsNullOrWhiteSpace(email))
-            .WithMessage("Email cannot be empty if provided");
-    }
-}
-
-[PublicAPI]
-public class ChangeEmailHandler(
-    CreatorsDbContext context)
-    : Endpoint<ChangeEmailRequest>
-{
-    public override void Configure()
-    {
-        Post("/api/creators/{CreatorId}/email");
-        Options(o => o.WithTags("Creators"));
-    }
-
-    public override async Task HandleAsync(
-        ChangeEmailRequest request,
-        CancellationToken ct)
-    {
-        Creator? creator = await context
-            .Creators
-            .Include(c => c.Presentation)
-            .SingleOrDefaultAsync(
-                c => c.Id == request.CreatorId,
-                ct);
-
-        if (creator is null)
-        {
-            await SendNotFoundAsync(ct);
-            return;
-        }
-
-        // Check if the current user is the creator
-        if (creator.CreatedBy != User.GetUserId())
-        {
-            await SendUnauthorizedAsync(ct);
-            return;
-        }
-
-        creator.Presentation.Email = request.Email?.Trim();
-
-        await context.SaveChangesAsync(ct);
-
-        await SendOkAsync(ct);
-    }
-}

backend/Modules/Creators/Features/ChangeLogo.cs

@@ -1,74 +0,0 @@
-using Hutopy.Infrastructure.BlobStorage.Contracts;
-using Hutopy.Modules.Creators.Data;
-
-namespace Hutopy.Modules.Creators.Features;
-
-[PublicAPI]
-public record ChangeLogoRequest(
-    Guid CreatorId,
-    IFormFile File);
-
-[PublicAPI]
-public record ChangeLogoResponse(
-    string BlobUrl);
-
-[PublicAPI]
-public sealed class ChangeLogoRequestValidator : Validator<ChangeLogoRequest>
-{
-    public ChangeLogoRequestValidator()
-    {
-        RuleFor(x => x.CreatorId)
-            .NotNull()
-            .NotEmpty();
-
-        RuleFor(x => x.File)
-            .NotNull()
-            .NotEmpty();
-    }
-}
-
-[PublicAPI]
-public class ChangeLogoHandler(
-    CreatorsDbContext context,
-    IBlobStorage blobStorage)
-    : Endpoint<ChangeLogoRequest>
-{
-    public override void Configure()
-    {
-        Post("/api/creators/{CreatorId}/logo");
-        Options(o => o.WithTags("Creators"));
-        AllowFileUploads();
-    }
-
-    public override async Task HandleAsync(
-        ChangeLogoRequest request,
-        CancellationToken ct)
-    {
-        Creator? creator = await context
-            .Creators
-            .SingleOrDefaultAsync(
-                c => c.Id == request.CreatorId,
-                ct);
-
-        if (creator is null)
-        {
-            await SendNotFoundAsync(ct);
-            return;
-        }
-
-        string blobUrl = await blobStorage.UploadFileAsync(
-            ContainerNames.Creators,
-            $"{request.CreatorId}/{SubDirectoryNames.Profile}/{CommonFileNames.ProfilePicture}",
-            request.File.OpenReadStream(),
-            request.File.ContentType,
-            ct);
-
-        creator.PortraitUrl = $"{blobUrl}?t={DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()}";
-
-        await context.SaveChangesAsync(ct);
-
-        await SendOkAsync(
-            new ChangeLogoResponse(blobUrl),
-            ct);
-    }
-}

backend/Modules/Creators/Features/ChangeName.cs

@@ -1,49 +0,0 @@
-using Hutopy.Modules.Creators.Data;
-
-namespace Hutopy.Modules.Creators.Features;
-
-[PublicAPI]
-public record ChangeNameRequest(
-    Guid CreatorId,
-    string Name);
-
-[PublicAPI]
-internal sealed class ChangeNameRequestValidator
-    : Validator<ChangeNameRequest>
-{
-    public ChangeNameRequestValidator()
-    {
-        RuleFor(r => r.Name)
-            .NotNull().WithMessage("You should specify the Name")
-            .NotEmpty().WithMessage("You should specify a valid/not empty Name");
-    }
-}
-
-[PublicAPI]
-public class ChangeNameHandler(
-    CreatorsDbContext context)
-    : Endpoint<ChangeNameRequest>
-{
-    public override void Configure()
-    {
-        Post("/api/creators/{CreatorId}/name");
-        Options(o => o.WithTags("Creators"));
-    }
-
-    public override async Task HandleAsync(
-        ChangeNameRequest request,
-        CancellationToken ct)
-    {
-        Creator creator = await context
-            .Creators
-            .SingleAsync(
-                c => c.Id == request.CreatorId,
-                ct);
-
-        creator.Name = request.Name;
-
-        await context.SaveChangesAsync(ct);
-
-        await SendOkAsync(ct);
-    }
-}

backend/Modules/Creators/Features/ChangePhoneNumber.cs

@@ -1,67 +0,0 @@
-using Hutopy.Infrastructure.Security;
-using Hutopy.Modules.Creators.Data;
-
-namespace Hutopy.Modules.Creators.Features;
-
-[PublicAPI]
-public record ChangePhoneNumberRequest(
-    Guid CreatorId,
-    string? PhoneNumber);
-
-[PublicAPI]
-public sealed class ChangePhoneNumberRequestValidator : Validator<ChangePhoneNumberRequest>
-{
-    public ChangePhoneNumberRequestValidator()
-    {
-        RuleFor(x => x.CreatorId)
-            .NotEmpty()
-            .WithMessage("Creator ID is required");
-
-        RuleFor(x => x.PhoneNumber)
-            .Must(phone => phone == null || !string.IsNullOrWhiteSpace(phone))
-            .WithMessage("Phone number cannot be empty if provided");
-    }
-}
-
-[PublicAPI]
-public class ChangePhoneNumberHandler(
-    CreatorsDbContext context)
-    : Endpoint<ChangePhoneNumberRequest>
-{
-    public override void Configure()
-    {
-        Post("/api/creators/{CreatorId}/phone");
-        Options(o => o.WithTags("Creators"));
-    }
-
-    public override async Task HandleAsync(
-        ChangePhoneNumberRequest request,
-        CancellationToken ct)
-    {
-        Creator? creator = await context
-            .Creators
-            .Include(c => c.Presentation)
-            .SingleOrDefaultAsync(
-                c => c.Id == request.CreatorId,
-                ct);
-
-        if (creator is null)
-        {
-            await SendNotFoundAsync(ct);
-            return;
-        }
-
-        // Check if the current user is the creator
-        if (creator.CreatedBy != User.GetUserId())
-        {
-            await SendUnauthorizedAsync(ct);
-            return;
-        }
-
-        creator.Presentation.PhoneNumber = request.PhoneNumber?.Trim();
-
-        await context.SaveChangesAsync(ct);
-
-        await SendOkAsync(ct);
-    }
-}

backend/Modules/Creators/Features/ChangePresentationInfos.cs

@@ -1,71 +0,0 @@
-using Hutopy.Infrastructure.YouTube;
-using Hutopy.Modules.Creators.Data;
-
-namespace Hutopy.Modules.Creators.Features;
-
-[PublicAPI]
-public record ChangePresentationInfosRequest(
-    Guid CreatorId,
-    string Description,
-    string? VideoUrl);
-
-[PublicAPI]
-public sealed class ChangePresentationInfosRequestValidator : Validator<ChangePresentationInfosRequest>
-{
-    public ChangePresentationInfosRequestValidator()
-    {
-        RuleFor(x => x.CreatorId)
-            .NotEmpty()
-            .WithMessage("Creator ID is required");
-
-        RuleFor(x => x.Description)
-            .NotEmpty()
-            .WithMessage("Description is required")
-            .MaximumLength(2000)
-            .WithMessage("Description cannot exceed 2000 characters");
-
-        RuleFor(x => x.VideoUrl)
-            .Must(url => url == null || YouTubeUrlHelper.IsValidYouTubeUrlOrId(url))
-            .WithMessage("Invalid YouTube URL or video ID format");
-    }
-}
-
-[PublicAPI]
-public class ChangePresentationInfosHandler(
-    CreatorsDbContext context)
-    : Endpoint<ChangePresentationInfosRequest>
-{
-    public override void Configure()
-    {
-        Post("/api/creators/{CreatorId}/presentation-infos");
-        Options(o => o.WithTags("Creators"));
-    }
-
-    public override async Task HandleAsync(
-        ChangePresentationInfosRequest request,
-        CancellationToken ct)
-    {
-        Creator? creator = await context
-            .Creators
-            .Include(c => c.Presentation)
-            .SingleOrDefaultAsync(
-                c => c.Id == request.CreatorId,
-                ct);
-
-        if (creator is null)
-        {
-            await SendNotFoundAsync(ct);
-            return;
-        }
-
-        // Update the presentation info with the new values
-        creator.Presentation.Description = request.Description.Trim();
-        creator.Presentation.VideoUrl = request.VideoUrl != null
-            ? YouTubeUrlHelper.ExtractVideoId(request.VideoUrl.Trim())
-            : null;
-
-        await context.SaveChangesAsync(ct);
-
-        await SendOkAsync(ct);
-    }
-}

backend/Modules/Creators/Features/ChangeSlug.cs

@@ -1,98 +0,0 @@
-using Hutopy.Infrastructure.Security;
-using Hutopy.Modules.Creators.Data;
-using Microsoft.EntityFrameworkCore.Storage;
-
-namespace Hutopy.Modules.Creators.Features;
-
-[PublicAPI]
-public record ChangeSlugRequest(
-    Guid CreatorId,
-    Guid SlugReservationId);
-
-[PublicAPI]
-internal sealed class ChangeSlugRequestValidator
-    : Validator<ChangeSlugRequest>
-{
-    public ChangeSlugRequestValidator()
-    {
-        RuleFor(r => r.CreatorId)
-            .NotNull().WithMessage("You should specify the CreatorId")
-            .NotEmpty().WithMessage("You should specify a valid/not empty CreatorId");
-
-        RuleFor(r => r.SlugReservationId)
-            .NotNull().WithMessage("You should specify the SlugReservationId")
-            .NotEmpty().WithMessage("You should specify a valid/not empty SlugReservationId");
-    }
-}
-
-[PublicAPI]
-public class ChangeSlugHandler(
-    CreatorsDbContext context)
-    : Endpoint<ChangeSlugRequest>
-{
-    public override void Configure()
-    {
-        Put("/api/creators/{CreatorId}/slug");
-        Options(o => o.WithTags("Creators"));
-    }
-
-    public override async Task HandleAsync(
-        ChangeSlugRequest request,
-        CancellationToken ct)
-    {
-        await using IDbContextTransaction transaction = await context.Database.BeginTransactionAsync(ct);
-
-        try
-        {
-            Creator creator = await context
-                .Creators
-                .SingleAsync(
-                    c => c.Id == request.CreatorId,
-                    ct);
-
-            if (creator.CreatedBy != User.GetUserId())
-            {
-                await SendUnauthorizedAsync(ct);
-                return;
-            }
-
-            Slugs? reservation = await context
-                .Slugs
-                .FirstOrDefaultAsync(
-                    s => s.Id == request.SlugReservationId,
-                    ct);
-
-            if (reservation is null)
-            {
-                await SendNotFoundAsync(ct);
-                return;
-            }
-
-            Slugs? previousReservation = await context
-                .Slugs
-                .FirstOrDefaultAsync(
-                    s => s.UsedBy == request.CreatorId,
-                    ct);
-
-            if (previousReservation is null)
-            {
-                await SendErrorsAsync(cancellation: ct);
-                return;
-            }
-
-            context.Remove(previousReservation);
-            reservation.UsedBy = creator.Id;
-            creator.Slug = reservation.NormalizedName;
-
-            await context.SaveChangesAsync(ct);
-
-            await transaction.CommitAsync(ct);
-
-            await SendOkAsync(ct);
-        }
-        catch
-        {
-            await transaction.RollbackAsync(ct);
-        }
-    }
-}

backend/Modules/Creators/Features/ChangeSocials.cs

@@ -1,50 +0,0 @@
-using Hutopy.Modules.Creators.Data;
-
-namespace Hutopy.Modules.Creators.Features;
-
-[PublicAPI]
-public record ChangeSocialsRequest(
-    Guid CreatorId,
-    string? FacebookUrl,
-    string? InstagramUrl,
-    string? XUrl,
-    string? LinkedInUrl,
-    string? TikTokUrl,
-    string? YoutubeUrl,
-    string? RedditUrl,
-    string? WebsiteUrl);
-
-[PublicAPI]
-public class ChangeSocialsHandler(
-    CreatorsDbContext context)
-    : Endpoint<ChangeSocialsRequest>
-{
-    public override void Configure()
-    {
-        Post("/api/creators/{CreatorId}/socials");
-        Options(o => o.WithTags("Creators"));
-    }
-
-    public override async Task HandleAsync(ChangeSocialsRequest request, CancellationToken ct)
-    {
-        Creator creator = await context
-            .Creators
-            .Include(c => c.Socials)
-            .SingleAsync(
-                c => c.Id == request.CreatorId,
-                ct);
-
-        creator.Socials.FacebookUrl = request.FacebookUrl;
-        creator.Socials.InstagramUrl = request.InstagramUrl;
-        creator.Socials.XUrl = request.XUrl;
-        creator.Socials.LinkedInUrl = request.LinkedInUrl;
-        creator.Socials.TikTokUrl = request.TikTokUrl;
-        creator.Socials.YoutubeUrl = request.YoutubeUrl;
-        creator.Socials.RedditUrl = request.RedditUrl;
-        creator.Socials.WebsiteUrl = request.WebsiteUrl;
-
-        await context.SaveChangesAsync(ct);
-
-        await SendOkAsync(ct);
-    }
-}

backend/Modules/Creators/Features/ChangeTitle.cs

@@ -1,37 +0,0 @@
-using Hutopy.Modules.Creators.Data;
-
-namespace Hutopy.Modules.Creators.Features;
-
-[PublicAPI]
-public record ChangeTitleRequest(
-    Guid CreatorId,
-    string? Title);
-
-[PublicAPI]
-public class ChangeTitleHandler(
-    CreatorsDbContext context)
-    : Endpoint<ChangeTitleRequest>
-{
-    public override void Configure()
-    {
-        Post("/api/creators/{CreatorId}/title");
-        Options(o => o.WithTags("Creators"));
-    }
-
-    public override async Task HandleAsync(
-        ChangeTitleRequest request,
-        CancellationToken ct)
-    {
-        Creator creator = await context
-            .Creators
-            .SingleAsync(
-                c => c.Id == request.CreatorId,
-                ct);
-
-        creator.Title = request.Title;
-
-        await context.SaveChangesAsync(ct);
-
-        await SendOkAsync(ct);
-    }
-}

backend/Modules/Creators/Features/CheckStatusStripe.cs

@@ -1,68 +0,0 @@
-using Hutopy.Infrastructure.Payments.Stripe.Configuration;
-using Hutopy.Infrastructure.Security;
-using Hutopy.Modules.Creators.Data;
-using Microsoft.Extensions.Options;
-using Stripe;
-
-namespace Hutopy.Modules.Creators.Features;
-
-[PublicAPI]
-public record CheckStatusStripeResponse(
-    bool IsStripeAccountPresent,
-    bool IsStripeOnboardingComplete,
-    bool IsStripeChargesEnabled,
-    bool IsStripePayoutReady
-);
-
-public class CheckStatusStripeIdHandler(
-    IOptionsSnapshot<StripeOptions> stripeOptions,
-    CreatorsDbContext dbContext)
-    : EndpointWithoutRequest<CheckStatusStripeResponse>
-{
-    public override void Configure()
-    {
-        Post("/api/stripe/check-status");
-        Options(o => o.WithTags("Creators"));
-    }
-
-    public override async Task HandleAsync(
-        CancellationToken ct)
-    {
-        // 1. Get the creator's information
-        Guid creatorId = HttpContext.User.GetUserId();
-
-        // 2. Get or create the creator
-        Creator? creator = await dbContext.Creators.SingleOrDefaultAsync(c => c.Id == creatorId, ct);
-        if (creator is null)
-        {
-            await SendNotFoundAsync(ct);
-            return;
-        }
-
-        // 3. The Creator is not being onboarded
-        if (string.IsNullOrWhiteSpace(creator.StripeAccountId))
-        {
-            await SendErrorsAsync(cancellation: ct);
-            return;
-        }
-
-        // 4. Update Creator's stripe account information
-        StripeConfiguration.ApiKey = stripeOptions.Value.SecretKey;
-        AccountService accountService = new();
-        Account? account = await accountService.GetAsync(creator.StripeAccountId, cancellationToken: ct);
-        creator.IsStripePayoutReady = account.PayoutsEnabled;
-        creator.IsStripeChargesEnabled = account.ChargesEnabled;
-        creator.IsStripeDetailsSubmitted = account.DetailsSubmitted;
-        await dbContext.SaveChangesAsync(ct);
-
-        // 6. Return the account link URL to the client
-        await SendOkAsync(
-            new CheckStatusStripeResponse(
-                creator.StripeAccountId != null,
-                creator.IsStripeDetailsSubmitted,
-                creator.IsStripeChargesEnabled,
-                creator.IsStripePayoutReady
-            ),
-            ct);
-    }
-}

backend/Modules/Creators/Features/ConnectStripe.cs

@@ -1,91 +0,0 @@
-using Hutopy.Infrastructure.Configuration;
-using Hutopy.Infrastructure.Payments.Stripe.Configuration;
-using Hutopy.Infrastructure.Security;
-using Hutopy.Modules.Creators.Data;
-using Microsoft.Extensions.Options;
-using Stripe;
-
-namespace Hutopy.Modules.Creators.Features;
-
-[PublicAPI]
-public record ConnectStripeResponse(
-    string Url);
-
-public class ConnectStripeIdHandler(
-    IOptionsSnapshot<WebsiteOptions> websiteOptions,
-    IOptionsSnapshot<StripeOptions> stripeOptions,
-    CreatorsDbContext dbContext)
-    : EndpointWithoutRequest<ConnectStripeResponse>
-{
-    public override void Configure()
-    {
-        Post("/api/stripe/connect");
-        Options(o => o.WithTags("Creators"));
-    }
-
-    public override async Task HandleAsync(
-        CancellationToken ct)
-    {
-        // 1. Get the creator's information
-        Guid creatorId = HttpContext.User.GetUserId();
-        string email = HttpContext.User.GetEmail();
-
-        // 2. Get or create the creator
-        Creator? creator = await dbContext
-            .Creators
-            .SingleOrDefaultAsync(
-                c => c.Id == creatorId,
-                ct);
-
-        if (creator is null)
-        {
-            await SendNotFoundAsync(ct);
-            return;
-        }
-
-        // 3. Create a Stripe account
-        StripeConfiguration.ApiKey = stripeOptions.Value.SecretKey;
-        AccountService accountService = new();
-        if (string.IsNullOrWhiteSpace(creator.StripeAccountId))
-        {
-            Account? account = await accountService.CreateAsync(
-                new AccountCreateOptions
-                {
-                    Type = "express",
-                    Capabilities = new AccountCapabilitiesOptions
-                    {
-                        CardPayments = new AccountCapabilitiesCardPaymentsOptions { Requested = true },
-                        Transfers = new AccountCapabilitiesTransfersOptions { Requested = true }
-                    },
-                    Email = email
-                },
-                cancellationToken: ct);
-
-            // 5. Update the creator's Stripe account ID
-            creator.StripeAccountId = account.Id;
-            await dbContext.SaveChangesAsync(ct);
-        }
-
-        // 4. Check if the creator already has a Stripe account
-        if (creator is { IsStripeDetailsSubmitted: true, IsStripeChargesEnabled: true, IsStripePayoutReady: true })
-        {
-            await SendErrorsAsync(cancellation: ct);
-            return;
-        }
-
-        // 5. Create an account link 
-        AccountLinkService accountLinkService = new();
-        AccountLink? accountLink = await accountLinkService.CreateAsync(
-            new AccountLinkCreateOptions
-            {
-                Account = creator.StripeAccountId,
-                RefreshUrl = $"{websiteOptions.Value.FrontendBaseUrl}/profile?stripe=retry",
-                ReturnUrl = $"{websiteOptions.Value.FrontendBaseUrl}/profile?stripe=complete",
-                Type = "account_onboarding"
-            },
-            cancellationToken: ct);
-
-        // 6. Return the account link URL to the client
-        await SendOkAsync(new ConnectStripeResponse(accountLink.Url), ct);
-    }
-}

backend/Modules/Creators/Features/CreateCreator.cs

@@ -1,80 +0,0 @@
-using Hutopy.Infrastructure.Security;
-using Hutopy.Modules.Creators.Data;
-using Microsoft.EntityFrameworkCore.Storage;
-
-namespace Hutopy.Modules.Creators.Features;
-
-[PublicAPI]
-public record CreateCreatorRequest(
-    Guid SlugReservationId,
-    Guid CreatorId);
-
-[PublicAPI]
-public sealed class CreateCreatorRequestValidator : Validator<CreateCreatorRequest>
-{
-    public CreateCreatorRequestValidator()
-    {
-        RuleFor(r => r.SlugReservationId)
-            .NotNull()
-            .NotEmpty()
-            .WithMessage("You should specify a valid SlugReservationId");
-
-        RuleFor(r => r.CreatorId)
-            .NotNull()
-            .NotEmpty()
-            .WithMessage("You should specify a valid CreatorId");
-    }
-}
-
-[PublicAPI]
-public sealed class CreateCreatorHandler(
-    CreatorsDbContext context)
-    : Endpoint<CreateCreatorRequest>
-{
-    public override void Configure()
-    {
-        Post("/api/creators");
-        Options(o => o.WithTags("Creators"));
-    }
-
-    public override async Task HandleAsync(
-        CreateCreatorRequest req,
-        CancellationToken ct)
-    {
-        await using IDbContextTransaction transaction = await context.Database.BeginTransactionAsync(ct);
-
-        try
-        {
-            Slugs slug = await context
-                .Slugs
-                .SingleAsync(s => s.Id == req.SlugReservationId, ct);
-
-            if (slug.UsedBy is not null
-                || slug.ReservedUntil < DateTimeOffset.UtcNow
-                || slug.CreatedBy != User.GetUserId())
-            {
-                await SendErrorsAsync(500, ct);
-                return;
-            }
-
-            slug.UsedBy = req.CreatorId;
-
-            await context.Creators.AddAsync(
-                new Creator
-                {
-                    Id = req.CreatorId, CreatedBy = User.GetUserId(), Name = slug.Name, Slug = slug.NormalizedName
-                },
-                ct);
-
-            await context.SaveChangesAsync(ct);
-
-            await transaction.CommitAsync(ct);
-
-            await SendOkAsync(ct);
-        }
-        catch (Exception)
-        {
-            await transaction.RollbackAsync(ct);
-        }
-    }
-}

backend/Modules/Creators/Features/GetCreatorById.cs

@@ -1,54 +0,0 @@
-using Hutopy.Modules.Creators.Data;
-
-namespace Hutopy.Modules.Creators.Features;
-
-[PublicAPI]
-public sealed class GetCreatorByIdRequest
-{
-    public required Guid CreatorId { get; set; }
-}
-
-[UsedImplicitly]
-public sealed class GetCreatorByIdRequestValidator
-    : Validator<GetCreatorByIdRequest>
-{
-    public GetCreatorByIdRequestValidator()
-    {
-        RuleFor(r => r.CreatorId)
-            .NotNull().WithMessage("You should specify the CreatorId")
-            .NotEmpty().WithMessage("You should specify a valid/not empty CreatorId");
-    }
-}
-
-[PublicAPI]
-public class GetCreatorByIdHandler(
-    CreatorsDbContext context)
-    : Endpoint<GetCreatorByIdRequest, Creator>
-{
-    public override void Configure()
-    {
-        Get("/api/creators/{CreatorId}");
-        Options(o => o.WithTags("Creators"));
-        AllowAnonymous();
-    }
-
-    public override async Task HandleAsync(
-        GetCreatorByIdRequest req,
-        CancellationToken ct)
-    {
-        Creator? creator = await context
-            .Creators
-            .FindAsync(
-                [req.CreatorId],
-                ct);
-
-        if (creator is null)
-        {
-            await SendNotFoundAsync(ct);
-        }
-        else
-        {
-            await SendAsync(creator, cancellation: ct);
-        }
-    }
-}

backend/Modules/Creators/Features/GetCreatorBySlug.cs

@@ -1,105 +0,0 @@
-using Hutopy.Infrastructure.Security;
-using Hutopy.Modules.Creators.Data;
-
-namespace Hutopy.Modules.Creators.Features;
-
-[PublicAPI]
-public sealed class GetCreatorBySlugRequest
-{
-    public required string Name { get; set; }
-}
-
-[PublicAPI]
-public record GetCreatorBySlugResponse
-{
-    public Guid Id { get; init; }
-    public Guid CreatedBy { get; init; }
-    public DateTimeOffset CreatedAt { get; init; }
-    public Guid? DeletedBy { get; init; }
-    public DateTimeOffset? DeletedAt { get; init; }
-    public bool IsDeleted { get; init; }
-    public bool Verified { get; init; }
-    public bool AcceptDonation { get; init; }
-    public string? BannerUrl { get; init; }
-    public string? PortraitUrl { get; init; }
-    public required string Slug { get; init; }
-    public required string Name { get; init; }
-    public string? Title { get; init; }
-    public Socials? Socials { get; init; }
-    public Presentation? Presentation { get; init; }
-}
-
-[UsedImplicitly]
-public sealed class GetCreatorBySlugRequestValidator
-    : Validator<GetCreatorBySlugRequest>
-{
-    public GetCreatorBySlugRequestValidator()
-    {
-        RuleFor(r => r.Name)
-            .NotNull().WithMessage("You should specify the Name")
-            .NotEmpty().WithMessage("You should specify a valid/not empty Name");
-    }
-}
-
-[PublicAPI]
-public class GetCreatorBySlugHandler(
-    CreatorsDbContext context)
-    : Endpoint<GetCreatorBySlugRequest, GetCreatorBySlugResponse>
-{
-    public override void Configure()
-    {
-        Get("/api/creators/@{Name}");
-        Options(o => o.WithTags("Creators"));
-        AllowAnonymous();
-    }
-
-    public override async Task HandleAsync(
-        GetCreatorBySlugRequest req,
-        CancellationToken ct)
-    {
-        string creatorName = req.Name.ToLower();
-
-        GetCreatorBySlugResponse? response = await context
-            .Creators
-            .IgnoreQueryFilters()
-            .Where(c => EF.Functions.ILike(c.Slug, creatorName))
-            .AsNoTracking()
-            .Select(c => new GetCreatorBySlugResponse
-            {
-                Id = c.Id,
-                CreatedBy = c.CreatedBy,
-                CreatedAt = c.CreatedAt,
-                DeletedBy = c.DeletedBy,
-                DeletedAt = c.DeletedAt,
-                IsDeleted = c.IsDeleted,
-                Verified = c.Verified,
-                BannerUrl = c.BannerUrl,
-                PortraitUrl = c.PortraitUrl,
-                Slug = c.Slug,
-                Name = c.Name,
-                Title = c.Title,
-                AcceptDonation = c.IsStripeChargesEnabled && c.IsStripePayoutReady,
-                Socials = c.Socials,
-                Presentation = c.Presentation
-            })
-            .SingleOrDefaultAsync(ct);
-
-        if (response is null)
-        {
-            await SendNotFoundAsync(ct);
-            return;
-        }
-
-        bool isOwner = User.Identity?.IsAuthenticated == true
-                       && User.GetUserId() == response.CreatedBy;
-
-        if (response.IsDeleted && !isOwner)
-        {
-            await SendNotFoundAsync(ct);
-        }
-        else
-        {
-            await SendAsync(response, cancellation: ct);
-        }
-    }
-}

backend/Modules/Creators/Features/GetCreatorProfile.cs

@@ -1,76 +0,0 @@
-using Hutopy.Infrastructure.Security;
-using Hutopy.Modules.Creators.Data;
-
-namespace Hutopy.Modules.Creators.Features;
-
-[PublicAPI]
-public sealed class GetCreatorProfileResponse
-{
-    public Guid Id { get; set; }
-    public Guid CreatedBy { get; set; }
-    public DateTimeOffset CreatedAt { get; set; }
-    public Guid? DeletedBy { get; set; }
-    public DateTimeOffset? DeletedAt { get; set; }
-    public bool IsDeleted { get; set; }
-    public required string Name { get; set; }
-    public required string Slug { get; set; }
-    public string? Title { get; set; }
-    public bool Verified { get; set; }
-    public bool IsStripeAccountPresent { get; set; }
-    public bool IsStripeDetailsSubmitted { get; set; }
-    public bool IsStripePayoutReady { get; set; }
-    public bool IsStripeChargesEnabled { get; set; }
-    public required Presentation Presentation { get; set; }
-    public required Socials Socials { get; set; }
-}
-
-[PublicAPI]
-public class GetCreatorProfileHandler(
-    CreatorsDbContext context)
-    : EndpointWithoutRequest<GetCreatorProfileResponse>
-{
-    public override void Configure()
-    {
-        Get("/api/creators/profile");
-        Options(o => o.WithTags("Creators"));
-    }
-
-    public override async Task HandleAsync(
-        CancellationToken ct)
-    {
-        GetCreatorProfileResponse? creator = await context
-            .Creators
-            .IgnoreQueryFilters()
-            .Where(c => c.Id == HttpContext.User.GetUserId())
-            .AsNoTracking()
-            .Select(c => new GetCreatorProfileResponse
-            {
-                Id = c.Id,
-                CreatedBy = c.CreatedBy,
-                CreatedAt = c.CreatedAt,
-                DeletedBy = c.DeletedBy,
-                DeletedAt = c.DeletedAt,
-                IsDeleted = c.IsDeleted,
-                Name = c.Name,
-                Slug = c.Slug,
-                Title = c.Title,
-                Verified = c.Verified,
-                IsStripeAccountPresent = !string.IsNullOrWhiteSpace(c.StripeAccountId),
-                IsStripeDetailsSubmitted = c.IsStripeDetailsSubmitted,
-                IsStripeChargesEnabled = c.IsStripeChargesEnabled,
-                IsStripePayoutReady = c.IsStripePayoutReady,
-                Presentation = c.Presentation,
-                Socials = c.Socials
-            })
-            .SingleOrDefaultAsync(ct);
-
-        if (creator is null)
-        {
-            await SendNotFoundAsync(ct);
-        }
-        else
-        {
-            await SendAsync(creator, cancellation: ct);
-        }
-    }
-}

backend/Modules/Creators/Features/RemoveCreator.cs

@@ -1,63 +0,0 @@
-using Hutopy.Infrastructure.Security;
-using Hutopy.Modules.Creators.Data;
-
-namespace Hutopy.Modules.Creators.Features;
-
-[PublicAPI]
-public record RemoveCreatorRequest(
-    string CreatorSlug);
-
-[UsedImplicitly]
-public sealed class RemoveCreatorRequestValidator : Validator<RemoveCreatorRequest>
-{
-    public RemoveCreatorRequestValidator()
-    {
-        RuleFor(r => r.CreatorSlug)
-            .NotNull()
-            .NotEmpty()
-            .WithMessage("You should specify a valid CreatorSlug");
-    }
-}
-
-[PublicAPI]
-public sealed class RemoveCreatorHandler(
-    CreatorsDbContext context)
-    : Endpoint<RemoveCreatorRequest>
-{
-    public override void Configure()
-    {
-        Delete("/api/creators/@{CreatorSlug}");
-        Options(o => o.WithTags("Creators"));
-    }
-
-    public override async Task HandleAsync(
-        RemoveCreatorRequest req,
-        CancellationToken ct)
-    {
-        string creatorSlug = req.CreatorSlug.ToLower();
-
-        Creator? creator = await context
-            .Creators
-            .Where(c => EF.Functions.ILike(c.Slug, creatorSlug))
-            .SingleOrDefaultAsync(ct);
-
-        if (creator is null)
-        {
-            await SendNotFoundAsync(ct);
-            return;
-        }
-
-        if (creator.CreatedBy != User.GetUserId())
-        {
-            await SendUnauthorizedAsync(ct);
-            return;
-        }
-
-        creator.DeletedAt = DateTimeOffset.UtcNow;
-        creator.DeletedBy = User.GetUserId();
-
-        await context.SaveChangesAsync(ct);
-
-        await SendOkAsync(ct);
-    }
-}

backend/Modules/Creators/Features/ReserveSlug.cs

@@ -1,109 +0,0 @@
-using System.Net;
-using FluentValidation.Results;
-using Hutopy.Infrastructure.Security;
-using Hutopy.Modules.Creators.Configuration;
-using Hutopy.Modules.Creators.Data;
-using Hutopy.Modules.Creators.Services;
-using Microsoft.EntityFrameworkCore.Storage;
-using Microsoft.Extensions.Options;
-using Npgsql;
-
-namespace Hutopy.Modules.Creators.Features;
-
-[PublicAPI]
-public record ReserveSlugRequest
-{
-    public required Guid ReservationId { get; set; }
-    public string Slug { get; set; } = null!;
-}
-
-[PublicAPI]
-public sealed class ReserveSlugRequestValidator : Validator<ReserveSlugRequest>
-{
-    public ReserveSlugRequestValidator()
-    {
-        RuleFor(r => r.Slug)
-            .NotEmpty()
-            .NotNull()
-            .WithMessage("You should specify a valid Slug");
-    }
-}
-
-[PublicAPI]
-public sealed class ReserveSlug(
-    CreatorsDbContext context,
-    IOptions<CreatorOptions> opts,
-    SlugPurger slugPurger)
-    : Endpoint<ReserveSlugRequest>
-{
-    public override void Configure()
-    {
-        Post("/api/creators/@{Slug}/reserve");
-        Options(o => o.WithTags("Creators"));
-    }
-
-    public override async Task HandleAsync(
-        ReserveSlugRequest req,
-        CancellationToken ct)
-    {
-        await using IDbContextTransaction transaction = await context.Database.BeginTransactionAsync(ct);
-
-        try
-        {
-            // First, purge any expired slugs
-            await slugPurger.PurgeExpiredSlugsAsync(ct);
-
-            Slugs? reservation = await context.Slugs.FirstOrDefaultAsync(
-                s => s.Id == req.ReservationId && s.CreatedBy == User.GetUserId(),
-                ct);
-
-            if (reservation == null)
-            {
-                reservation = new Slugs
-                {
-                    Id = req.ReservationId, CreatedBy = User.GetUserId(), CreatedAt = DateTimeOffset.UtcNow
-                };
-
-                context.Slugs.Attach(reservation);
-                context.Entry(reservation).State = EntityState.Added;
-            }
-
-            reservation.Name = req.Slug;
-            reservation.ReservedUntil = DateTimeOffset.UtcNow + opts.Value.SlugReservationDuration;
-
-            await context.SaveChangesAsync(ct);
-
-            await transaction.CommitAsync(ct);
-
-            await SendOkAsync(new { Message = "Slug reserved." }, ct);
-        }
-        catch (Exception e)
-        {
-            await transaction.RollbackAsync(ct);
-
-            Logger.LogError("Transaction failed: {Message}", e.Message);
-
-            if (e.InnerException is PostgresException innerException)
-            {
-                if (innerException.ConstraintName == "IX_Slugs_NormalizedName")
-                {
-                    await SendResultAsync(new ProblemDetails(
-                        [
-                            new ValidationFailure(nameof(Slugs.Name),
-                                "The name is already taken.")
-                        ],
-                        (int)HttpStatusCode.Conflict));
-                }
-            }
-            else
-            {
-                await SendResultAsync(new ProblemDetails(
-                    [
-                        new ValidationFailure(nameof(Slugs.Name),
-                            e.Message)
-                    ],
-                    (int)HttpStatusCode.Conflict));
-            }
-        }
-    }
-}

backend/Modules/Creators/Features/RestoreCreator.cs

@@ -1,64 +0,0 @@
-using Hutopy.Infrastructure.Security;
-using Hutopy.Modules.Creators.Data;
-
-namespace Hutopy.Modules.Creators.Features;
-
-[PublicAPI]
-public record RestoreCreatorRequest(
-    string CreatorSlug);
-
-[UsedImplicitly]
-public sealed class RestoreCreatorRequestValidator : Validator<RestoreCreatorRequest>
-{
-    public RestoreCreatorRequestValidator()
-    {
-        RuleFor(r => r.CreatorSlug)
-            .NotNull()
-            .NotEmpty()
-            .WithMessage("You should specify a valid CreatorSlug");
-    }
-}
-
-[PublicAPI]
-public sealed class RestoreCreatorHandler(
-    CreatorsDbContext context)
-    : Endpoint<RestoreCreatorRequest>
-{
-    public override void Configure()
-    {
-        Put("/api/creators/@{CreatorSlug}/restore");
-        Options(o => o.WithTags("Creators"));
-    }
-
-    public override async Task HandleAsync(
-        RestoreCreatorRequest req,
-        CancellationToken ct)
-    {
-        string creatorSlug = req.CreatorSlug.ToLower();
-
-        Creator? creator = await context
-            .Creators
-            .IgnoreQueryFilters()
-            .Where(c => EF.Functions.ILike(c.Slug, creatorSlug))
-            .SingleOrDefaultAsync(ct);
-
-        if (creator is null)
-        {
-            await SendNotFoundAsync(ct);
-            return;
-        }
-
-        if (creator.CreatedBy != User.GetUserId())
-        {
-            await SendUnauthorizedAsync(ct);
-            return;
-        }
-
-        creator.DeletedAt = null;
-        creator.DeletedBy = null;
-
-        await context.SaveChangesAsync(ct);
-
-        await SendOkAsync(ct);
-    }
-}

backend/Modules/Creators/Features/RevokeStripe.cs

@@ -1,48 +0,0 @@
-using Hutopy.Infrastructure.Security;
-using Hutopy.Modules.Creators.Data;
-
-namespace Hutopy.Modules.Creators.Features;
-
-[PublicAPI]
-public class RemoveStripeHandler(
-    CreatorsDbContext dbContext)
-    : EndpointWithoutRequest
-{
-    public override void Configure()
-    {
-        Delete("/api/stripe");
-        Options(o => o.WithTags("Creators"));
-    }
-
-    public override async Task HandleAsync(CancellationToken ct)
-    {
-        // 1. Get the creator's ID from the authenticated user
-        Guid creatorId = HttpContext.User.GetUserId();
-
-        // 2. Retrieve the creator from the database
-        Creator? creator = await dbContext
-            .Creators
-            .SingleOrDefaultAsync(
-                c => c.Id == creatorId,
-                ct);
-
-        // 3. If the creator doesn't exist or has no Stripe account linked, return 404
-        if (creator is null || string.IsNullOrWhiteSpace(creator.StripeAccountId))
-        {
-            await SendNotFoundAsync(ct);
-            return;
-        }
-
-        // 4. Remove Stripe configuration
-        creator.StripeAccountId = null;
-        creator.IsStripeDetailsSubmitted = false;
-        creator.IsStripeChargesEnabled = false;
-        creator.IsStripePayoutReady = false;
-
-        // 5. Persist changes
-        await dbContext.SaveChangesAsync(ct);
-
-        // 6. Respond with success
-        await SendOkAsync(ct);
-    }
-}

backend/Modules/Creators/Migrations/20250609203815_Initial.Designer.cs

@@ -1,221 +0,0 @@
-// <auto-generated />
-using System;
-using Hutopy.Modules.Creators.Data;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Infrastructure;
-using Microsoft.EntityFrameworkCore.Migrations;
-using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
-using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
-
-#nullable disable
-
-namespace Hutopy.Modules.Creators.Migrations
-{
-    [DbContext(typeof(CreatorsDbContext))]
-    [Migration("20250609203815_Initial")]
-    partial class Initial
-    {
-        /// <inheritdoc />
-        protected override void BuildTargetModel(ModelBuilder modelBuilder)
-        {
-#pragma warning disable 612, 618
-            modelBuilder
-                .HasDefaultSchema("Creators")
-                .HasAnnotation("ProductVersion", "9.0.3")
-                .HasAnnotation("Relational:MaxIdentifierLength", 63);
-
-            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
-
-            modelBuilder.Entity("Hutopy.Modules.Creators.Data.Creator", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<bool>("AcceptDonation")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("BannerUrl")
-                        .HasMaxLength(2048)
-                        .HasColumnType("character varying(2048)");
-
-                    b.Property<DateTimeOffset>("CreatedAt")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<Guid>("CreatedBy")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTimeOffset?>("DeletedAt")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<Guid?>("DeletedBy")
-                        .HasColumnType("uuid");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAddOrUpdate()
-                        .HasColumnType("boolean")
-                        .HasComputedColumnSql("\"DeletedAt\" IS NOT NULL", true);
-
-                    b.Property<bool>("IsStripeChargesEnabled")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("IsStripeOnboardingComplete")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("IsStripePayoutReady")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("PortraitUrl")
-                        .HasMaxLength(2048)
-                        .HasColumnType("character varying(2048)");
-
-                    b.Property<string>("Slug")
-                        .IsRequired()
-                        .HasMaxLength(128)
-                        .HasColumnType("character varying(128)");
-
-                    b.Property<string>("StripeAccountId")
-                        .HasMaxLength(21)
-                        .HasColumnType("character varying(21)");
-
-                    b.Property<string>("Title")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<bool>("Verified")
-                        .HasColumnType("boolean");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Creators", "Creators");
-                });
-
-            modelBuilder.Entity("Hutopy.Modules.Creators.Data.Slugs", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTimeOffset>("CreatedAt")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<Guid>("CreatedBy")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasMaxLength(128)
-                        .HasColumnType("character varying(128)");
-
-                    b.Property<string>("NormalizedName")
-                        .IsRequired()
-                        .ValueGeneratedOnAddOrUpdate()
-                        .HasMaxLength(128)
-                        .HasColumnType("character varying(128)")
-                        .HasComputedColumnSql("LOWER(\"Name\")", true);
-
-                    b.Property<DateTimeOffset>("ReservedUntil")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<Guid?>("UsedBy")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("NormalizedName")
-                        .IsUnique();
-
-                    b.ToTable("Slugs", "Creators");
-                });
-
-            modelBuilder.Entity("Hutopy.Modules.Creators.Data.Creator", b =>
-                {
-                    b.OwnsOne("Hutopy.Modules.Creators.Data.Presentation", "Presentation", b1 =>
-                        {
-                            b1.Property<Guid>("CreatorId")
-                                .HasColumnType("uuid");
-
-                            b1.Property<string>("Description")
-                                .IsRequired()
-                                .HasColumnType("text");
-
-                            b1.Property<string>("Email")
-                                .HasMaxLength(256)
-                                .HasColumnType("character varying(256)");
-
-                            b1.Property<string>("PhoneNumber")
-                                .HasMaxLength(256)
-                                .HasColumnType("character varying(256)");
-
-                            b1.Property<string>("VideoUrl")
-                                .HasMaxLength(2048)
-                                .HasColumnType("character varying(2048)");
-
-                            b1.HasKey("CreatorId");
-
-                            b1.ToTable("Presentation", "Creators");
-
-                            b1.WithOwner()
-                                .HasForeignKey("CreatorId");
-                        });
-
-                    b.OwnsOne("Hutopy.Modules.Creators.Data.Socials", "Socials", b1 =>
-                        {
-                            b1.Property<Guid>("CreatorId")
-                                .HasColumnType("uuid");
-
-                            b1.Property<string>("FacebookUrl")
-                                .HasMaxLength(2048)
-                                .HasColumnType("character varying(2048)");
-
-                            b1.Property<string>("InstagramUrl")
-                                .HasMaxLength(2048)
-                                .HasColumnType("character varying(2048)");
-
-                            b1.Property<string>("LinkedInUrl")
-                                .HasMaxLength(2048)
-                                .HasColumnType("character varying(2048)");
-
-                            b1.Property<string>("RedditUrl")
-                                .HasMaxLength(2048)
-                                .HasColumnType("character varying(2048)");
-
-                            b1.Property<string>("TikTokUrl")
-                                .HasMaxLength(2048)
-                                .HasColumnType("character varying(2048)");
-
-                            b1.Property<string>("WebsiteUrl")
-                                .HasMaxLength(2048)
-                                .HasColumnType("character varying(2048)");
-
-                            b1.Property<string>("XUrl")
-                                .HasMaxLength(2048)
-                                .HasColumnType("character varying(2048)");
-
-                            b1.Property<string>("YoutubeUrl")
-                                .HasMaxLength(2048)
-                                .HasColumnType("character varying(2048)");
-
-                            b1.HasKey("CreatorId");
-
-                            b1.ToTable("Socials", "Creators");
-
-                            b1.WithOwner()
-                                .HasForeignKey("CreatorId");
-                        });
-
-                    b.Navigation("Presentation")
-                        .IsRequired();
-
-                    b.Navigation("Socials")
-                        .IsRequired();
-                });
-#pragma warning restore 612, 618
-        }
-    }
-}

backend/Modules/Creators/Migrations/20250609203815_Initial.cs

@@ -1,141 +0,0 @@
-using System;
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace Hutopy.Modules.Creators.Migrations
-{
-    /// <inheritdoc />
-    public partial class Initial : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.EnsureSchema(
-                name: "Creators");
-
-            migrationBuilder.CreateTable(
-                name: "Creators",
-                schema: "Creators",
-                columns: table => new
-                {
-                    Id = table.Column<Guid>(type: "uuid", nullable: false),
-                    CreatedBy = table.Column<Guid>(type: "uuid", nullable: false),
-                    CreatedAt = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false),
-                    DeletedBy = table.Column<Guid>(type: "uuid", nullable: true),
-                    DeletedAt = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: true),
-                    IsDeleted = table.Column<bool>(type: "boolean", nullable: false, computedColumnSql: "\"DeletedAt\" IS NOT NULL", stored: true),
-                    BannerUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: true),
-                    PortraitUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: true),
-                    Verified = table.Column<bool>(type: "boolean", nullable: false),
-                    Name = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
-                    Slug = table.Column<string>(type: "character varying(128)", maxLength: 128, nullable: false),
-                    Title = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
-                    StripeAccountId = table.Column<string>(type: "character varying(21)", maxLength: 21, nullable: true),
-                    IsStripeOnboardingComplete = table.Column<bool>(type: "boolean", nullable: false),
-                    IsStripePayoutReady = table.Column<bool>(type: "boolean", nullable: false),
-                    IsStripeChargesEnabled = table.Column<bool>(type: "boolean", nullable: false),
-                    AcceptDonation = table.Column<bool>(type: "boolean", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_Creators", x => x.Id);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "Slugs",
-                schema: "Creators",
-                columns: table => new
-                {
-                    Id = table.Column<Guid>(type: "uuid", nullable: false),
-                    CreatedBy = table.Column<Guid>(type: "uuid", nullable: false),
-                    CreatedAt = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false),
-                    UsedBy = table.Column<Guid>(type: "uuid", nullable: true),
-                    Name = table.Column<string>(type: "character varying(128)", maxLength: 128, nullable: false),
-                    NormalizedName = table.Column<string>(type: "character varying(128)", maxLength: 128, nullable: false, computedColumnSql: "LOWER(\"Name\")", stored: true),
-                    ReservedUntil = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_Slugs", x => x.Id);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "Presentation",
-                schema: "Creators",
-                columns: table => new
-                {
-                    CreatorId = table.Column<Guid>(type: "uuid", nullable: false),
-                    Description = table.Column<string>(type: "text", nullable: false),
-                    VideoUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: true),
-                    PhoneNumber = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
-                    Email = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_Presentation", x => x.CreatorId);
-                    table.ForeignKey(
-                        name: "FK_Presentation_Creators_CreatorId",
-                        column: x => x.CreatorId,
-                        principalSchema: "Creators",
-                        principalTable: "Creators",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "Socials",
-                schema: "Creators",
-                columns: table => new
-                {
-                    CreatorId = table.Column<Guid>(type: "uuid", nullable: false),
-                    FacebookUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: true),
-                    InstagramUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: true),
-                    XUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: true),
-                    LinkedInUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: true),
-                    TikTokUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: true),
-                    YoutubeUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: true),
-                    RedditUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: true),
-                    WebsiteUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: true)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_Socials", x => x.CreatorId);
-                    table.ForeignKey(
-                        name: "FK_Socials_Creators_CreatorId",
-                        column: x => x.CreatorId,
-                        principalSchema: "Creators",
-                        principalTable: "Creators",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateIndex(
-                name: "IX_Slugs_NormalizedName",
-                schema: "Creators",
-                table: "Slugs",
-                column: "NormalizedName",
-                unique: true);
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropTable(
-                name: "Presentation",
-                schema: "Creators");
-
-            migrationBuilder.DropTable(
-                name: "Slugs",
-                schema: "Creators");
-
-            migrationBuilder.DropTable(
-                name: "Socials",
-                schema: "Creators");
-
-            migrationBuilder.DropTable(
-                name: "Creators",
-                schema: "Creators");
-        }
-    }
-}

backend/Modules/Creators/Migrations/20250610200446_AddStripe.Designer.cs

@@ -1,218 +0,0 @@
-// <auto-generated />
-using System;
-using Hutopy.Modules.Creators.Data;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Infrastructure;
-using Microsoft.EntityFrameworkCore.Migrations;
-using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
-using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
-
-#nullable disable
-
-namespace Hutopy.Modules.Creators.Migrations
-{
-    [DbContext(typeof(CreatorsDbContext))]
-    [Migration("20250610200446_AddStripe")]
-    partial class AddStripe
-    {
-        /// <inheritdoc />
-        protected override void BuildTargetModel(ModelBuilder modelBuilder)
-        {
-#pragma warning disable 612, 618
-            modelBuilder
-                .HasDefaultSchema("Creators")
-                .HasAnnotation("ProductVersion", "9.0.3")
-                .HasAnnotation("Relational:MaxIdentifierLength", 63);
-
-            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
-
-            modelBuilder.Entity("Hutopy.Modules.Creators.Data.Creator", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("BannerUrl")
-                        .HasMaxLength(2048)
-                        .HasColumnType("character varying(2048)");
-
-                    b.Property<DateTimeOffset>("CreatedAt")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<Guid>("CreatedBy")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTimeOffset?>("DeletedAt")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<Guid?>("DeletedBy")
-                        .HasColumnType("uuid");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAddOrUpdate()
-                        .HasColumnType("boolean")
-                        .HasComputedColumnSql("\"DeletedAt\" IS NOT NULL", true);
-
-                    b.Property<bool>("IsStripeChargesEnabled")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("IsStripeDetailsSubmitted")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("IsStripePayoutReady")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("PortraitUrl")
-                        .HasMaxLength(2048)
-                        .HasColumnType("character varying(2048)");
-
-                    b.Property<string>("Slug")
-                        .IsRequired()
-                        .HasMaxLength(128)
-                        .HasColumnType("character varying(128)");
-
-                    b.Property<string>("StripeAccountId")
-                        .HasMaxLength(21)
-                        .HasColumnType("character varying(21)");
-
-                    b.Property<string>("Title")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<bool>("Verified")
-                        .HasColumnType("boolean");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Creators", "Creators");
-                });
-
-            modelBuilder.Entity("Hutopy.Modules.Creators.Data.Slugs", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTimeOffset>("CreatedAt")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<Guid>("CreatedBy")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasMaxLength(128)
-                        .HasColumnType("character varying(128)");
-
-                    b.Property<string>("NormalizedName")
-                        .IsRequired()
-                        .ValueGeneratedOnAddOrUpdate()
-                        .HasMaxLength(128)
-                        .HasColumnType("character varying(128)")
-                        .HasComputedColumnSql("LOWER(\"Name\")", true);
-
-                    b.Property<DateTimeOffset>("ReservedUntil")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<Guid?>("UsedBy")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("NormalizedName")
-                        .IsUnique();
-
-                    b.ToTable("Slugs", "Creators");
-                });
-
-            modelBuilder.Entity("Hutopy.Modules.Creators.Data.Creator", b =>
-                {
-                    b.OwnsOne("Hutopy.Modules.Creators.Data.Presentation", "Presentation", b1 =>
-                        {
-                            b1.Property<Guid>("CreatorId")
-                                .HasColumnType("uuid");
-
-                            b1.Property<string>("Description")
-                                .IsRequired()
-                                .HasColumnType("text");
-
-                            b1.Property<string>("Email")
-                                .HasMaxLength(256)
-                                .HasColumnType("character varying(256)");
-
-                            b1.Property<string>("PhoneNumber")
-                                .HasMaxLength(256)
-                                .HasColumnType("character varying(256)");
-
-                            b1.Property<string>("VideoUrl")
-                                .HasMaxLength(2048)
-                                .HasColumnType("character varying(2048)");
-
-                            b1.HasKey("CreatorId");
-
-                            b1.ToTable("Presentation", "Creators");
-
-                            b1.WithOwner()
-                                .HasForeignKey("CreatorId");
-                        });
-
-                    b.OwnsOne("Hutopy.Modules.Creators.Data.Socials", "Socials", b1 =>
-                        {
-                            b1.Property<Guid>("CreatorId")
-                                .HasColumnType("uuid");
-
-                            b1.Property<string>("FacebookUrl")
-                                .HasMaxLength(2048)
-                                .HasColumnType("character varying(2048)");
-
-                            b1.Property<string>("InstagramUrl")
-                                .HasMaxLength(2048)
-                                .HasColumnType("character varying(2048)");
-
-                            b1.Property<string>("LinkedInUrl")
-                                .HasMaxLength(2048)
-                                .HasColumnType("character varying(2048)");
-
-                            b1.Property<string>("RedditUrl")
-                                .HasMaxLength(2048)
-                                .HasColumnType("character varying(2048)");
-
-                            b1.Property<string>("TikTokUrl")
-                                .HasMaxLength(2048)
-                                .HasColumnType("character varying(2048)");
-
-                            b1.Property<string>("WebsiteUrl")
-                                .HasMaxLength(2048)
-                                .HasColumnType("character varying(2048)");
-
-                            b1.Property<string>("XUrl")
-                                .HasMaxLength(2048)
-                                .HasColumnType("character varying(2048)");
-
-                            b1.Property<string>("YoutubeUrl")
-                                .HasMaxLength(2048)
-                                .HasColumnType("character varying(2048)");
-
-                            b1.HasKey("CreatorId");
-
-                            b1.ToTable("Socials", "Creators");
-
-                            b1.WithOwner()
-                                .HasForeignKey("CreatorId");
-                        });
-
-                    b.Navigation("Presentation")
-                        .IsRequired();
-
-                    b.Navigation("Socials")
-                        .IsRequired();
-                });
-#pragma warning restore 612, 618
-        }
-    }
-}

backend/Modules/Creators/Migrations/20250610200446_AddStripe.cs

@@ -1,43 +0,0 @@
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace Hutopy.Modules.Creators.Migrations
-{
-    /// <inheritdoc />
-    public partial class AddStripe : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropColumn(
-                name: "AcceptDonation",
-                schema: "Creators",
-                table: "Creators");
-
-            migrationBuilder.RenameColumn(
-                name: "IsStripeOnboardingComplete",
-                schema: "Creators",
-                table: "Creators",
-                newName: "IsStripeDetailsSubmitted");
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.RenameColumn(
-                name: "IsStripeDetailsSubmitted",
-                schema: "Creators",
-                table: "Creators",
-                newName: "IsStripeOnboardingComplete");
-
-            migrationBuilder.AddColumn<bool>(
-                name: "AcceptDonation",
-                schema: "Creators",
-                table: "Creators",
-                type: "boolean",
-                nullable: false,
-                defaultValue: false);
-        }
-    }
-}

backend/Modules/Creators/Migrations/CreatorsDbContextModelSnapshot.cs

@@ -1,215 +0,0 @@
-// <auto-generated />
-using System;
-using Hutopy.Modules.Creators.Data;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Infrastructure;
-using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
-using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
-
-#nullable disable
-
-namespace Hutopy.Modules.Creators.Migrations
-{
-    [DbContext(typeof(CreatorsDbContext))]
-    partial class CreatorsDbContextModelSnapshot : ModelSnapshot
-    {
-        protected override void BuildModel(ModelBuilder modelBuilder)
-        {
-#pragma warning disable 612, 618
-            modelBuilder
-                .HasDefaultSchema("Creators")
-                .HasAnnotation("ProductVersion", "9.0.3")
-                .HasAnnotation("Relational:MaxIdentifierLength", 63);
-
-            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
-
-            modelBuilder.Entity("Hutopy.Modules.Creators.Data.Creator", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("BannerUrl")
-                        .HasMaxLength(2048)
-                        .HasColumnType("character varying(2048)");
-
-                    b.Property<DateTimeOffset>("CreatedAt")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<Guid>("CreatedBy")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTimeOffset?>("DeletedAt")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<Guid?>("DeletedBy")
-                        .HasColumnType("uuid");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAddOrUpdate()
-                        .HasColumnType("boolean")
-                        .HasComputedColumnSql("\"DeletedAt\" IS NOT NULL", true);
-
-                    b.Property<bool>("IsStripeChargesEnabled")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("IsStripeDetailsSubmitted")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("IsStripePayoutReady")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("PortraitUrl")
-                        .HasMaxLength(2048)
-                        .HasColumnType("character varying(2048)");
-
-                    b.Property<string>("Slug")
-                        .IsRequired()
-                        .HasMaxLength(128)
-                        .HasColumnType("character varying(128)");
-
-                    b.Property<string>("StripeAccountId")
-                        .HasMaxLength(21)
-                        .HasColumnType("character varying(21)");
-
-                    b.Property<string>("Title")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<bool>("Verified")
-                        .HasColumnType("boolean");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Creators", "Creators");
-                });
-
-            modelBuilder.Entity("Hutopy.Modules.Creators.Data.Slugs", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTimeOffset>("CreatedAt")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<Guid>("CreatedBy")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasMaxLength(128)
-                        .HasColumnType("character varying(128)");
-
-                    b.Property<string>("NormalizedName")
-                        .IsRequired()
-                        .ValueGeneratedOnAddOrUpdate()
-                        .HasMaxLength(128)
-                        .HasColumnType("character varying(128)")
-                        .HasComputedColumnSql("LOWER(\"Name\")", true);
-
-                    b.Property<DateTimeOffset>("ReservedUntil")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<Guid?>("UsedBy")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("NormalizedName")
-                        .IsUnique();
-
-                    b.ToTable("Slugs", "Creators");
-                });
-
-            modelBuilder.Entity("Hutopy.Modules.Creators.Data.Creator", b =>
-                {
-                    b.OwnsOne("Hutopy.Modules.Creators.Data.Presentation", "Presentation", b1 =>
-                        {
-                            b1.Property<Guid>("CreatorId")
-                                .HasColumnType("uuid");
-
-                            b1.Property<string>("Description")
-                                .IsRequired()
-                                .HasColumnType("text");
-
-                            b1.Property<string>("Email")
-                                .HasMaxLength(256)
-                                .HasColumnType("character varying(256)");
-
-                            b1.Property<string>("PhoneNumber")
-                                .HasMaxLength(256)
-                                .HasColumnType("character varying(256)");
-
-                            b1.Property<string>("VideoUrl")
-                                .HasMaxLength(2048)
-                                .HasColumnType("character varying(2048)");
-
-                            b1.HasKey("CreatorId");
-
-                            b1.ToTable("Presentation", "Creators");
-
-                            b1.WithOwner()
-                                .HasForeignKey("CreatorId");
-                        });
-
-                    b.OwnsOne("Hutopy.Modules.Creators.Data.Socials", "Socials", b1 =>
-                        {
-                            b1.Property<Guid>("CreatorId")
-                                .HasColumnType("uuid");
-
-                            b1.Property<string>("FacebookUrl")
-                                .HasMaxLength(2048)
-                                .HasColumnType("character varying(2048)");
-
-                            b1.Property<string>("InstagramUrl")
-                                .HasMaxLength(2048)
-                                .HasColumnType("character varying(2048)");
-
-                            b1.Property<string>("LinkedInUrl")
-                                .HasMaxLength(2048)
-                                .HasColumnType("character varying(2048)");
-
-                            b1.Property<string>("RedditUrl")
-                                .HasMaxLength(2048)
-                                .HasColumnType("character varying(2048)");
-
-                            b1.Property<string>("TikTokUrl")
-                                .HasMaxLength(2048)
-                                .HasColumnType("character varying(2048)");
-
-                            b1.Property<string>("WebsiteUrl")
-                                .HasMaxLength(2048)
-                                .HasColumnType("character varying(2048)");
-
-                            b1.Property<string>("XUrl")
-                                .HasMaxLength(2048)
-                                .HasColumnType("character varying(2048)");
-
-                            b1.Property<string>("YoutubeUrl")
-                                .HasMaxLength(2048)
-                                .HasColumnType("character varying(2048)");
-
-                            b1.HasKey("CreatorId");
-
-                            b1.ToTable("Socials", "Creators");
-
-                            b1.WithOwner()
-                                .HasForeignKey("CreatorId");
-                        });
-
-                    b.Navigation("Presentation")
-                        .IsRequired();
-
-                    b.Navigation("Socials")
-                        .IsRequired();
-                });
-#pragma warning restore 612, 618
-        }
-    }
-}

backend/Modules/Creators/Services/CreatorLookup.cs

@@ -1,26 +0,0 @@
-using Hutopy.Modules.Creators.Contracts;
-using Hutopy.Modules.Creators.Data;
-
-namespace Hutopy.Modules.Creators.Services;
-
-public sealed class CreatorLookup(
-    CreatorsDbContext context)
-    : ICreatorLookup
-{
-    public async Task<CreatorReference?> GetCreatorAsync(Guid creatorId, CancellationToken cancellationToken)
-    {
-        Creator? creator = await context
-            .Creators
-            .FirstOrDefaultAsync(c => c.Id == creatorId, cancellationToken);
-
-        return creator is null
-            ? null
-            : new CreatorReference(
-                creator.Id,
-                creator.Name,
-                creator.PortraitUrl,
-                creator.IsStripeDetailsSubmitted,
-                creator.IsStripeChargesEnabled,
-                creator.StripeAccountId);
-    }
-}

backend/Modules/Creators/Services/SlugPurger.cs

@@ -1,43 +0,0 @@
-using Hutopy.Modules.Creators.Data;
-
-namespace Hutopy.Modules.Creators.Services;
-
-public class SlugPurger(CreatorsDbContext context)
-{
-    private static readonly SemaphoreSlim Semaphore = new(1, 1);
-    private static DateTimeOffset s_lastPurgeTime = DateTimeOffset.MinValue;
-    private static readonly TimeSpan MinTimeBetweenPurges = TimeSpan.FromSeconds(10);
-
-    public async Task PurgeExpiredSlugsAsync(CancellationToken ct)
-    {
-        // Try to acquire the semaphore
-        if (!await Semaphore.WaitAsync(0, ct))
-        {
-            // Another purge operation is in progress, skip this one
-            return;
-        }
-
-        try
-        {
-            DateTimeOffset now = DateTimeOffset.UtcNow;
-            if (now - s_lastPurgeTime < MinTimeBetweenPurges)
-            {
-                // Not enough time has passed since the last purge
-                return;
-            }
-
-            // Delete expired slugs that are not in use
-            await context
-                .Slugs
-                .Where(s => s.ReservedUntil < now && s.UsedBy == null)
-                .ExecuteDeleteAsync(ct);
-
-            // Update the last purge time regardless of whether we found expired slugs or not
-            s_lastPurgeTime = now;
-        }
-        finally
-        {
-            Semaphore.Release();
-        }
-    }
-}

backend/Modules/Identity/Contracts/KnownRoles.cs

@@ -1,7 +0,0 @@
-namespace Hutopy.Modules.Identity.Contracts;
-
-public static class KnownRoles
-{
-    public const string Administrator = nameof(Administrator);
-    public const string Creator = nameof(Creator);
-}

backend/Modules/Identity/Data/IdentityDbContext.cs

@@ -1,18 +0,0 @@
-using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
-
-namespace Hutopy.Modules.Identity.Data;
-
-public class IdentityDbContext(
-    DbContextOptions<IdentityDbContext> options)
-    : IdentityDbContext<User, Role, Guid>(options)
-{
-    public const string SchemaName = "Identity";
-
-    protected override void OnModelCreating(ModelBuilder
-        modelBuilder)
-    {
-        base.OnModelCreating(modelBuilder);
-
-        modelBuilder.HasDefaultSchema(SchemaName);
-    }
-}

backend/Modules/Identity/DependencyInjection.cs

@@ -1,73 +0,0 @@
-using Hutopy.Modules.Identity.Configuration;
-using Hutopy.Modules.Identity.Contracts;
-using Hutopy.Modules.Identity.Data;
-using Hutopy.Modules.Identity.Services;
-using Microsoft.AspNetCore.Identity;
-
-namespace Hutopy.Modules.Identity;
-
-public static class DependencyInjection
-{
-    public static WebApplicationBuilder AddIdentityModule(
-        this WebApplicationBuilder builder,
-        Action<DbContextOptionsBuilder>? configureAction = null)
-    {
-        builder.Services.AddDbContext<IdentityDbContext>(configureAction);
-
-        builder.Services.Configure<JwtOptions>(
-            builder.Configuration.GetRequiredSection(JwtOptions.SectionName));
-
-        builder.Services.AddAuthentication()
-            .AddBearerToken(IdentityConstants.BearerScheme);
-
-        builder.Services.AddAuthorizationBuilder();
-
-        builder.Services
-            .AddIdentityCore<User>()
-            .AddUserManager<UserManager>()
-            .AddRoles<Role>()
-            .AddEntityFrameworkStores<IdentityDbContext>()
-            .AddApiEndpoints()
-            .AddDefaultTokenProviders();
-
-        // Singleton services
-        builder.Services.AddSingleton(TimeProvider.System);
-
-        // Scoped services
-        builder.Services.AddScoped<IdentityService>();
-        builder.Services.AddScoped<EmailVerificationService>();
-        builder.Services.AddScoped<IUserLookup, UserLookup>();
-
-        return builder;
-    }
-
-    public static async Task<IApplicationBuilder> UseIdentityModuleAsync(
-        this IApplicationBuilder app,
-        CancellationToken cancellationToken = default)
-    {
-        IServiceScopeFactory scopeFactory = app.ApplicationServices.GetRequiredService<IServiceScopeFactory>();
-        using IServiceScope scope = scopeFactory.CreateScope();
-        await using IdentityDbContext context = scope.ServiceProvider.GetRequiredService<IdentityDbContext>();
-        await context.Database.MigrateAsync(cancellationToken);
-
-        RoleManager<Role> roleManager = scope.ServiceProvider.GetRequiredService<RoleManager<Role>>();
-        await TrySeedAsync(roleManager);
-
-        return app;
-    }
-
-    private static async Task TrySeedAsync(RoleManager<Role> roleManager)
-    {
-        Role administratorRole = new(KnownRoles.Administrator);
-        if (roleManager.Roles.All(r => r.Name != administratorRole.Name))
-        {
-            await roleManager.CreateAsync(administratorRole);
-        }
-
-        Role roleCreator = new(KnownRoles.Creator);
-        if (roleManager.Roles.All(r => r.Name != roleCreator.Name))
-        {
-            await roleManager.CreateAsync(roleCreator);
-        }
-    }
-}

backend/Modules/Identity/Handlers/GetCurrentUser.cs

@@ -1,47 +0,0 @@
-using Hutopy.Modules.Identity.Data;
-using Hutopy.Modules.Identity.Models;
-
-namespace Hutopy.Modules.Identity.Handlers;
-
-[PublicAPI]
-public class GetCurrentUserQueryHandler(
-    IdentityService identityService)
-    : EndpointWithoutRequest<UserDto>
-{
-    public override void Configure()
-    {
-        Get("/api/users/profile");
-        Options(o => o.WithTags("Memberships"));
-    }
-
-    public override async Task HandleAsync(
-        CancellationToken cancellationToken)
-    {
-        UserModel? userModel = await identityService.GetCurrentUserAsync();
-
-        if (userModel is null)
-        {
-            await SendNotFoundAsync(cancellationToken);
-            return;
-        }
-
-        IList<string> roles = await identityService.GetCurrentUserRolesAsync();
-
-        await SendOkAsync(
-            new UserDto
-            {
-                Id = userModel.Id,
-                Alias = userModel.Alias,
-                PortraitUrl = userModel.PortraitUrl,
-                Firstname = userModel.Firstname,
-                Lastname = userModel.Lastname,
-                Username = userModel.Username,
-                PhoneNumber = userModel.PhoneNumber,
-                Email = userModel.Email,
-                BirthDate = userModel.BirthDate,
-                Address = userModel.Address,
-                UserRoles = roles
-            },
-            cancellationToken);
-    }
-}

backend/Modules/Identity/Migrations/20250609203622_Initial.Designer.cs

@@ -1,315 +0,0 @@
-// <auto-generated />
-using System;
-using Hutopy.Modules.Identity.Data;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Infrastructure;
-using Microsoft.EntityFrameworkCore.Migrations;
-using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
-using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
-
-#nullable disable
-
-namespace Hutopy.Modules.Identity.Migrations
-{
-    [DbContext(typeof(IdentityDbContext))]
-    [Migration("20250609203622_Initial")]
-    partial class Initial
-    {
-        /// <inheritdoc />
-        protected override void BuildTargetModel(ModelBuilder modelBuilder)
-        {
-#pragma warning disable 612, 618
-            modelBuilder
-                .HasDefaultSchema("Identity")
-                .HasAnnotation("ProductVersion", "9.0.3")
-                .HasAnnotation("Relational:MaxIdentifierLength", 63);
-
-            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
-
-            modelBuilder.Entity("Hutopy.Modules.Identity.Data.Role", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Name")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("NormalizedName")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("NormalizedName")
-                        .IsUnique()
-                        .HasDatabaseName("RoleNameIndex");
-
-                    b.ToTable("AspNetRoles", "Identity");
-                });
-
-            modelBuilder.Entity("Hutopy.Modules.Identity.Data.User", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<int>("AccessFailedCount")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("Address")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("Alias")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<DateTime?>("BirthDate")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Email")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<bool>("EmailConfirmed")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("FacebookId")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("Firstname")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("GoogleId")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("Lastname")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<bool>("LockoutEnabled")
-                        .HasColumnType("boolean");
-
-                    b.Property<DateTimeOffset?>("LockoutEnd")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<string>("NormalizedEmail")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("NormalizedUserName")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("PasswordHash")
-                        .HasColumnType("text");
-
-                    b.Property<string>("PhoneNumber")
-                        .HasColumnType("text");
-
-                    b.Property<bool>("PhoneNumberConfirmed")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("PortraitUrl")
-                        .HasMaxLength(2048)
-                        .HasColumnType("character varying(2048)");
-
-                    b.Property<string>("RefreshToken")
-                        .HasMaxLength(44)
-                        .HasColumnType("character varying(44)");
-
-                    b.Property<DateTime>("RefreshTokenExpiryTime")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<string>("SecurityStamp")
-                        .HasColumnType("text");
-
-                    b.Property<bool>("TwoFactorEnabled")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("UserName")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("NormalizedEmail")
-                        .HasDatabaseName("EmailIndex");
-
-                    b.HasIndex("NormalizedUserName")
-                        .IsUnique()
-                        .HasDatabaseName("UserNameIndex");
-
-                    b.ToTable("AspNetUsers", "Identity");
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<System.Guid>", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<string>("ClaimType")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ClaimValue")
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("RoleId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("RoleId");
-
-                    b.ToTable("AspNetRoleClaims", "Identity");
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<System.Guid>", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<string>("ClaimType")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ClaimValue")
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("UserId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("UserId");
-
-                    b.ToTable("AspNetUserClaims", "Identity");
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<System.Guid>", b =>
-                {
-                    b.Property<string>("LoginProvider")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ProviderKey")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ProviderDisplayName")
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("UserId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("LoginProvider", "ProviderKey");
-
-                    b.HasIndex("UserId");
-
-                    b.ToTable("AspNetUserLogins", "Identity");
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<System.Guid>", b =>
-                {
-                    b.Property<Guid>("UserId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("RoleId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("UserId", "RoleId");
-
-                    b.HasIndex("RoleId");
-
-                    b.ToTable("AspNetUserRoles", "Identity");
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<System.Guid>", b =>
-                {
-                    b.Property<Guid>("UserId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("LoginProvider")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Name")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Value")
-                        .HasColumnType("text");
-
-                    b.HasKey("UserId", "LoginProvider", "Name");
-
-                    b.ToTable("AspNetUserTokens", "Identity");
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<System.Guid>", b =>
-                {
-                    b.HasOne("Hutopy.Modules.Identity.Data.Role", null)
-                        .WithMany()
-                        .HasForeignKey("RoleId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<System.Guid>", b =>
-                {
-                    b.HasOne("Hutopy.Modules.Identity.Data.User", null)
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<System.Guid>", b =>
-                {
-                    b.HasOne("Hutopy.Modules.Identity.Data.User", null)
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<System.Guid>", b =>
-                {
-                    b.HasOne("Hutopy.Modules.Identity.Data.Role", null)
-                        .WithMany()
-                        .HasForeignKey("RoleId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Hutopy.Modules.Identity.Data.User", null)
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<System.Guid>", b =>
-                {
-                    b.HasOne("Hutopy.Modules.Identity.Data.User", null)
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-#pragma warning restore 612, 618
-        }
-    }
-}

backend/Modules/Identity/Migrations/20250609203622_Initial.cs

@@ -1,263 +0,0 @@
-using System;
-using Microsoft.EntityFrameworkCore.Migrations;
-using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
-
-#nullable disable
-
-namespace Hutopy.Modules.Identity.Migrations
-{
-    /// <inheritdoc />
-    public partial class Initial : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.EnsureSchema(
-                name: "Identity");
-
-            migrationBuilder.CreateTable(
-                name: "AspNetRoles",
-                schema: "Identity",
-                columns: table => new
-                {
-                    Id = table.Column<Guid>(type: "uuid", nullable: false),
-                    Name = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
-                    NormalizedName = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
-                    ConcurrencyStamp = table.Column<string>(type: "text", nullable: true)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_AspNetRoles", x => x.Id);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "AspNetUsers",
-                schema: "Identity",
-                columns: table => new
-                {
-                    Id = table.Column<Guid>(type: "uuid", nullable: false),
-                    Alias = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
-                    Firstname = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
-                    Lastname = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
-                    BirthDate = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
-                    Address = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
-                    PortraitUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: true),
-                    GoogleId = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
-                    FacebookId = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
-                    RefreshToken = table.Column<string>(type: "character varying(44)", maxLength: 44, nullable: true),
-                    RefreshTokenExpiryTime = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
-                    UserName = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
-                    NormalizedUserName = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
-                    Email = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
-                    NormalizedEmail = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
-                    EmailConfirmed = table.Column<bool>(type: "boolean", nullable: false),
-                    PasswordHash = table.Column<string>(type: "text", nullable: true),
-                    SecurityStamp = table.Column<string>(type: "text", nullable: true),
-                    ConcurrencyStamp = table.Column<string>(type: "text", nullable: true),
-                    PhoneNumber = table.Column<string>(type: "text", nullable: true),
-                    PhoneNumberConfirmed = table.Column<bool>(type: "boolean", nullable: false),
-                    TwoFactorEnabled = table.Column<bool>(type: "boolean", nullable: false),
-                    LockoutEnd = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: true),
-                    LockoutEnabled = table.Column<bool>(type: "boolean", nullable: false),
-                    AccessFailedCount = table.Column<int>(type: "integer", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_AspNetUsers", x => x.Id);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "AspNetRoleClaims",
-                schema: "Identity",
-                columns: table => new
-                {
-                    Id = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    RoleId = table.Column<Guid>(type: "uuid", nullable: false),
-                    ClaimType = table.Column<string>(type: "text", nullable: true),
-                    ClaimValue = table.Column<string>(type: "text", nullable: true)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_AspNetRoleClaims", x => x.Id);
-                    table.ForeignKey(
-                        name: "FK_AspNetRoleClaims_AspNetRoles_RoleId",
-                        column: x => x.RoleId,
-                        principalSchema: "Identity",
-                        principalTable: "AspNetRoles",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "AspNetUserClaims",
-                schema: "Identity",
-                columns: table => new
-                {
-                    Id = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    UserId = table.Column<Guid>(type: "uuid", nullable: false),
-                    ClaimType = table.Column<string>(type: "text", nullable: true),
-                    ClaimValue = table.Column<string>(type: "text", nullable: true)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_AspNetUserClaims", x => x.Id);
-                    table.ForeignKey(
-                        name: "FK_AspNetUserClaims_AspNetUsers_UserId",
-                        column: x => x.UserId,
-                        principalSchema: "Identity",
-                        principalTable: "AspNetUsers",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "AspNetUserLogins",
-                schema: "Identity",
-                columns: table => new
-                {
-                    LoginProvider = table.Column<string>(type: "text", nullable: false),
-                    ProviderKey = table.Column<string>(type: "text", nullable: false),
-                    ProviderDisplayName = table.Column<string>(type: "text", nullable: true),
-                    UserId = table.Column<Guid>(type: "uuid", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_AspNetUserLogins", x => new { x.LoginProvider, x.ProviderKey });
-                    table.ForeignKey(
-                        name: "FK_AspNetUserLogins_AspNetUsers_UserId",
-                        column: x => x.UserId,
-                        principalSchema: "Identity",
-                        principalTable: "AspNetUsers",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "AspNetUserRoles",
-                schema: "Identity",
-                columns: table => new
-                {
-                    UserId = table.Column<Guid>(type: "uuid", nullable: false),
-                    RoleId = table.Column<Guid>(type: "uuid", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_AspNetUserRoles", x => new { x.UserId, x.RoleId });
-                    table.ForeignKey(
-                        name: "FK_AspNetUserRoles_AspNetRoles_RoleId",
-                        column: x => x.RoleId,
-                        principalSchema: "Identity",
-                        principalTable: "AspNetRoles",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                    table.ForeignKey(
-                        name: "FK_AspNetUserRoles_AspNetUsers_UserId",
-                        column: x => x.UserId,
-                        principalSchema: "Identity",
-                        principalTable: "AspNetUsers",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "AspNetUserTokens",
-                schema: "Identity",
-                columns: table => new
-                {
-                    UserId = table.Column<Guid>(type: "uuid", nullable: false),
-                    LoginProvider = table.Column<string>(type: "text", nullable: false),
-                    Name = table.Column<string>(type: "text", nullable: false),
-                    Value = table.Column<string>(type: "text", nullable: true)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_AspNetUserTokens", x => new { x.UserId, x.LoginProvider, x.Name });
-                    table.ForeignKey(
-                        name: "FK_AspNetUserTokens_AspNetUsers_UserId",
-                        column: x => x.UserId,
-                        principalSchema: "Identity",
-                        principalTable: "AspNetUsers",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateIndex(
-                name: "IX_AspNetRoleClaims_RoleId",
-                schema: "Identity",
-                table: "AspNetRoleClaims",
-                column: "RoleId");
-
-            migrationBuilder.CreateIndex(
-                name: "RoleNameIndex",
-                schema: "Identity",
-                table: "AspNetRoles",
-                column: "NormalizedName",
-                unique: true);
-
-            migrationBuilder.CreateIndex(
-                name: "IX_AspNetUserClaims_UserId",
-                schema: "Identity",
-                table: "AspNetUserClaims",
-                column: "UserId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_AspNetUserLogins_UserId",
-                schema: "Identity",
-                table: "AspNetUserLogins",
-                column: "UserId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_AspNetUserRoles_RoleId",
-                schema: "Identity",
-                table: "AspNetUserRoles",
-                column: "RoleId");
-
-            migrationBuilder.CreateIndex(
-                name: "EmailIndex",
-                schema: "Identity",
-                table: "AspNetUsers",
-                column: "NormalizedEmail");
-
-            migrationBuilder.CreateIndex(
-                name: "UserNameIndex",
-                schema: "Identity",
-                table: "AspNetUsers",
-                column: "NormalizedUserName",
-                unique: true);
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropTable(
-                name: "AspNetRoleClaims",
-                schema: "Identity");
-
-            migrationBuilder.DropTable(
-                name: "AspNetUserClaims",
-                schema: "Identity");
-
-            migrationBuilder.DropTable(
-                name: "AspNetUserLogins",
-                schema: "Identity");
-
-            migrationBuilder.DropTable(
-                name: "AspNetUserRoles",
-                schema: "Identity");
-
-            migrationBuilder.DropTable(
-                name: "AspNetUserTokens",
-                schema: "Identity");
-
-            migrationBuilder.DropTable(
-                name: "AspNetRoles",
-                schema: "Identity");
-
-            migrationBuilder.DropTable(
-                name: "AspNetUsers",
-                schema: "Identity");
-        }
-    }
-}

backend/Modules/Identity/Migrations/IdentityDbContextModelSnapshot.cs

@@ -1,312 +0,0 @@
-// <auto-generated />
-using System;
-using Hutopy.Modules.Identity.Data;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Infrastructure;
-using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
-using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
-
-#nullable disable
-
-namespace Hutopy.Modules.Identity.Migrations
-{
-    [DbContext(typeof(IdentityDbContext))]
-    partial class IdentityDbContextModelSnapshot : ModelSnapshot
-    {
-        protected override void BuildModel(ModelBuilder modelBuilder)
-        {
-#pragma warning disable 612, 618
-            modelBuilder
-                .HasDefaultSchema("Identity")
-                .HasAnnotation("ProductVersion", "9.0.3")
-                .HasAnnotation("Relational:MaxIdentifierLength", 63);
-
-            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
-
-            modelBuilder.Entity("Hutopy.Modules.Identity.Data.Role", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Name")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("NormalizedName")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("NormalizedName")
-                        .IsUnique()
-                        .HasDatabaseName("RoleNameIndex");
-
-                    b.ToTable("AspNetRoles", "Identity");
-                });
-
-            modelBuilder.Entity("Hutopy.Modules.Identity.Data.User", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<int>("AccessFailedCount")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("Address")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("Alias")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<DateTime?>("BirthDate")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Email")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<bool>("EmailConfirmed")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("FacebookId")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("Firstname")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("GoogleId")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("Lastname")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<bool>("LockoutEnabled")
-                        .HasColumnType("boolean");
-
-                    b.Property<DateTimeOffset?>("LockoutEnd")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<string>("NormalizedEmail")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("NormalizedUserName")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("PasswordHash")
-                        .HasColumnType("text");
-
-                    b.Property<string>("PhoneNumber")
-                        .HasColumnType("text");
-
-                    b.Property<bool>("PhoneNumberConfirmed")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("PortraitUrl")
-                        .HasMaxLength(2048)
-                        .HasColumnType("character varying(2048)");
-
-                    b.Property<string>("RefreshToken")
-                        .HasMaxLength(44)
-                        .HasColumnType("character varying(44)");
-
-                    b.Property<DateTime>("RefreshTokenExpiryTime")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<string>("SecurityStamp")
-                        .HasColumnType("text");
-
-                    b.Property<bool>("TwoFactorEnabled")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("UserName")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("NormalizedEmail")
-                        .HasDatabaseName("EmailIndex");
-
-                    b.HasIndex("NormalizedUserName")
-                        .IsUnique()
-                        .HasDatabaseName("UserNameIndex");
-
-                    b.ToTable("AspNetUsers", "Identity");
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<System.Guid>", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<string>("ClaimType")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ClaimValue")
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("RoleId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("RoleId");
-
-                    b.ToTable("AspNetRoleClaims", "Identity");
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<System.Guid>", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<string>("ClaimType")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ClaimValue")
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("UserId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("UserId");
-
-                    b.ToTable("AspNetUserClaims", "Identity");
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<System.Guid>", b =>
-                {
-                    b.Property<string>("LoginProvider")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ProviderKey")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ProviderDisplayName")
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("UserId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("LoginProvider", "ProviderKey");
-
-                    b.HasIndex("UserId");
-
-                    b.ToTable("AspNetUserLogins", "Identity");
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<System.Guid>", b =>
-                {
-                    b.Property<Guid>("UserId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("RoleId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("UserId", "RoleId");
-
-                    b.HasIndex("RoleId");
-
-                    b.ToTable("AspNetUserRoles", "Identity");
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<System.Guid>", b =>
-                {
-                    b.Property<Guid>("UserId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("LoginProvider")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Name")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Value")
-                        .HasColumnType("text");
-
-                    b.HasKey("UserId", "LoginProvider", "Name");
-
-                    b.ToTable("AspNetUserTokens", "Identity");
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<System.Guid>", b =>
-                {
-                    b.HasOne("Hutopy.Modules.Identity.Data.Role", null)
-                        .WithMany()
-                        .HasForeignKey("RoleId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<System.Guid>", b =>
-                {
-                    b.HasOne("Hutopy.Modules.Identity.Data.User", null)
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<System.Guid>", b =>
-                {
-                    b.HasOne("Hutopy.Modules.Identity.Data.User", null)
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<System.Guid>", b =>
-                {
-                    b.HasOne("Hutopy.Modules.Identity.Data.Role", null)
-                        .WithMany()
-                        .HasForeignKey("RoleId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Hutopy.Modules.Identity.Data.User", null)
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<System.Guid>", b =>
-                {
-                    b.HasOne("Hutopy.Modules.Identity.Data.User", null)
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-#pragma warning restore 612, 618
-        }
-    }
-}

backend/Modules/Memberships/Contracts/IMembershipCancellationProcessor.cs

@@ -1,6 +0,0 @@
-namespace Hutopy.Modules.Memberships.Contracts;
-
-public interface IMembershipCancellationProcessor
-{
-    Task<DateTimeOffset?> CancelAsync(string subscriptionId, CancellationToken ct = default);
-}

backend/Modules/Memberships/Contracts/IMembershipNotifier.cs

@@ -1,26 +0,0 @@
-namespace Hutopy.Modules.Memberships.Contracts;
-
-public interface IMembershipNotifier
-{
-    Task NotifyCheckoutSessionCompleted(string stripeSessionId, string stripeSubscriptionId,
-        string userId,
-        string creatorId,
-        string tierId,
-        CancellationToken cancellationToken = default);
-
-    Task NotifyPaymentSucceedAsync(
-        string stripeSubscriptionId,
-        string hostedInvoiceUrl,
-        decimal amount,
-        string currency,
-        CancellationToken cancellationToken = default);
-
-    Task NotifySubscriptionUpdatedAsync(
-        string subscriptionId,
-        DateTimeOffset? endDate,
-        CancellationToken cancellationToken = default);
-
-    Task NotifySubscriptionDeletedAsync(
-        string subscriptionId,
-        CancellationToken cancellationToken = default);
-}

backend/Modules/Memberships/Contracts/IMembershipPaymentProcessor.cs

@@ -1,14 +0,0 @@
-using Hutopy.Modules.Creators.Contracts;
-
-namespace Hutopy.Modules.Memberships.Contracts;
-
-public interface IMembershipPaymentProcessor
-{
-    Task<MembershipCheckoutSession> CreateCheckoutSessionAsync(
-        Guid userId,
-        CreatorReference creatorReference,
-        Guid tierId,
-        string priceId,
-        string successUrl,
-        string cancelUrl);
-}

backend/Modules/Memberships/Contracts/IMembershipTierProcessor.cs

@@ -1,11 +0,0 @@
-namespace Hutopy.Modules.Memberships.Contracts;
-
-public interface IMembershipTierProcessor
-{
-    Task<string> CreateAsync(
-        Guid creatorId,
-        Guid tierId,
-        string productName,
-        string currencyCode,
-        decimal amount);
-}

backend/Modules/Memberships/Contracts/MembershipCheckoutSession.cs

@@ -1,6 +0,0 @@
-namespace Hutopy.Modules.Memberships.Contracts;
-
-[PublicAPI]
-public record MembershipCheckoutSession(
-    string Id,
-    string Url);

backend/Modules/Memberships/Data/Membership.cs

@@ -1,20 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-
-namespace Hutopy.Modules.Memberships.Data;
-
-public class Membership
-{
-    public Guid Id { get; set; }
-    public DateTimeOffset CreatedAt { get; set; }
-    public Guid UserId { get; set; }
-    public Guid CreatorId { get; set; }
-    public Guid TierId { get; set; }
-    public MembershipTier? MembershipTier { get; set; }
-    public MembershipState State { get; set; }
-    public DateTimeOffset? StartDate { get; set; }
-    public DateTimeOffset? EndDate { get; set; }
-    public bool IsActive => EndDate == null || EndDate > DateTimeOffset.UtcNow;
-    [MaxLength(256)] public string? StripeSubscriptionId { get; set; }
-
-    public ICollection<Payment> Payments { get; set; } = [];
-}

backend/Modules/Memberships/Data/MembershipState.cs

@@ -1,8 +0,0 @@
-namespace Hutopy.Modules.Memberships.Data;
-
-public enum MembershipState
-{
-    Pending,
-    Active,
-    Inactive
-}

backend/Modules/Memberships/Data/MembershipTier.cs

@@ -1,17 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using Hutopy.Common.Domain;
-
-namespace Hutopy.Modules.Memberships.Data;
-
-public class MembershipTier : Entity
-{
-    public Guid CreatorId { get; set; }
-    [MaxLength(128)] public string Name { get; set; } = null!;
-    [MaxLength(4096)] public string Description { get; set; } = null!;
-    public decimal Price { get; set; }
-    [MaxLength(128)] public string CurrencyCode { get; set; } = null!;
-    [MaxLength(128)] public string StripeProductId { get; set; } = null!;
-    [MaxLength(128)] public string StripePriceId { get; set; } = null!;
-
-    public ICollection<Membership> Subscriptions { get; set; } = [];
-}

backend/Modules/Memberships/Data/MembershipsDbContext.cs

@@ -1,36 +0,0 @@
-namespace Hutopy.Modules.Memberships.Data;
-
-public sealed class MembershipsDbContext(
-    DbContextOptions<MembershipsDbContext> options)
-    : DbContext(options)
-{
-    public const string SchemaName = "Memberships";
-
-    public DbSet<MembershipTier> MembershipTiers => Set<MembershipTier>();
-    public DbSet<Membership> Memberships => Set<Membership>();
-    public DbSet<Payment> Payments => Set<Payment>();
-
-
-    protected override void OnModelCreating(ModelBuilder modelBuilder)
-    {
-        modelBuilder.HasDefaultSchema(SchemaName);
-
-        modelBuilder
-            .Entity<MembershipTier>()
-            .Property(c => c.CreatedAt)
-            .ValueGeneratedOnAdd()
-            .HasDefaultValueSql("CURRENT_TIMESTAMP");
-
-        modelBuilder
-            .Entity<Membership>()
-            .Property(c => c.CreatedAt)
-            .ValueGeneratedOnAdd()
-            .HasDefaultValueSql("CURRENT_TIMESTAMP");
-
-        modelBuilder
-            .Entity<Payment>()
-            .Property(c => c.CreatedAt)
-            .ValueGeneratedOnAdd()
-            .HasDefaultValueSql("CURRENT_TIMESTAMP");
-    }
-}

backend/Modules/Memberships/Data/Payment.cs

@@ -1,12 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-
-namespace Hutopy.Modules.Memberships.Data;
-
-public class Payment
-{
-    public Guid Id { get; set; }
-    public DateTimeOffset CreatedAt { get; set; }
-    public decimal Amount { get; set; }
-    [MaxLength(8)] public required string Currency { get; set; }
-    [MaxLength(2048)] public required string InvoiceUrl { get; set; }
-}

backend/Modules/Memberships/DependencyInjection.cs

@@ -1,32 +0,0 @@
-using Hutopy.Modules.Memberships.Contracts;
-using Hutopy.Modules.Memberships.Data;
-using Hutopy.Modules.Memberships.Services;
-
-namespace Hutopy.Modules.Memberships;
-
-public static class DependencyInjection
-{
-    public static WebApplicationBuilder AddMembershipModule(
-        this WebApplicationBuilder builder,
-        Action<DbContextOptionsBuilder>? configureAction = null)
-    {
-        builder.Services.AddDbContext<MembershipsDbContext>(configureAction);
-
-        builder.Services.AddTransient<IMembershipNotifier, MembershipNotifier>();
-
-        return builder;
-    }
-
-
-    public static async Task<IApplicationBuilder> UseMembershipModuleAsync(
-        this IApplicationBuilder app,
-        CancellationToken cancellationToken = default)
-    {
-        IServiceScopeFactory scopeFactory = app.ApplicationServices.GetRequiredService<IServiceScopeFactory>();
-        using IServiceScope scope = scopeFactory.CreateScope();
-        await using MembershipsDbContext context = scope.ServiceProvider.GetRequiredService<MembershipsDbContext>();
-        await context.Database.MigrateAsync(cancellationToken);
-
-        return app;
-    }
-}

backend/Modules/Memberships/Handlers/CancelMembership.cs

@@ -1,49 +0,0 @@
-using Hutopy.Modules.Memberships.Contracts;
-using Hutopy.Modules.Memberships.Data;
-
-namespace Hutopy.Modules.Memberships.Handlers;
-
-[PublicAPI]
-public class CancelMembershipRequest
-{
-    public Guid SubscriptionId { get; set; }
-}
-
-public class CancelMembershipHandler(
-    MembershipsDbContext dbContext,
-    IMembershipCancellationProcessor cancellationProcessor)
-    : Endpoint<CancelMembershipRequest>
-{
-    public override void Configure()
-    {
-        Delete("/api/memberships");
-        Options(o => o.WithTags("Memberships"));
-    }
-
-    public override async Task HandleAsync(
-        CancelMembershipRequest req,
-        CancellationToken ct)
-    {
-        Membership? subscription = await dbContext
-            .Memberships
-            .FindAsync(
-                [req.SubscriptionId],
-                ct);
-
-        if (subscription is not { EndDate: null }
-            || subscription.StripeSubscriptionId is null)
-        {
-            await SendNotFoundAsync(ct);
-            return;
-        }
-
-        // Cancel Stripe subscription
-        await cancellationProcessor.CancelAsync(subscription.StripeSubscriptionId, ct);
-
-        // Update subscription in the system
-        subscription.EndDate = DateTime.UtcNow;
-        await dbContext.SaveChangesAsync(ct);
-
-        await SendOkAsync(subscription.Id, ct);
-    }
-}

backend/Modules/Memberships/Handlers/CreateMembershipTier.cs

@@ -1,56 +0,0 @@
-using Hutopy.Modules.Memberships.Contracts;
-using Hutopy.Modules.Memberships.Data;
-
-namespace Hutopy.Modules.Memberships.Handlers;
-
-[PublicAPI]
-public record struct CreateMembershipTierRequest(
-    Guid CreatorId,
-    string Name,
-    string Description,
-    decimal Price,
-    string Currency = "CAD");
-
-[PublicAPI]
-public class CreateMembershipTierEndpoint(
-    MembershipsDbContext dbContext,
-    IMembershipTierProcessor membershipTierProcessor)
-    : Endpoint<CreateMembershipTierRequest>
-{
-    public override void Configure()
-    {
-        Post("/api/memberships/tiers");
-        Options(o => o.WithTags("Memberships"));
-    }
-
-    public override async Task HandleAsync(
-        CreateMembershipTierRequest req,
-        CancellationToken ct)
-    {
-        Guid tierId = Guid.CreateVersion7();
-
-        string productId = await membershipTierProcessor.CreateAsync(
-            req.CreatorId,
-            tierId,
-            req.Name,
-            req.Currency,
-            req.Price);
-
-        // Record the new Tier
-        MembershipTier tier = new()
-        {
-            Id = tierId,
-            CreatorId = req.CreatorId,
-            Price = req.Price,
-            Name = req.Name,
-            Description = req.Description,
-            StripeProductId = productId
-        };
-
-        dbContext.MembershipTiers.Add(tier);
-
-        await dbContext.SaveChangesAsync(ct);
-
-        await SendOkAsync(tier, ct);
-    }
-}

backend/Modules/Memberships/Handlers/GetActiveMemberships.cs

@@ -1,54 +0,0 @@
-using Hutopy.Infrastructure.Security;
-using Hutopy.Modules.Creators.Contracts;
-using Hutopy.Modules.Memberships.Data;
-
-namespace Hutopy.Modules.Memberships.Handlers;
-
-[PublicAPI]
-public record struct GetActiveMembershipsResponse(
-    Guid Id,
-    Guid CreatorId,
-    string CreatorName,
-    string CreatorPortraitUrl,
-    DateTimeOffset? StartDate,
-    DateTimeOffset? EndDate);
-
-[PublicAPI]
-public class GetActiveMembershipsHandler(
-    ICreatorLookup creatorLookup,
-    MembershipsDbContext dbContext)
-    : EndpointWithoutRequest<IEnumerable<GetActiveMembershipsResponse>>
-{
-    public override void Configure()
-    {
-        Get("/api/memberships/active");
-        Options(o => o.WithTags("Memberships"));
-    }
-
-    public override async Task HandleAsync(
-        CancellationToken ct)
-    {
-        List<Membership> subscriptions = await dbContext
-            .Memberships
-            .Where(subscription => subscription.UserId == User.GetUserId())
-            .Where(subscription => subscription.State == MembershipState.Active)
-            .ToListAsync(ct);
-
-        GetActiveMembershipsResponse[] result = await Task.WhenAll(
-            subscriptions.Select(async subscription =>
-            {
-                CreatorReference? creator = await creatorLookup.GetCreatorAsync(subscription.CreatorId, ct);
-
-                return new GetActiveMembershipsResponse(
-                    subscription.Id,
-                    subscription.CreatorId,
-                    creator?.Name ?? "Unknown Creator",
-                    creator?.PortraitUrl ?? string.Empty,
-                    subscription.StartDate,
-                    subscription.EndDate);
-            }));
-
-
-        await SendOkAsync(result, ct);
-    }
-}

backend/Modules/Memberships/Handlers/GetMembershipTiers.cs

@@ -1,52 +0,0 @@
-using Hutopy.Modules.Memberships.Data;
-
-namespace Hutopy.Modules.Memberships.Handlers;
-
-[PublicAPI]
-public record GetMembershipTiersRequest
-{
-    public Guid CreatorId { get; set; }
-}
-
-[PublicAPI]
-public record struct TierModel(
-    Guid Id,
-    DateTimeOffset CreatedAt,
-    string Name,
-    string Description,
-    decimal Price,
-    string CurrencyCode,
-    string StripeProductId);
-
-[PublicAPI]
-public class GetMembershipTiersEndpoint(
-    MembershipsDbContext dbContext)
-    : Endpoint<GetMembershipTiersRequest, List<TierModel>>
-{
-    public override void Configure()
-    {
-        Get("/api/memberships/tiers/{CreatorId:guid}");
-        Options(o => o.WithTags("Memberships"));
-        AllowAnonymous();
-    }
-
-    public override async Task HandleAsync(
-        GetMembershipTiersRequest req,
-        CancellationToken ct)
-    {
-        List<TierModel> tiers = await dbContext
-            .MembershipTiers
-            .Where(tier => tier.CreatorId == req.CreatorId)
-            .Select(tier => new TierModel(
-                tier.Id,
-                tier.CreatedAt,
-                tier.Name,
-                tier.Description,
-                tier.Price,
-                tier.CurrencyCode,
-                tier.StripeProductId))
-            .ToListAsync(ct);
-
-        await SendOkAsync(tiers, ct);
-    }
-}

backend/Modules/Memberships/Handlers/StripeWebhookEndpoint.cs

@@ -1,119 +0,0 @@
-using System.Diagnostics;
-using Hutopy.Infrastructure.Payments.Stripe.Configuration;
-using Hutopy.Modules.Memberships.Contracts;
-using Hutopy.Modules.Tipping.Contracts;
-using Microsoft.Extensions.Options;
-using Stripe;
-using Stripe.Checkout;
-
-namespace Hutopy.Modules.Memberships.Handlers;
-
-internal class StripeWebhookEndpoint(
-    ITipPaymentNotifier tipPaymentNotifier,
-    IMembershipNotifier membershipNotifier,
-    IOptions<StripeOptions> stripeOptions)
-    : EndpointWithoutRequest
-{
-    public override void Configure()
-    {
-        Post("/api/stripe");
-        AllowAnonymous();
-        Options(o => o.WithTags("Webhooks"));
-    }
-
-    public override async Task HandleAsync(CancellationToken ct)
-    {
-        var signatureHeader = HttpContext.Request.Headers["Stripe-Signature"];
-        using StreamReader streamReader = new(HttpContext.Request.Body);
-
-        var json = await streamReader.ReadToEndAsync(ct).ConfigureAwait(false);
-
-        var stripeEvent = EventUtility.ConstructEvent(json, signatureHeader, stripeOptions.Value.WebhookSecret);
-
-        var stripeSession = stripeEvent.Data.Object as Session;
-        var stripeSubscription = stripeEvent.Data.Object as Subscription;
-
-        switch (stripeEvent.Type)
-        {
-            case "checkout.session.completed":
-                Debug.Assert(stripeSession != null);
-                switch (stripeSession.Mode)
-                {
-                    // Check if this is a one-time tip
-                    case "payment" when stripeSession is { PaymentIntentId: not null, PaymentStatus: "paid" }:
-                        // Get the customer email from the appropriate place
-                        var customerEmail = stripeSession.CustomerDetails?.Email ??
-                                            stripeSession.Customer?.Email ??
-                                            "";
-
-                        StripeConfiguration.ApiKey = stripeOptions.Value.SecretKey;
-                        var paymentIntentService = new PaymentIntentService();
-                        var paymentIntent = await paymentIntentService
-                            .GetAsync(
-                                stripeSession.PaymentIntentId,
-                                new PaymentIntentGetOptions { Expand = ["latest_charge"] },
-                                cancellationToken: ct)
-                            .ConfigureAwait(false);
-                        var receiptUrl = paymentIntent.LatestCharge.ReceiptUrl;
-                        var receiptUri = new Uri(receiptUrl);
-
-                        // Get the receipt URL, preferring the one directly on the charge if available
-                        await tipPaymentNotifier
-                            .NotifyPaymentSucceedAsync(
-                                stripeSession.Id,
-                                receiptUri,
-                                customerEmail,
-                                ct)
-                            .ConfigureAwait(false);
-                        break;
-
-                    // Check if this is a subscription
-                    case "subscription" when stripeSession.SubscriptionId != null:
-                        await membershipNotifier
-                            .NotifyPaymentSucceedAsync(
-                                stripeSession.SubscriptionId,
-                                stripeSession.Invoice.HostedInvoiceUrl,
-                                stripeSession.Invoice.Total,
-                                stripeSession.Invoice.Currency,
-                                ct)
-                            .ConfigureAwait(false);
-                        break;
-                }
-
-                break;
-            case "invoice.payment_succeeded":
-                var invoice = stripeEvent.Data.Object as Invoice;
-                Debug.Assert(invoice != null);
-                Debug.Assert(invoice.Subscription != null);
-                await membershipNotifier
-                    .NotifyPaymentSucceedAsync(
-                        invoice.SubscriptionId,
-                        invoice.HostedInvoiceUrl,
-                        invoice.Total,
-                        invoice.Currency,
-                        ct)
-                    .ConfigureAwait(false);
-                break;
-
-            case "customer.subscription.updated":
-                Debug.Assert(stripeSubscription != null);
-                await membershipNotifier
-                    .NotifySubscriptionUpdatedAsync(
-                        stripeSubscription.Id,
-                        stripeSubscription.CancelAt ?? stripeSubscription.CanceledAt,
-                        ct)
-                    .ConfigureAwait(false);
-                break;
-            case "customer.subscription.deleted":
-                Debug.Assert(stripeSubscription != null);
-                await membershipNotifier
-                    .NotifySubscriptionDeletedAsync(
-                        stripeSubscription.Id,
-                        ct)
-                    .ConfigureAwait(false);
-                break;
-        }
-
-        await SendOkAsync(ct).ConfigureAwait(false);
-    }
-}

backend/Modules/Memberships/Handlers/SubscribeToCreator.cs

@@ -1,83 +0,0 @@
-using Hutopy.Infrastructure.Security;
-using Hutopy.Modules.Creators.Contracts;
-using Hutopy.Modules.Memberships.Contracts;
-using Hutopy.Modules.Memberships.Data;
-
-namespace Hutopy.Modules.Memberships.Handlers;
-
-[PublicAPI]
-public class SubscribeRequest
-{
-    public Guid CreatorId { get; set; }
-    public Guid MembershipTierId { get; set; }
-    public required string CheckoutSuccessUrl { get; init; }
-    public required string CheckoutCancelledUrl { get; init; }
-}
-
-[PublicAPI]
-public record struct SubscriptionResponse(
-    string StripeCheckoutUrl);
-
-[PublicAPI]
-public class SubscribeValidator : Validator<SubscribeRequest>
-{
-    public SubscribeValidator()
-    {
-        RuleFor(x => x.MembershipTierId).NotEmpty();
-    }
-}
-
-[PublicAPI]
-public class SubscribeHandler(
-    MembershipsDbContext dbContext,
-    ICreatorLookup creatorLookup,
-    IMembershipPaymentProcessor membershipPaymentProcessor)
-    : Endpoint<SubscribeRequest, SubscriptionResponse>
-{
-    public override void Configure()
-    {
-        Post("/api/memberships/subscribe");
-        Options(o => o.WithTags("Memberships"));
-    }
-
-    public override async Task HandleAsync(
-        SubscribeRequest req,
-        CancellationToken ct)
-    {
-        MembershipTier? tier = await dbContext
-            .MembershipTiers
-            .Where(tier => tier.Id == req.MembershipTierId)
-            .FirstOrDefaultAsync(ct);
-        if (tier == null)
-        {
-            await SendNotFoundAsync(ct);
-            return;
-        }
-
-        CreatorReference? creator = await creatorLookup.GetCreatorAsync(tier.CreatorId, ct);
-        if (creator == null)
-        {
-            await SendNotFoundAsync(ct);
-            return;
-        }
-
-        if (!creator.AcceptCharges)
-        {
-            await SendErrorsAsync(StatusCodes.Status400BadRequest, ct);
-            return;
-        }
-
-        // Process Stripe subscription
-        MembershipCheckoutSession checkoutSession = await membershipPaymentProcessor.CreateCheckoutSessionAsync(
-            User.GetUserId(),
-            creator,
-            tier.Id,
-            tier.StripePriceId,
-            req.CheckoutSuccessUrl,
-            req.CheckoutCancelledUrl);
-
-        await SendOkAsync(
-            new SubscriptionResponse { StripeCheckoutUrl = checkoutSession.Url },
-            ct);
-    }
-}

backend/Modules/Memberships/Migrations/20250609212641_Initial.Designer.cs

@@ -1,190 +0,0 @@
-// <auto-generated />
-using System;
-using Hutopy.Modules.Memberships.Data;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Infrastructure;
-using Microsoft.EntityFrameworkCore.Migrations;
-using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
-using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
-
-#nullable disable
-
-namespace Hutopy.Modules.Memberships.Migrations
-{
-    [DbContext(typeof(MembershipsDbContext))]
-    [Migration("20250609212641_Initial")]
-    partial class Initial
-    {
-        /// <inheritdoc />
-        protected override void BuildTargetModel(ModelBuilder modelBuilder)
-        {
-#pragma warning disable 612, 618
-            modelBuilder
-                .HasDefaultSchema("Memberships")
-                .HasAnnotation("ProductVersion", "9.0.3")
-                .HasAnnotation("Relational:MaxIdentifierLength", 63);
-
-            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
-
-            modelBuilder.Entity("Hutopy.Modules.Memberships.Data.Membership", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTimeOffset>("CreatedAt")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("timestamp with time zone")
-                        .HasDefaultValueSql("CURRENT_TIMESTAMP");
-
-                    b.Property<Guid>("CreatorId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTimeOffset?>("EndDate")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<Guid?>("MembershipTierId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTimeOffset?>("StartDate")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<int>("State")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("StripeSubscriptionId")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<Guid>("TierId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("UserId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("MembershipTierId");
-
-                    b.ToTable("Memberships", "Memberships");
-                });
-
-            modelBuilder.Entity("Hutopy.Modules.Memberships.Data.MembershipTier", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTimeOffset>("CreatedAt")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("timestamp with time zone")
-                        .HasDefaultValueSql("CURRENT_TIMESTAMP");
-
-                    b.Property<Guid>("CreatedBy")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("CreatorId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("CurrencyCode")
-                        .IsRequired()
-                        .HasMaxLength(128)
-                        .HasColumnType("character varying(128)");
-
-                    b.Property<DateTimeOffset?>("DeletedAt")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<Guid?>("DeletedBy")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("Description")
-                        .IsRequired()
-                        .HasMaxLength(4096)
-                        .HasColumnType("character varying(4096)");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasMaxLength(128)
-                        .HasColumnType("character varying(128)");
-
-                    b.Property<decimal>("Price")
-                        .HasColumnType("numeric");
-
-                    b.Property<string>("StripePriceId")
-                        .IsRequired()
-                        .HasMaxLength(128)
-                        .HasColumnType("character varying(128)");
-
-                    b.Property<string>("StripeProductId")
-                        .IsRequired()
-                        .HasMaxLength(128)
-                        .HasColumnType("character varying(128)");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("MembershipTiers", "Memberships");
-                });
-
-            modelBuilder.Entity("Hutopy.Modules.Memberships.Data.Payment", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<decimal>("Amount")
-                        .HasColumnType("numeric");
-
-                    b.Property<DateTimeOffset>("CreatedAt")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("timestamp with time zone")
-                        .HasDefaultValueSql("CURRENT_TIMESTAMP");
-
-                    b.Property<string>("Currency")
-                        .IsRequired()
-                        .HasMaxLength(8)
-                        .HasColumnType("character varying(8)");
-
-                    b.Property<string>("InvoiceUrl")
-                        .IsRequired()
-                        .HasMaxLength(2048)
-                        .HasColumnType("character varying(2048)");
-
-                    b.Property<Guid?>("MembershipId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("MembershipId");
-
-                    b.ToTable("Payments", "Memberships");
-                });
-
-            modelBuilder.Entity("Hutopy.Modules.Memberships.Data.Membership", b =>
-                {
-                    b.HasOne("Hutopy.Modules.Memberships.Data.MembershipTier", "MembershipTier")
-                        .WithMany("Subscriptions")
-                        .HasForeignKey("MembershipTierId");
-
-                    b.Navigation("MembershipTier");
-                });
-
-            modelBuilder.Entity("Hutopy.Modules.Memberships.Data.Payment", b =>
-                {
-                    b.HasOne("Hutopy.Modules.Memberships.Data.Membership", null)
-                        .WithMany("Payments")
-                        .HasForeignKey("MembershipId");
-                });
-
-            modelBuilder.Entity("Hutopy.Modules.Memberships.Data.Membership", b =>
-                {
-                    b.Navigation("Payments");
-                });
-
-            modelBuilder.Entity("Hutopy.Modules.Memberships.Data.MembershipTier", b =>
-                {
-                    b.Navigation("Subscriptions");
-                });
-#pragma warning restore 612, 618
-        }
-    }
-}