Epic 6: Automated Speaker Onboarding - Architecture Plan

        ┌──────────────┐
        │  IDENTIFIED  │  Speaker added to pool
        └──────┬───────┘
               │ Send invitation (auto/manual)
               ▼
        ┌──────────────┐
        │   INVITED    │  Awaiting response
        └──────┬───────┘
               │
        ┌──────┴──────┐
        ▼             ▼
┌──────────────┐ ┌──────────────┐
│   ACCEPTED   │ │   DECLINED   │ (terminal)
└──────┬───────┘ └──────────────┘
       │
       ├─────────────────┐
       ▼                 ▼
┌──────────────┐  ┌──────────────┐
│  CONFIRMED   │  │   WITHDREW   │ (terminal)
└──────────────┘  └──────────────┘
   (terminal)

INVITED (is_tentative=false) ──▶ Speaker clicks "Maybe" ──▶ INVITED (is_tentative=true)
                                                                    │
                                                         ┌──────────┴──────────┐
                                                         ▼                     ▼
                                                    ACCEPTED              DECLINED

┌─────────────────────────────────────────────────────────────────┐
│                    SESSION ASSIGNMENT FLOW                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Option A: Invite with session                                  │
│  ───────────────────────────────                                │
│  Organizer selects session → Invite sent with sessionId         │
│  Speaker accepts → Can immediately submit content               │
│                                                                 │
│  Option B: Invite to general pool                               │
│  ─────────────────────────────────                              │
│  Organizer invites without session → sessionId = NULL           │
│  Speaker accepts → Organizer assigns session later              │
│  Session assigned → Speaker can now submit content              │
│                                                                 │
│  Content submission blocked until session_id is set             │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                        SPEAKER ONBOARDING WORKFLOW                          │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐    ┌───────────┐ │
│  │  IDENTIFIED  │───▶│   INVITED    │───▶│   ACCEPTED   │───▶│ CONFIRMED │ │
│  │   (Pool)     │    │   (Email)    │    │   (Portal)   │    │  (Final)  │ │
│  └──────────────┘    └──────────────┘    └──────────────┘    └───────────┘ │
│        │                    │                   │                  │        │
│        ▼                    ▼                   ▼                  ▼        │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐    ┌───────────┐ │
│  │ SpeakerPool  │    │  AWS SES     │    │  Portal UI   │    │  Profile  │ │
│  │ (Organizer)  │    │  Magic Link  │    │  Response    │    │  Content  │ │
│  └──────────────┘    └──────────────┘    │  Form        │    │  Upload   │ │
│                                          └──────────────┘    └───────────┘ │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

                              ┌──────────────────────┐
                              │   CONTENT WORKFLOW   │
                              │  (Parallel to State) │
                              ├──────────────────────┤
                              │                      │
                              │  ┌────────────────┐  │
                              │  │ Profile Update │  │
                              │  │ - Bio          │  │
                              │  │ - Photo        │  │
                              │  │ - Expertise    │  │
                              │  └────────────────┘  │
                              │         │           │
                              │         ▼           │
                              │  ┌────────────────┐  │
                              │  │ Session Info   │  │
                              │  │ - Title        │  │
                              │  │ - Abstract     │  │
                              │  └────────────────┘  │
                              │         │           │
                              │         ▼           │
                              │  ┌────────────────┐  │
                              │  │ File Upload    │  │
                              │  │ - PPTX/PDF     │  │
                              │  │ - Handouts     │  │
                              │  └────────────────┘  │
                              │         │           │
                              │         ▼           │
                              │  ┌────────────────┐  │
                              │  │ Quality Review │  │
                              │  │ (Organizer)    │  │
                              │  └────────────────┘  │
                              │                      │
                              │  Status: PENDING →   │
                              │  SUBMITTED → APPROVED│
                              │                      │
                              └──────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│                   MAGIC LINK AUTHENTICATION                     │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Email Link Structure:                                          │
