karaoke-gen 0.99.3__py3-none-any.whl → 0.103.1__py3-none-any.whl

backend/services/job_defaults_service.py

@@ -0,0 +1,113 @@
+"""
+Centralized job defaults service.
+
+This module provides consistent handling of job creation defaults across all
+endpoints (file_upload, audio_search, made-for-you webhook, etc.).
+
+Centralizing these defaults prevents divergence between code paths and ensures
+all jobs receive the same default configuration.
+"""
+from dataclasses import dataclass
+from typing import Optional, Tuple
+
+from backend.config import get_settings
+
+
+@dataclass
+class EffectiveDistributionSettings:
+    """Distribution settings with defaults applied from environment variables."""
+    dropbox_path: Optional[str]
+    gdrive_folder_id: Optional[str]
+    discord_webhook_url: Optional[str]
+    brand_prefix: Optional[str]
+    enable_youtube_upload: bool
+    youtube_description: Optional[str]
+
+
+def get_effective_distribution_settings(
+    dropbox_path: Optional[str] = None,
+    gdrive_folder_id: Optional[str] = None,
+    discord_webhook_url: Optional[str] = None,
+    brand_prefix: Optional[str] = None,
+    enable_youtube_upload: Optional[bool] = None,
+    youtube_description: Optional[str] = None,
+) -> EffectiveDistributionSettings:
+    """
+    Get distribution settings with defaults applied from environment variables.
+
+    This ensures consistent handling of defaults across all job creation endpoints.
+    Each parameter, if not provided (None), falls back to the corresponding
+    environment variable configured in settings.
+
+    Args:
+        dropbox_path: Explicit Dropbox path or None for default
+        gdrive_folder_id: Explicit Google Drive folder ID or None for default
+        discord_webhook_url: Explicit Discord webhook URL or None for default
+        brand_prefix: Explicit brand prefix or None for default
+        enable_youtube_upload: Explicit flag or None for default
+        youtube_description: Explicit description or None for default
+
+    Returns:
+        EffectiveDistributionSettings with defaults applied
+    """
+    settings = get_settings()
+    return EffectiveDistributionSettings(
+        dropbox_path=dropbox_path or settings.default_dropbox_path,
+        gdrive_folder_id=gdrive_folder_id or settings.default_gdrive_folder_id,
+        discord_webhook_url=discord_webhook_url or settings.default_discord_webhook_url,
+        brand_prefix=brand_prefix or settings.default_brand_prefix,
+        enable_youtube_upload=enable_youtube_upload if enable_youtube_upload is not None else settings.default_enable_youtube_upload,
+        youtube_description=youtube_description or settings.default_youtube_description,
+    )
+
+
+def resolve_cdg_txt_defaults(
+    theme_id: Optional[str],
+    enable_cdg: Optional[bool] = None,
+    enable_txt: Optional[bool] = None,
+) -> Tuple[bool, bool]:
+    """
+    Resolve CDG/TXT settings based on theme and explicit settings.
+
+    The resolution logic is:
+    1. If explicit True/False is provided, use that value
+    2. Otherwise, if a theme is set, use the server defaults (settings.default_enable_cdg/txt)
+    3. If no theme is set, default to False (CDG/TXT require style configuration)
+
+    This ensures CDG/TXT are only enabled when:
+    - A theme is configured (provides necessary style params), AND
+    - The server defaults allow it (DEFAULT_ENABLE_CDG=true by default)
+
+    Args:
+        theme_id: Theme identifier (if any)
+        enable_cdg: Explicit CDG setting (None means use default)
+        enable_txt: Explicit TXT setting (None means use default)
+
+    Returns:
+        Tuple of (resolved_enable_cdg, resolved_enable_txt)
+    """
+    settings = get_settings()
+
+    # Default based on whether theme is set AND server defaults
+    # Theme is required because CDG/TXT need style configuration
+    theme_is_set = theme_id is not None
+    default_cdg = theme_is_set and settings.default_enable_cdg
+    default_txt = theme_is_set and settings.default_enable_txt
+
+    # Explicit values override defaults, None uses computed default
+    resolved_cdg = enable_cdg if enable_cdg is not None else default_cdg
+    resolved_txt = enable_txt if enable_txt is not None else default_txt
+
+    return resolved_cdg, resolved_txt
+
+
+# Singleton instance (optional, for convenience)
+_service_instance = None
+
+
+def get_job_defaults_service():
+    """Get the job defaults service (module-level functions work fine, this is for consistency)."""
+    return {
+        'get_effective_distribution_settings': get_effective_distribution_settings,
+        'resolve_cdg_txt_defaults': resolve_cdg_txt_defaults,
+    }

backend/services/job_manager.py

@@ -14,6 +14,7 @@ from datetime import datetime
 from typing import Optional, Dict, Any, List
 
 from backend.config import settings
+from backend.exceptions import RateLimitExceededError
 from backend.models.job import Job, JobStatus, JobCreate, STATE_TRANSITIONS
 from backend.models.worker_log import WorkerLogEntry
 from backend.services.firestore_service import FirestoreService
@@ -23,6 +24,16 @@ from backend.services.storage_service import StorageService
 logger = logging.getLogger(__name__)
 
 
