karaoke-gen 0.96.0__py3-none-any.whl → 0.101.0__py3-none-any.whl

backend/api/routes/users.py

@@ -8,8 +8,28 @@ Handles:
 - Stripe checkout and webhooks
 - Admin user management
 """
+import hashlib
 import logging
 from typing import Optional, Tuple
+
+
+def _mask_email(email: str) -> str:
+    """Mask email for logging to avoid PII exposure.
+
+    Example: test@example.com -> te***@ex***.com
+    """
+    if not email or "@" not in email:
+        return "***"
+    local, domain = email.split("@", 1)
+    masked_local = local[:2] + "***" if len(local) > 2 else "***"
+    domain_parts = domain.split(".")
+    if len(domain_parts) >= 2:
+        masked_domain = domain_parts[0][:2] + "***." + domain_parts[-1]
+    else:
+        masked_domain = "***"
+    return f"{masked_local}@{masked_domain}"
+
+
 from fastapi import APIRouter, HTTPException, Depends, Request, Header
 from pydantic import BaseModel, EmailStr
 
@@ -32,8 +52,11 @@ from backend.models.user import (
 from backend.services.user_service import get_user_service, UserService, USERS_COLLECTION
 from backend.services.email_service import get_email_service, EmailService
 from backend.services.stripe_service import get_stripe_service, StripeService, CREDIT_PACKAGES
+from backend.services.theme_service import get_theme_service
 from backend.api.dependencies import require_admin
+from backend.api.routes.file_upload import _prepare_theme_for_job
 from backend.services.auth_service import UserType
+from backend.utils.test_data import is_test_email
 
 
 logger = logging.getLogger(__name__)
@@ -57,6 +80,16 @@ class CreateCheckoutResponse(BaseModel):
     message: str
 
 
+class MadeForYouCheckoutRequest(BaseModel):
+    """Request to create a made-for-you karaoke video order."""
+    email: EmailStr
+    artist: str
+    title: str
+    source_type: str = "search"  # search, youtube, or upload
+    youtube_url: Optional[str] = None
+    notes: Optional[str] = None
+
+
 class CreditPackage(BaseModel):
     """Credit package information."""
     id: str
@@ -99,7 +132,11 @@ async def send_magic_link(
 
     The user will receive an email with a link that logs them in.
     Links expire after 15 minutes and can only be used once.
+
+    For white-label tenants, validates email domain against tenant config.
     """
+    from backend.middleware.tenant import get_tenant_from_request, get_tenant_config_from_request
+
     # Check if email service is configured
     if not email_service.is_configured():
         logger.error("Email service not configured - cannot send magic links")