│  https://portal.batbern.ch/speaker/respond/{token}              │
│                                                                 │
│  Token Properties:                                              │
│  - JWT with speaker_invitation claim                            │
│  - Contains: speakerId, eventCode, sessionId, action            │
│  - Expiry: 30 days (configurable)                               │
│  - Single-use for state-changing actions (Accept/Decline)       │
│  - Reusable for read-only actions (View dashboard)              │
│                                                                 │
│  Database Schema:                                               │
│  CREATE TABLE speaker_invitation_tokens (                       │
│      id UUID PRIMARY KEY,                                       │
│      speaker_id UUID NOT NULL,                                  │
│      event_id UUID NOT NULL,                                    │
│      session_id UUID,                                           │
│      token_hash VARCHAR(255) UNIQUE NOT NULL, -- SHA-256        │
│      action VARCHAR(50) NOT NULL, -- RESPOND, SUBMIT, VIEW      │
│      expires_at TIMESTAMP NOT NULL,                             │
│      used_at TIMESTAMP,                                         │
│      created_at TIMESTAMP DEFAULT NOW()                         │
│  );                                                             │
│                                                                 │
│  Security:                                                      │
│  - Token stored as hash (SHA-256)                               │
│  - Rate limiting: 5 requests/minute per token                   │
│  - IP logging for audit trail                                   │
│  - HTTPS only                                                   │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

// Email Template Structure
public record SpeakerInvitationEmail(
    String speakerName,
    String speakerEmail,
    String eventName,
    String eventDate,
    String sessionTitle,
    String sessionDescription,
    String responseDeadline,
    String acceptLink,      // Magic link for acceptance
    String declineLink,     // Magic link for decline
    String organizerName,
    String organizerEmail
) {}

// Email Service Extension
@Service
public class SpeakerInvitationService {

    @Async
    public void sendInvitation(SpeakerInvitation invitation) {
        // 1. Generate magic links (accept/decline)
        String acceptToken = generateMagicToken(invitation, Action.ACCEPT);
        String declineToken = generateMagicToken(invitation, Action.DECLINE);

        // 2. Build email from template
        String emailBody = templateEngine.process("speaker-invitation", Map.of(
            "acceptLink", buildPortalUrl(acceptToken),
            "declineLink", buildPortalUrl(declineToken),
            // ... other variables
        ));

        // 3. Send via AWS SES
        emailService.sendHtmlEmail(
            invitation.speakerEmail(),
            "BATbern Invitation: " + invitation.eventName(),
            emailBody
        );

        // 4. Emit domain event
        eventPublisher.publish(new SpeakerInvitationSentEvent(...));

        // 5. Update speaker status
        updateSpeakerStatus(invitation.speakerId(), CONTACTED);
    }
}

web-frontend/src/pages/speaker-portal/
├── SpeakerPortalLayout.tsx       # Layout with minimal nav (no full auth)
├── InvitationResponsePage.tsx    # Accept/Decline (Tentative removed from UI 2026-02-11)
├── ProfileUpdatePage.tsx         # Bio, photo, expertise
├── ContentSubmissionPage.tsx     # Title, abstract, files
├── SpeakerDashboardPage.tsx      # View upcoming/past events
└── components/
    ├── ResponseForm.tsx          # Availability, constraints
    ├── ProfileForm.tsx           # Speaker profile editor
    ├── ContentWizard.tsx         # Multi-step submission
    └── MaterialUpload.tsx        # Reuse FileUpload component

# Speaker Portal API (public with magic link auth)

# Respond to invitation
POST /api/v1/speaker-portal/respond
  Body: {
    token: string,
    response: "ACCEPT" | "DECLINE" | "TENTATIVE",
    reason?: string,           # Required if DECLINE or TENTATIVE
    constraints?: string       # Optional: travel, schedule constraints
  }
  Response: 200 OK {
    speakerName: string,
    eventName: string,
    eventDate: string,
    sessionTitle?: string,     # If session assigned
    nextSteps: string[],       # ["Complete your profile", "Submit title and abstract"]
    contentDeadline?: string   # If accepted
  }
  Notes:
    - ACCEPT → workflow_state = ACCEPTED
    - DECLINE → workflow_state = DECLINED
    - TENTATIVE → workflow_state stays INVITED, is_tentative = true

# Get speaker profile (combined User + Speaker data)
GET /api/v1/speaker-portal/profile?token={token}
  Response: 200 OK {
    username: string,
    email: string,
    firstName: string,
    lastName: string,
    bio?: string,
    profilePictureUrl?: string,
    expertiseAreas?: string[],
    speakingTopics?: string[],
    linkedInUrl?: string,
    languages?: string[]
  }