+def _mask_email(email: str) -> str:
+    """Mask email for logging to protect PII. Shows first char + domain."""
+    if not email or "@" not in email:
+        return "***"
+    local, domain = email.split("@", 1)
+    if len(local) <= 1:
+        return f"*@{domain}"
+    return f"{local[0]}***@{domain}"
+
+
 class JobManager:
     """Manager for job lifecycle and state."""
     
@@ -31,16 +42,44 @@ class JobManager:
         self.firestore = FirestoreService()
         self.storage = StorageService()
     
-    def create_job(self, job_create: JobCreate) -> Job:
+    def create_job(self, job_create: JobCreate, is_admin: bool = False) -> Job:
         """
         Create a new job with initial state PENDING.
 
         Jobs start in PENDING state and transition to DOWNLOADING
         when a worker picks them up.
 
+        Args:
+            job_create: Job creation parameters
+            is_admin: Whether the requesting user is an admin (bypasses rate limits)
+
         Raises:
             ValueError: If theme_id is not provided (all jobs require a theme)
+            RateLimitExceededError: If user has exceeded their daily job limit
         """
+        # Check rate limit FIRST (before any other validation)
+        # This prevents wasted work if user is rate limited
+        if job_create.user_email:
+            from backend.services.rate_limit_service import get_rate_limit_service
+
+            rate_limit_service = get_rate_limit_service()
+            allowed, remaining, message = rate_limit_service.check_user_job_limit(
+                user_email=job_create.user_email,
+                is_admin=is_admin
+            )
+            if not allowed:
+                from backend.services.rate_limit_service import _seconds_until_midnight_utc
+
+                # Get actual current count - remaining is clamped to 0 which loses info
+                current_count = rate_limit_service.get_user_job_count_today(job_create.user_email)
+                raise RateLimitExceededError(
+                    message=message,
+                    limit_type="jobs_per_day",
+                    remaining_seconds=_seconds_until_midnight_utc(),
+                    current_count=current_count,
+                    limit_value=settings.rate_limit_jobs_per_day
+                )
+
         # Enforce theme requirement - all jobs must have a theme
         # This prevents unstyled videos from ever being generated
         if not job_create.theme_id:
@@ -85,11 +124,27 @@ class JobManager:
             keep_brand_code=job_create.keep_brand_code,
             # Request metadata (for tracking and filtering)
             request_metadata=job_create.request_metadata,
+            # Tenant scoping
+            tenant_id=job_create.tenant_id,
+            # Made-for-you order fields
+            made_for_you=job_create.made_for_you,
+            customer_email=job_create.customer_email,
+            customer_notes=job_create.customer_notes,
         )
         
         self.firestore.create_job(job)
         logger.info(f"Created new job {job_id} with status PENDING")
-        
+
+        # Record job creation for rate limiting (after successful persistence)
+        if job_create.user_email:
+            try:
+                from backend.services.rate_limit_service import get_rate_limit_service
+                rate_limit_service = get_rate_limit_service()
+                rate_limit_service.record_job_creation(job_create.user_email, job_id)
+            except Exception as e:
+                # Don't fail job creation if rate limit recording fails
+                logger.warning(f"Failed to record job creation for rate limiting: {e}")
+
         return job
     
     def get_job(self, job_id: str) -> Optional[Job]:
@@ -125,6 +180,7 @@ class JobManager:
         created_after: Optional[datetime] = None,
         created_before: Optional[datetime] = None,
         user_email: Optional[str] = None,
+        tenant_id: Optional[str] = None,
         limit: int = 100
     ) -> List[Job]:
         """
@@ -137,6 +193,7 @@ class JobManager:
             created_after: Filter jobs created after this datetime
             created_before: Filter jobs created before this datetime
             user_email: Filter by user_email (job owner)
+            tenant_id: Filter by tenant_id (white-label portal scoping)
             limit: Maximum number of jobs to return
 
         Returns:
@@ -149,6 +206,7 @@ class JobManager:
             created_after=created_after,
             created_before=created_before,
             user_email=user_email,
+            tenant_id=tenant_id,
             limit=limit
         )
     
@@ -413,6 +471,7 @@ class JobManager:
         """
         Schedule sending a job completion email.
 
+        For made-for-you orders, also transfers ownership from admin to customer.
         Uses asyncio to fire-and-forget the email sending.
         """
         import asyncio
@@ -429,11 +488,22 @@ class JobManager:
             dropbox_url = state_data.get('dropbox_link')
             brand_code = state_data.get('brand_code')
 
+            # For made-for-you orders, send to customer and transfer ownership
+            recipient_email = job.user_email
+            if job.made_for_you and job.customer_email:
+                recipient_email = job.customer_email
+                # Transfer ownership from admin to customer (non-blocking - email still goes out if this fails)
+                try:
+                    self.update_job(job.job_id, {'user_email': job.customer_email})
+                    logger.info(f"Transferred ownership of made-for-you job {job.job_id} to {_mask_email(job.customer_email)}")
+                except Exception as e:
+                    logger.error(f"Failed to transfer ownership for job {job.job_id}: {e}")
+
             # Create async task (fire-and-forget)
             async def send_email():
                 await notification_service.send_job_completion_email(
                     job_id=job.job_id,
-                    user_email=job.user_email,
+                    user_email=recipient_email,
                     user_name=None,  # Could fetch from user service if needed
                     artist=job.artist,
                     title=job.title,