@@ -110,19 +147,39 @@ async def send_magic_link(
 
     email = request.email.lower()
 
+    # Get tenant context from middleware
+    tenant_id = get_tenant_from_request(http_request)
+    tenant_config = get_tenant_config_from_request(http_request)
+
+    # Validate email domain for tenant if configured
+    if tenant_config and tenant_config.auth.allowed_email_domains:
+        if not tenant_config.is_email_allowed(email):
+            logger.warning(f"Email domain not allowed for tenant {tenant_id}: {_mask_email(email)}")
+            # Return success anyway to prevent email enumeration
+            return SendMagicLinkResponse(
+                status="success",
+                message="If this email is registered, you will receive a sign-in link shortly."
+            )
+
     # Get client info for security logging
     ip_address = http_request.client.host if http_request.client else None
     user_agent = http_request.headers.get("user-agent")
 
-    # Create magic link token
+    # Create magic link token with tenant context
     magic_link = user_service.create_magic_link(
         email,
         ip_address=ip_address,
-        user_agent=user_agent
+        user_agent=user_agent,
+        tenant_id=tenant_id
     )
 
-    # Send email
-    sent = email_service.send_magic_link(email, magic_link.token)
+    # Get tenant-specific sender email
+    sender_email = None
+    if tenant_config:
+        sender_email = tenant_config.get_sender_email()
+
+    # Send email (with tenant-specific sender if configured)
+    sent = email_service.send_magic_link(email, magic_link.token, sender_email=sender_email)
 
     if not sent:
         logger.error(f"Failed to send magic link email to {email}")
@@ -146,18 +203,26 @@ async def verify_magic_link(
     Verify a magic link token and create a session.
 
     Returns a session token that should be stored and used for subsequent requests.
+    The session will be associated with the tenant from the magic link.
     """
+    # Reject empty tokens early to avoid invalid Firestore document paths
+    if not token or not token.strip():
+        raise HTTPException(status_code=401, detail="Invalid token")
+
     # Get client info
     ip_address = http_request.client.host if http_request.client else None
     user_agent = http_request.headers.get("user-agent")
 
     # Check if this is a first login BEFORE verification (which sets last_login_at)
     # We need to get the user's state before verify_magic_link updates it
+    # Also extract tenant_id from the magic link for session creation
     from backend.services.user_service import MAGIC_LINKS_COLLECTION
     magic_link_doc = user_service.db.collection(MAGIC_LINKS_COLLECTION).document(token).get()
     is_first_login = False
+    magic_link_tenant_id = None
     if magic_link_doc.exists:
         magic_link_data = magic_link_doc.to_dict()
+        magic_link_tenant_id = magic_link_data.get('tenant_id')
         pre_verify_user = user_service.get_user(magic_link_data.get('email', ''))
         if pre_verify_user:
             is_first_login = pre_verify_user.total_jobs_created == 0 and not pre_verify_user.last_login_at
@@ -168,18 +233,19 @@ async def verify_magic_link(
     if not success or not user:
         raise HTTPException(status_code=401, detail=message)
 
-    # Create session
+    # Create session with tenant context from the magic link
     session = user_service.create_session(
         user.email,
         ip_address=ip_address,
-        user_agent=user_agent
+        user_agent=user_agent,
+        tenant_id=magic_link_tenant_id
     )
 
     # Send welcome email to first-time users
     if is_first_login:
         email_service.send_welcome_email(user.email, user.credits)
 
-    # Return user info
+    # Return user info with tenant_id
     user_public = UserPublic(
         email=user.email,
         role=user.role,
@@ -187,6 +253,7 @@ async def verify_magic_link(
         display_name=user.display_name,
         total_jobs_created=user.total_jobs_created,
         total_jobs_completed=user.total_jobs_completed,
+        tenant_id=user.tenant_id,
     )
 
     return VerifyMagicLinkResponse(
@@ -327,10 +394,327 @@ async def create_checkout(
     )
 
 
+@router.post("/made-for-you/checkout", response_model=CreateCheckoutResponse)
+async def create_made_for_you_checkout(
+    request: MadeForYouCheckoutRequest,
+    stripe_service: StripeService = Depends(get_stripe_service),
+):
+    """
+    Create a Stripe checkout session for a made-for-you karaoke video order.
+
+    This is the full-service option where Nomad Karaoke handles everything:
+    - Finding or processing the audio
+    - Reviewing and correcting lyrics
+    - Selecting the best instrumental
+    - Generating the final video
+
+    $15 with 24-hour delivery guarantee.
+    No authentication required - customer email is provided in the request.
+    """
+    if not stripe_service.is_configured():
+        raise HTTPException(status_code=503, detail="Payment processing is not available")
+
+    success, checkout_url, message = stripe_service.create_made_for_you_checkout_session(
+        customer_email=request.email,
+        artist=request.artist,
+        title=request.title,
+        source_type=request.source_type,
+        youtube_url=request.youtube_url,
+        notes=request.notes,
+    )
+
+    if not success or not checkout_url:
+        raise HTTPException(status_code=400, detail=message)
+
+    return CreateCheckoutResponse(
+        status="success",
+        checkout_url=checkout_url,
+        message=message,
+    )
+
+
 # =============================================================================
 # Stripe Webhooks
 # =============================================================================
 
+# Admin email for made-for-you order notifications
+ADMIN_EMAIL = "madeforyou@nomadkaraoke.com"
+
+
+async def _handle_made_for_you_order(
+    session_id: str,
+    metadata: dict,
+    user_service: UserService,
+    email_service: EmailService,
+) -> None:
+    """
+    Handle a completed made-for-you order by creating a job and notifying Andrew.
+
+    The made-for-you flow:
+    1. Job is created with made_for_you=True, owned by admin during processing
+    2. For search orders: audio search runs, results stored, job pauses at AWAITING_AUDIO_SELECTION
+    3. Admin receives notification email with link to select audio source
+    4. Customer receives order confirmation email
+    5. Admin selects audio in UI, job proceeds through normal pipeline
+    6. On completion, ownership transfers to customer
+
+    For orders with a YouTube URL, workers are triggered immediately (no search needed).
+
+    Args:
+        session_id: Stripe checkout session ID
+        metadata: Order metadata from Stripe session
+        user_service: User service for marking session processed
+        email_service: Email service for notifications
+    """
+    from backend.models.job import JobCreate, JobStatus
+    from backend.services.job_manager import JobManager
+    from backend.services.worker_service import get_worker_service
+    from backend.services.audio_search_service import (
+        get_audio_search_service,
+        NoResultsError,
+        AudioSearchError,
+    )
+    from backend.services.storage_service import StorageService
+    from backend.config import get_settings
+    import asyncio
+    import tempfile
+    import os
+
+    customer_email = metadata.get("customer_email", "")
+    artist = metadata.get("artist", "Unknown Artist")
+    title = metadata.get("title", "Unknown Title")
+    source_type = metadata.get("source_type", "search")
+    youtube_url = metadata.get("youtube_url")
+    notes = metadata.get("notes", "")
+
+    logger.info(
+        f"Processing made-for-you order: {artist} - {title} for {customer_email} "
+        f"(session: {session_id}, source_type: {source_type})"
+    )
+
+    try:
+        job_manager = JobManager()
+        worker_service = get_worker_service()
+        storage_service = StorageService()
+        settings = get_settings()
+
+        # Apply default theme (Nomad) - same as audio_search endpoint
+        theme_service = get_theme_service()
+        effective_theme_id = theme_service.get_default_theme_id()
+        if effective_theme_id:
+            logger.info(f"Applying default theme '{effective_theme_id}' for made-for-you order")
+
+        # Get distribution defaults from settings (same as audio_search endpoint)
+        effective_dropbox_path = settings.default_dropbox_path
+        effective_gdrive_folder_id = settings.default_gdrive_folder_id
+        effective_enable_youtube_upload = settings.default_enable_youtube_upload
+        effective_brand_prefix = settings.default_brand_prefix
+        effective_discord_webhook_url = settings.default_discord_webhook_url
+        effective_youtube_description = settings.default_youtube_description
+
+        # Create job with admin ownership during processing
+        # CRITICAL: made_for_you=True, user_email=ADMIN_EMAIL, customer_email for delivery
+        # auto_download=False to pause at audio selection for admin to choose
+        job_create = JobCreate(
+            url=youtube_url if youtube_url else None,
+            artist=artist,
+            title=title,
+            user_email=ADMIN_EMAIL,  # Admin owns during processing
+            theme_id=effective_theme_id,  # Apply default theme
+            non_interactive=False,  # Admin will review lyrics/instrumental
+            # Made-for-you specific fields
+            made_for_you=True,  # Flag for ownership transfer on completion
+            customer_email=customer_email,  # Customer email for final delivery
+            customer_notes=notes if notes else None,  # Customer's special requests
+            # Audio search fields for search-based orders
+            audio_search_artist=artist if not youtube_url else None,
+            audio_search_title=title if not youtube_url else None,
+            auto_download=False,  # Pause at audio selection for admin to choose
+            # Distribution settings from server defaults
+            enable_youtube_upload=effective_enable_youtube_upload,
+            dropbox_path=effective_dropbox_path,
+            gdrive_folder_id=effective_gdrive_folder_id,
+            brand_prefix=effective_brand_prefix,
+            discord_webhook_url=effective_discord_webhook_url,
+            youtube_description=effective_youtube_description,
+        )
+        job = job_manager.create_job(job_create)
+        job_id = job.job_id
+
+        logger.info(f"Created made-for-you job {job_id} for {_mask_email(customer_email)} (owned by {_mask_email(ADMIN_EMAIL)})")
+
+        # Prepare theme style assets for the job (same as audio_search endpoint)
+        if effective_theme_id:
+            try:
+                style_params_path, theme_style_assets, youtube_desc = _prepare_theme_for_job(
+                    job_id, effective_theme_id, None  # No color overrides for made-for-you
+                )
+                theme_update = {
+                    'style_params_gcs_path': style_params_path,
+                    'style_assets': theme_style_assets,
+                }
+                if youtube_desc:
+                    theme_update['youtube_description_template'] = youtube_desc
+                job_manager.update_job(job_id, theme_update)
+                logger.info(f"Applied theme '{effective_theme_id}' to made-for-you job {job_id}")
+            except Exception as e:
+                logger.warning(f"Failed to prepare theme for made-for-you job {job_id}: {e}")
+
+        # Mark session as processed for idempotency
+        # Note: Using internal method since this isn't a credit transaction
+        user_service._mark_stripe_session_processed(
+            stripe_session_id=session_id,
+            email=customer_email,
+            amount=0  # No credits, just tracking the session
+        )
+
+        # Initialize search_results for later use in email notification
+        search_results = None
+
+        # Handle based on whether we have a YouTube URL or need to search
+        if youtube_url:
+            # URL provided - trigger workers directly (no audio selection needed)
+            logger.info(f"Job {job_id}: YouTube URL provided, triggering workers")
+            await asyncio.gather(
+                worker_service.trigger_audio_worker(job_id),
+                worker_service.trigger_lyrics_worker(job_id)
+            )
+        else:
+            # No URL - use audio search flow, pause for admin selection
+            # Made-for-you jobs require admin to select audio source
+            logger.info(f"Job {job_id}: No URL, using audio search for '{artist} - {title}'")
+
+            # Update job with audio search fields
+            job_manager.update_job(job_id, {
+                'audio_search_artist': artist,
+                'audio_search_title': title,
+                'auto_download': False,  # Admin must select
+            })
+
+            # Transition to searching state
+            job_manager.transition_to_state(
+                job_id=job_id,
+                new_status=JobStatus.SEARCHING_AUDIO,
+                progress=5,
+                message=f"Searching for audio: {artist} - {title}"
+            )
+
+            # Perform audio search
+            audio_search_service = get_audio_search_service()
+
+            try:
+                search_results = audio_search_service.search(artist, title)
+            except NoResultsError as e:
+                # No results found - still transition to AWAITING_AUDIO_SELECTION
+                # Admin can manually provide audio
+                logger.warning(f"Job {job_id}: No audio sources found for '{artist} - {title}'")
+                job_manager.transition_to_state(
+                    job_id=job_id,
+                    new_status=JobStatus.AWAITING_AUDIO_SELECTION,
+                    progress=10,
+                    message=f"No automatic audio sources found. Manual intervention required."
+                )
+                search_results = None
+            except AudioSearchError as e:
+                logger.error(f"Job {job_id}: Audio search failed: {e}")
+                job_manager.transition_to_state(
+                    job_id=job_id,
+                    new_status=JobStatus.AWAITING_AUDIO_SELECTION,
+                    progress=10,
+                    message=f"Audio search error. Manual intervention required."
+                )
+                search_results = None
+
+            if search_results:
+                # Store search results in state_data for admin to review
+                results_dicts = [r.to_dict() for r in search_results]
+                state_data_update = {
+                    'audio_search_results': results_dicts,
+                    'audio_search_count': len(results_dicts),
+                }
+                if audio_search_service.last_remote_search_id:
+                    state_data_update['remote_search_id'] = audio_search_service.last_remote_search_id
+                job_manager.update_job(job_id, {'state_data': state_data_update})
+
+                # Transition to AWAITING_AUDIO_SELECTION for admin to choose
+                # Do NOT auto-select or download - admin must review and select
+                logger.info(f"Job {job_id}: Found {len(results_dicts)} audio sources, awaiting admin selection")
+
+                # Transition to AWAITING_AUDIO_SELECTION for admin to choose
+                # Admin will select from results in the UI, then job proceeds
+                job_manager.transition_to_state(
+                    job_id=job_id,
+                    new_status=JobStatus.AWAITING_AUDIO_SELECTION,
+                    progress=10,
+                    message=f"Found {len(results_dicts)} audio sources. Awaiting admin selection."
+                )
+
+        # Get audio source count for admin notification
+        # (search_results may be set from the search flow above, or None for YouTube URL orders)
+        audio_source_count = len(search_results) if search_results else 0
+
+        # Generate admin login token for one-click email access (24hr expiry)
+        admin_login = user_service.create_admin_login_token(
+            email=ADMIN_EMAIL,
+            expiry_hours=24,
+        )
+
+        # Send confirmation email to customer using professional template
+        email_service.send_made_for_you_order_confirmation(
+            to_email=customer_email,
+            artist=artist,
+            title=title,
+            job_id=job_id,
+            notes=notes,
+        )
+
+        # Send notification email to admin using professional template
+        email_service.send_made_for_you_admin_notification(
+            to_email=ADMIN_EMAIL,
+            customer_email=customer_email,
+            artist=artist,
+            title=title,
+            job_id=job_id,
+            admin_login_token=admin_login.token,
+            notes=notes,
+            audio_source_count=audio_source_count,
+        )
+
+        logger.info(f"Sent made-for-you order notifications for job {job_id}")
+
+    except Exception as e:
+        logger.error(f"Error processing made-for-you order: {e}", exc_info=True)
+        # Still try to notify Andrew of the failure
+        try:
+            email_service.send_email(
+                to_email=ADMIN_EMAIL,
+                subject=f"[FAILED] Made For You Order: {artist} - {title}",
+                html_content=f"""
+                <h2>Made-For-You Order Failed</h2>
+                <p>An error occurred processing this order:</p>
+                <ul>
+                    <li><strong>Customer:</strong> {customer_email}</li>
+                    <li><strong>Artist:</strong> {artist}</li>
+                    <li><strong>Title:</strong> {title}</li>
+                    <li><strong>Error:</strong> {str(e)}</li>
+                </ul>
+                <p>Please manually create this job and notify the customer.</p>
+                """,
+                text_content=f"""
+Made-For-You Order Failed
+
+Customer: {customer_email}
+Artist: {artist}
+Title: {title}
+Error: {str(e)}
+
+Please manually create this job and notify the customer.
+                """.strip(),
+            )
+        except Exception as email_error:
+            logger.error(f"Failed to send error notification: {email_error}")
+
+
 @router.post("/webhooks/stripe")
 async def stripe_webhook(
     request: Request,
@@ -365,30 +749,41 @@ async def stripe_webhook(
     if event_type == "checkout.session.completed":
         session = event["data"]["object"]
         session_id = session.get("id")
+        metadata = session.get("metadata", {})
 
         # Idempotency check: Skip if this session was already processed
         if session_id and user_service.is_stripe_session_processed(session_id):
             logger.info(f"Skipping already processed session: {session_id}")
             return {"status": "received", "type": event_type, "note": "already_processed"}
 
-        # Process the completed checkout
-        success, user_email, credits, _ = stripe_service.handle_checkout_completed(session)
-
-        if success and user_email and credits > 0:
-            # Add credits to user account
-            ok, new_balance, credit_msg = user_service.add_credits(
-                email=user_email,
-                amount=credits,
-                reason="stripe_purchase",
-                stripe_session_id=session_id,
+        # Check if this is a made-for-you order
+        if metadata.get("order_type") == "made_for_you":
+            # Handle made-for-you order - create a job
+            await _handle_made_for_you_order(
+                session_id=session_id,
+                metadata=metadata,
+                user_service=user_service,
+                email_service=email_service,
             )
-
-            if ok:
-                # Send confirmation email
-                email_service.send_credits_added(user_email, credits, new_balance)
-                logger.info(f"Added {credits} credits to {user_email}, new balance: {new_balance}")
-            else:
-                logger.error(f"Failed to add credits: {credit_msg}")
+        else:
+            # Handle regular credit purchase
+            success, user_email, credits, _ = stripe_service.handle_checkout_completed(session)
+
+            if success and user_email and credits > 0:
+                # Add credits to user account
+                ok, new_balance, credit_msg = user_service.add_credits(
+                    email=user_email,
+                    amount=credits,
+                    reason="stripe_purchase",
+                    stripe_session_id=session_id,
+                )
+
+                if ok:
+                    # Send confirmation email
+                    email_service.send_credits_added(user_email, credits, new_balance)
+                    logger.info(f"Added {credits} credits to {user_email}, new balance: {new_balance}")
+                else:
+                    logger.error(f"Failed to add credits: {credit_msg}")
 
     elif event_type == "checkout.session.expired":
         logger.info(f"Checkout session expired: {event['data']['object'].get('id')}")
@@ -663,6 +1058,7 @@ async def list_users(
     sort_by: str = "created_at",
     sort_order: str = "desc",
     include_inactive: bool = False,
+    exclude_test: bool = True,
     auth_data: Tuple[str, UserType, int] = Depends(require_admin),
     user_service: UserService = Depends(get_user_service),
 ):
@@ -676,6 +1072,7 @@ async def list_users(
         sort_by: Field to sort by (created_at, last_login_at, credits, email)
         sort_order: Sort direction (asc, desc)
         include_inactive: Include disabled users
+        exclude_test: If True (default), exclude test users (e.g., @inbox.testmail.app)
     """
     from google.cloud import firestore
     from google.cloud.firestore_v1 import FieldFilter
@@ -704,9 +1101,14 @@ async def list_users(
     else:
         query = query.order_by("created_at", direction=direction)
 
-    # Get total count (without pagination) for has_more calculation
+    # Get all docs and filter in Python
     # Note: This is expensive for large datasets, consider caching
     all_docs = list(query.stream())
+
+    # Filter out test users if exclude_test is True
+    if exclude_test:
+        all_docs = [d for d in all_docs if not is_test_email(d.to_dict().get('email', ''))]
+
     total_count = len(all_docs)
 
     # Apply pagination manually (Firestore doesn't support offset well)
@@ -942,44 +1344,64 @@ async def list_beta_feedback(
 
 @router.get("/admin/beta/stats")
 async def get_beta_stats(
+    exclude_test: bool = True,
     auth_data: Tuple[str, UserType, int] = Depends(require_admin),
     user_service: UserService = Depends(get_user_service),
 ):
     """
     Get beta tester program statistics (admin only).
+
+    Args:
+        exclude_test: If True (default), exclude test users from beta stats
     """
     from google.cloud.firestore_v1 import FieldFilter
     from google.cloud.firestore_v1 import aggregation
 
-    # Count beta testers by status using efficient aggregation queries
     users_collection = user_service.db.collection(USERS_COLLECTION)
 
-    # Helper function to get count using aggregation
-    def get_count(query) -> int:
-        agg_query = aggregation.AggregationQuery(query)
-        agg_query.count(alias="count")
-        results = agg_query.get()
-        return results[0][0].value if results else 0
-
-    total_beta_testers = get_count(
-        users_collection.where(filter=FieldFilter("is_beta_tester", "==", True))
-    )
-
-    active_testers = get_count(
-        users_collection.where(filter=FieldFilter("beta_tester_status", "==", "active"))
-    )
-
-    pending_feedback = get_count(
-        users_collection.where(filter=FieldFilter("beta_tester_status", "==", "pending_feedback"))
-    )
+    if exclude_test:
+        # Stream and filter in Python since Firestore doesn't support "not ends with"
+        all_beta_users = []
+        for doc in users_collection.where(filter=FieldFilter("is_beta_tester", "==", True)).stream():
+            data = doc.to_dict()
+            if not is_test_email(data.get("email", "")):
+                all_beta_users.append(data)
 
-    completed_feedback = get_count(
-        users_collection.where(filter=FieldFilter("beta_tester_status", "==", "completed"))
-    )
+        total_beta_testers = len(all_beta_users)
+        active_testers = sum(1 for u in all_beta_users if u.get("beta_tester_status") == "active")
+        pending_feedback = sum(1 for u in all_beta_users if u.get("beta_tester_status") == "pending_feedback")
+        completed_feedback = sum(1 for u in all_beta_users if u.get("beta_tester_status") == "completed")
 
-    # Get average ratings from feedback
-    feedback_docs = list(user_service.db.collection("beta_feedback").stream())
+        # Filter feedback by non-test users
+        all_feedback = []
+        for doc in user_service.db.collection("beta_feedback").stream():
+            data = doc.to_dict()
+            if not is_test_email(data.get("user_email", "")):
+                all_feedback.append(data)
+        feedback_docs = all_feedback
+    else:
+        # Use efficient aggregation queries when including test data
+        def get_count(query) -> int:
+            agg_query = aggregation.AggregationQuery(query)
+            agg_query.count(alias="count")
+            results = agg_query.get()
+            return results[0][0].value if results else 0
+
+        total_beta_testers = get_count(
+            users_collection.where(filter=FieldFilter("is_beta_tester", "==", True))
+        )
+        active_testers = get_count(
+            users_collection.where(filter=FieldFilter("beta_tester_status", "==", "active"))
+        )
+        pending_feedback = get_count(
+            users_collection.where(filter=FieldFilter("beta_tester_status", "==", "pending_feedback"))
+        )
+        completed_feedback = get_count(
+            users_collection.where(filter=FieldFilter("beta_tester_status", "==", "completed"))
+        )
+        feedback_docs = [doc.to_dict() for doc in user_service.db.collection("beta_feedback").stream()]
 
+    # Calculate average ratings from feedback
     avg_overall = 0
     avg_ease = 0
     avg_accuracy = 0
@@ -987,8 +1409,7 @@ async def get_beta_stats(
 
     if feedback_docs:
         total = len(feedback_docs)
-        for doc in feedback_docs:
-            data = doc.to_dict()
+        for data in feedback_docs:
             avg_overall += data.get("overall_rating", 0)
             avg_ease += data.get("ease_of_use_rating", 0)
             avg_accuracy += data.get("lyrics_accuracy_rating", 0)