# Update speaker profile (syncs to User entity per ADR-004)
PATCH /api/v1/speaker-portal/profile
  Body: {
    token: string,
    bio?: string,              # Updates User.bio in Company Service
    firstName?: string,        # Updates User.firstName
    lastName?: string,         # Updates User.lastName
    expertiseAreas?: string[], # Updates Speaker.expertiseAreas
    speakingTopics?: string[], # Updates Speaker.speakingTopics
    linkedInUrl?: string,      # Updates Speaker.linkedInUrl
    languages?: string[]       # Updates Speaker.languages
  }
  Response: 200 OK { updated profile }
  Notes:
    - Profile changes sync to User entity (single source of truth)
    - Changes apply to ALL events (not event-specific)

# Submit content (title + abstract)
POST /api/v1/speaker-portal/content
  Body: {
    token: string,
    title: string,             # Max 200 chars
    abstract: string           # Max 1000 chars
  }
  Response: 201 Created {
    submissionId: string,
    version: number,
    status: "SUBMITTED",
    sessionTitle: string
  }
  Error 400: "Session not assigned - contact organizer"
  Notes:
    - Requires session_id on SpeakerPool (organizer must assign first)
    - Sets content_status = SUBMITTED
    - Creates ContentSubmission record with version

# Get presigned URL for file upload
POST /api/v1/speaker-portal/materials/presigned-url
  Body: {
    token: string,
    fileName: string,
    contentType: string        # application/pdf, application/vnd.ms-powerpoint, etc.
  }
  Response: 200 OK {
    uploadUrl: string,         # S3 presigned PUT URL
    uploadId: string,
    expiresIn: number          # seconds until URL expires (900)
  }

# Confirm file upload
POST /api/v1/speaker-portal/materials/confirm
  Body: {
    token: string,
    uploadId: string,
    materialType: "PRESENTATION" | "DOCUMENT" | "VIDEO" | "OTHER"
  }
  Response: 200 OK {
    materialId: string,
    fileName: string,
    cloudfrontUrl: string
  }

┌─────────────────────────────────────────────────────────────────┐
│              CONTENT STATUS (Independent of Workflow)           │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│   Speaker in ACCEPTED state can submit/revise content:          │
│                                                                 │
│   ┌─────────┐    ┌───────────┐    ┌──────────┐                 │
│   │ PENDING │───▶│ SUBMITTED │───▶│ APPROVED │                 │
│   └─────────┘    └─────┬─────┘    └──────────┘                 │
│                        │                                        │
│                        │  ⬅─── QUALITY REVIEW HAPPENS HERE      │
│                        │        (Organizer reviews content)     │
│                        ▼                                        │
│                 ┌────────────────┐                              │
│                 │REVISION_NEEDED │──▶ Speaker fixes ──▶ SUBMITTED│
│                 └────────────────┘                              │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│                    QUALITY REVIEW CHECKLIST                     │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Organizer reviews content when content_status = SUBMITTED:     │
│                                                                 │
│  REQUIRED:                                                      │
│  □ Title: Clear, descriptive, not promotional                   │
│  □ Abstract: ≤1000 chars, includes lessons learned              │
│  □ Abstract: Not product promotion or sales pitch               │
│                                                                 │
│  OPTIONAL (can be uploaded later):                              │
│  ○ Presentation file (PPTX/PDF)                                 │
│  ○ Handouts                                                     │
│                                                                 │
│  Actions:                                                       │
│  ├─ Title + Abstract OK → Set status to APPROVED                │
│  └─ Issues found → Set status to REVISION_NEEDED                │
│                    + Add reviewer_feedback                      │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

-- ============================================
-- Flyway Migration: V43__Add_speaker_content_tracking.sql
-- ============================================

-- Extend speaker_pool with simplified workflow + content tracking
-- NOTE: workflow_state column may already exist - use IF NOT EXISTS pattern

-- New columns for 6-state workflow
ALTER TABLE speaker_pool ADD COLUMN IF NOT EXISTS content_status VARCHAR(20) DEFAULT 'PENDING';
ALTER TABLE speaker_pool ADD COLUMN IF NOT EXISTS content_submitted_at TIMESTAMP;
ALTER TABLE speaker_pool ADD COLUMN IF NOT EXISTS content_approved_at TIMESTAMP;
ALTER TABLE speaker_pool ADD COLUMN IF NOT EXISTS content_approved_by VARCHAR(255);
ALTER TABLE speaker_pool ADD COLUMN IF NOT EXISTS is_overflow BOOLEAN DEFAULT FALSE;

-- Timestamps for state transitions
ALTER TABLE speaker_pool ADD COLUMN IF NOT EXISTS invited_at TIMESTAMP;
ALTER TABLE speaker_pool ADD COLUMN IF NOT EXISTS accepted_at TIMESTAMP;
ALTER TABLE speaker_pool ADD COLUMN IF NOT EXISTS declined_at TIMESTAMP;
ALTER TABLE speaker_pool ADD COLUMN IF NOT EXISTS withdrew_at TIMESTAMP;
ALTER TABLE speaker_pool ADD COLUMN IF NOT EXISTS confirmed_at TIMESTAMP;

-- Deadline tracking
ALTER TABLE speaker_pool ADD COLUMN IF NOT EXISTS response_deadline TIMESTAMP;
ALTER TABLE speaker_pool ADD COLUMN IF NOT EXISTS content_deadline TIMESTAMP;

-- Tentative response tracking (speaker interested but not committed)
ALTER TABLE speaker_pool ADD COLUMN IF NOT EXISTS is_tentative BOOLEAN DEFAULT FALSE;
ALTER TABLE speaker_pool ADD COLUMN IF NOT EXISTS tentative_reason TEXT;

-- Indexes for common queries
CREATE INDEX IF NOT EXISTS idx_speaker_pool_content_status ON speaker_pool(content_status);
CREATE INDEX IF NOT EXISTS idx_speaker_pool_overflow ON speaker_pool(is_overflow) WHERE is_overflow = TRUE;
CREATE INDEX IF NOT EXISTS idx_speaker_pool_response_deadline ON speaker_pool(response_deadline)
    WHERE response_deadline IS NOT NULL;

-- Content submissions (supports versioning for revision cycles)
CREATE TABLE IF NOT EXISTS speaker_content_submissions (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    speaker_pool_id UUID NOT NULL REFERENCES speaker_pool(id) ON DELETE CASCADE,
    session_id UUID REFERENCES sessions(id),
    title VARCHAR(200) NOT NULL,
    abstract TEXT NOT NULL,  -- Max 1000 chars enforced in app
    abstract_char_count INTEGER NOT NULL,
    submission_version INTEGER DEFAULT 1,
    reviewer_feedback TEXT,
    submitted_at TIMESTAMP DEFAULT NOW(),
    reviewed_at TIMESTAMP,
    reviewed_by VARCHAR(255),

    CONSTRAINT chk_abstract_length CHECK (abstract_char_count <= 1000)
);

CREATE INDEX IF NOT EXISTS idx_content_submissions_speaker ON speaker_content_submissions(speaker_pool_id);
CREATE INDEX IF NOT EXISTS idx_content_submissions_session ON speaker_content_submissions(session_id);

-- ============================================
-- Flyway Migration: V44__Create_speaker_invitation_tokens.sql
-- ============================================

CREATE TABLE speaker_invitation_tokens (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    speaker_pool_id UUID NOT NULL REFERENCES speaker_pool(id) ON DELETE CASCADE,
    token_hash VARCHAR(64) NOT NULL UNIQUE,  -- SHA-256 hash
    action VARCHAR(20) NOT NULL,             -- RESPOND, SUBMIT, VIEW
    expires_at TIMESTAMP WITH TIME ZONE NOT NULL,
    used_at TIMESTAMP WITH TIME ZONE,
    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),

    CONSTRAINT chk_token_action CHECK (action IN ('RESPOND', 'SUBMIT', 'VIEW'))
);

CREATE INDEX idx_invitation_tokens_hash ON speaker_invitation_tokens(token_hash);
CREATE INDEX idx_invitation_tokens_speaker ON speaker_invitation_tokens(speaker_pool_id);
CREATE INDEX idx_invitation_tokens_expires ON speaker_invitation_tokens(expires_at)
    WHERE used_at IS NULL;

-- ============================================
-- Flyway Migration: V45__Migrate_workflow_states.sql
-- ============================================

-- Migrate existing workflow states to simplified 6-state model
-- Old state → New state mapping:
--   CONTACTED → INVITED
--   READY → INVITED (with is_tentative = true)
--   CONTENT_SUBMITTED → ACCEPTED (content_status = SUBMITTED)
--   QUALITY_REVIEWED → ACCEPTED (content_status = APPROVED)
--   SLOT_ASSIGNED → ACCEPTED (content_status = APPROVED)
--   OVERFLOW → ACCEPTED (is_overflow = true)

UPDATE speaker_pool SET status = 'INVITED' WHERE status = 'CONTACTED';
UPDATE speaker_pool SET status = 'INVITED', is_tentative = TRUE WHERE status = 'READY';
UPDATE speaker_pool SET status = 'ACCEPTED', content_status = 'SUBMITTED' WHERE status = 'CONTENT_SUBMITTED';
UPDATE speaker_pool SET status = 'ACCEPTED', content_status = 'APPROVED' WHERE status = 'QUALITY_REVIEWED';
UPDATE speaker_pool SET status = 'ACCEPTED', content_status = 'APPROVED' WHERE status = 'SLOT_ASSIGNED';
UPDATE speaker_pool SET status = 'ACCEPTED', is_overflow = TRUE WHERE status = 'OVERFLOW';

-- Add constraint to enforce new valid states only
ALTER TABLE speaker_pool ADD CONSTRAINT chk_workflow_state
    CHECK (status IN ('IDENTIFIED', 'INVITED', 'ACCEPTED', 'DECLINED', 'CONFIRMED', 'WITHDREW'));

// Reminder Configuration
public record ReminderRule(
    EventType eventType,          // Conference, Workshop, etc.
    ReminderTier tier,            // TIER_1 (friendly), TIER_2 (urgent), TIER_3 (escalate)
    int daysBeforeDeadline,       // e.g., 30, 14, 3
    boolean autoEscalate,         // Escalate to organizer after TIER_3
    String emailTemplate          // Template name
) {}

// Scheduler Job
@Scheduled(cron = "0 0 9 * * *")  // Daily at 9 AM
public void processDeadlineReminders() {
    // 1. Find speakers with upcoming deadlines
    List<SpeakerDeadline> deadlines = findUpcomingDeadlines();

    // 2. Match against reminder rules
    for (SpeakerDeadline deadline : deadlines) {
        ReminderRule rule = findApplicableRule(deadline);
        if (rule != null && !alreadySent(deadline, rule)) {
            sendReminder(deadline, rule);
            logReminder(deadline, rule);
        }
    }
}

┌─────────────────────────────────────────────────────────────────────────────┐
│                    SPEAKER DOMAIN MODEL (6-State Workflow)                  │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────┐        ┌──────────────────┐        ┌──────────────────┐  │
│  │    User      │◄───────│     Speaker      │        │   SpeakerPool    │  │
│  │ (Company Svc)│   via  │ (Global Profile) │        │ (Event-specific) │  │
│  └──────────────┘ username└──────────────────┘        └────────┬─────────┘  │
│        │                        │                              │            │
│        ▼                        ▼                              │            │
│  ┌──────────────┐        ┌──────────────────┐                  │            │
│  │ Profile Data │        │ Speaker-specific │                  │            │
│  │ - name       │        │ - expertise[]    │                  │            │
│  │ - email      │        │ - topics[]       │                  │            │
│  │ - bio        │        │ - languages[]    │                  │            │
│  │ - photo      │        │ - linkedin       │                  │            │
│  └──────────────┘        └──────────────────┘                  │            │
│                                                                │            │
│  ┌─────────────────────────────────────────────────────────────┘            │
│  │                                                                          │
│  │  SpeakerPool (Event-Speaker Association)                                 │
│  │  ┌────────────────────────────────────────────────────────────────────┐  │
│  │  │ workflow_state: IDENTIFIED|INVITED|ACCEPTED|DECLINED|CONFIRMED|WITHDREW│
│  │  │ content_status: PENDING|SUBMITTED|APPROVED|REVISION_NEEDED         │  │
│  │  │ is_overflow: boolean, is_tentative: boolean, tentative_reason: text│  │
│  │  │ response_deadline, content_deadline                                │  │
│  │  │ invited_at, accepted_at, declined_at, withdrew_at, confirmed_at    │  │
│  │  │ content_submitted_at, content_approved_at, content_approved_by     │  │
│  │  └────────────────────────────────────────────────────────────────────┘  │
│  │           │                              │                               │
│  │           ▼                              ▼                               │
│  │  ┌──────────────────┐           ┌──────────────────┐                    │
│  │  │ ContentSubmission│           │  SessionMaterial │                    │
│  │  │ - title          │           │  - file (S3)     │                    │
│  │  │ - abstract       │           │  - type (PPTX,   │                    │
│  │  │ - version        │           │    PDF, VIDEO)   │                    │
│  │  │ - reviewer_      │           │  - cloudfront_url│                    │
│  │  │   feedback       │           └──────────────────┘                    │
│  │  └──────────────────┘                                                   │
│  │                                                                          │
│  └──────────────────────────────────────────────────────────────────────────┘
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    Magic Link Tokens                                 │   │
│  │  ┌────────────────────────────────────────────────────────────────┐  │   │
│  │  │ speaker_invitation_tokens                                      │  │   │
│  │  │ - token_hash (SHA-256)                                         │  │   │
│  │  │ - speaker_pool_id                                              │  │   │
│  │  │ - action: RESPOND|SUBMIT|VIEW                                  │  │   │
│  │  │ - expires_at, used_at                                          │  │   │
│  │  └────────────────────────────────────────────────────────────────┘  │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│                    SPEAKER-USER RELATIONSHIP                    │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Speaker.username ──references──▶ User.username                 │
│  (Event Service)                  (Company Service)             │
│                                                                 │
│  - No database FK (cross-service, ADR-004)                      │
│  - User data fetched via HTTP enrichment                        │
│  - username is the meaningful identifier (ADR-003)              │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│              INVITE SPEAKER (Auto-Create User)                  │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  1. Organizer enters speaker email (+ optional name)            │
│                                                                 │
│  2. System checks: Does User with this email exist?             │
│     ├─ YES: Link SpeakerPool to existing username               │
│     └─ NO:  Create User with role=SPEAKER                       │
│             └─ Generate username from email (john.doe@x.com     │
│                → john.doe or john.doe.2 if taken)               │
│                                                                 │
│  3. Create SpeakerPool entry:                                   │
│     - event_id: current event                                   │
│     - username: linked user                                     │
│     - workflow_state: IDENTIFIED                                │
│                                                                 │
│  4. Send invitation email with magic link                       │
│     - workflow_state → INVITED                                  │
│                                                                 │
│  5. Speaker clicks link, can:                                   │
│     - Complete profile (updates User entity)                    │
│     - Accept/Decline (updates SpeakerPool)                      │
│     - Submit content (creates ContentSubmission)                │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

// When organizer invites a speaker by email
public SpeakerPool inviteSpeaker(String eventId, String email, String name) {
    // 1. Find or create User
    User user = userService.findByEmail(email)
        .orElseGet(() -> userService.createSpeakerUser(email, name));

    // 2. Create SpeakerPool entry
    SpeakerPool speakerPool = SpeakerPool.builder()
        .eventId(eventId)
        .username(user.getUsername())  // Link via username
        .workflowState(IDENTIFIED)
        .build();

    return speakerPoolRepository.save(speakerPool);
}

// User creation for new speakers
public User createSpeakerUser(String email, String name) {
    String username = generateUsername(email);  // john.doe@x.com → john.doe

    return User.builder()
        .username(username)
        .email(email)
        .firstName(extractFirstName(name))
        .lastName(extractLastName(name))
        .role(Role.SPEAKER)
        .status(UserStatus.PENDING)  // Activated on first portal access
        .build();
}

// Speaker can only access their own data
@PreAuthorize("@speakerPortalSecurity.validateToken(#token)")
public ResponseEntity<?> getProfile(@RequestParam String token) {
    // Token validation extracts speakerId
    // Only returns data for that speaker
}

// Organizer override for assistance
@PreAuthorize("hasRole('ORGANIZER')")
public ResponseEntity<?> getAnyProfile(@PathVariable String username) {
    // Full access for organizers
}