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

backend/services/rclone_service.py

@@ -0,0 +1,106 @@
+"""
+Rclone configuration service for cloud storage integration.
+
+This service manages the rclone configuration needed for Dropbox
+and other cloud storage uploads from the backend workers.
+"""
+import logging
+import os
+import tempfile
+from typing import Optional
+
+from backend.config import get_settings
+
+logger = logging.getLogger(__name__)
+
+
+class RcloneService:
+    """Service for managing rclone configuration."""
+    
+    # Secret Manager secret name for rclone config
+    RCLONE_CONFIG_SECRET = "rclone-config"
+    
+    def __init__(self):
+        self.settings = get_settings()
+        self._config_file: Optional[str] = None
+        self._config_loaded = False
+    
+    def setup_rclone_config(self) -> bool:
+        """
+        Load rclone config from Secret Manager and set up environment.
+        
+        Writes the config to a temp file and sets RCLONE_CONFIG env var.
+        
+        Returns:
+            True if successful, False otherwise
+        """
+        if self._config_loaded:
+            logger.debug("Rclone config already loaded")
+            return True
+        
+        try:
+            # Get rclone config from Secret Manager
+            config_content = self.settings.get_secret(self.RCLONE_CONFIG_SECRET)
+            
+            if not config_content:
+                logger.warning("Rclone config not found in Secret Manager")
+                return False
+            
+            # Write to a temp file
+            fd, config_path = tempfile.mkstemp(prefix="rclone_", suffix=".conf")
+            try:
+                with os.fdopen(fd, 'w') as f:
+                    f.write(config_content)
+                
+                self._config_file = config_path
+                
+                # Set environment variable for rclone to find the config
+                os.environ["RCLONE_CONFIG"] = config_path
+                
+                logger.info(f"Rclone config loaded and written to {config_path}")
+                self._config_loaded = True
+                return True
+                
+            except Exception:
+                # Clean up the temp file on error
+                # Note: os.fdopen() takes ownership of fd, so it's already closed
+                # We only need to remove the temp file if it exists
+                if os.path.exists(config_path):
+                    os.unlink(config_path)
+                raise
+                
+        except Exception as e:
+            logger.error(f"Failed to setup rclone config: {e}")
+            return False
+    
+    def cleanup(self) -> None:
+        """Remove the temporary config file."""
+        if self._config_file and os.path.exists(self._config_file):
+            try:
+                os.unlink(self._config_file)
+                logger.debug(f"Cleaned up rclone config file: {self._config_file}")
+            except Exception as e:
+                logger.warning(f"Failed to cleanup rclone config: {e}")
+        
+        # Always reset internal state and environment, even if the file was missing
+        if self._config_file is not None:
+            os.environ.pop("RCLONE_CONFIG", None)
+        self._config_file = None
+        self._config_loaded = False
+    
+    @property
+    def is_configured(self) -> bool:
+        """Check if rclone is configured and ready to use."""
+        return self._config_loaded and self._config_file is not None
+
+
+# Singleton instance
+_rclone_service: Optional[RcloneService] = None
+
+
+def get_rclone_service() -> RcloneService:
+    """Get the singleton rclone service instance."""
+    global _rclone_service
+    if _rclone_service is None:
+        _rclone_service = RcloneService()
+    return _rclone_service

backend/services/storage_service.py

@@ -0,0 +1,209 @@
+"""
+Google Cloud Storage operations for file management.
+"""
+import logging
+import os
+import json
+from typing import Optional, BinaryIO, Any, Dict
+from pathlib import Path
+from google.cloud import storage
+from datetime import timedelta
+
+from backend.config import settings
+
+
+logger = logging.getLogger(__name__)
+
+
+class StorageService:
+    """Service for Google Cloud Storage operations."""
+    
+    def __init__(self):
+        """Initialize GCS client."""
+        self.client = storage.Client(project=settings.google_cloud_project)
+        self.bucket = self.client.bucket(settings.gcs_bucket_name)
+    
+    def upload_file(self, local_path: str, destination_path: str) -> str:
+        """Upload a file to GCS."""
+        try:
+            blob = self.bucket.blob(destination_path)
+            blob.upload_from_filename(local_path)
+            logger.info(f"Uploaded {local_path} to gs://{settings.gcs_bucket_name}/{destination_path}")
+            return destination_path
+        except Exception as e:
+            logger.error(f"Error uploading file {local_path}: {e}")
+            raise
+    
+    def upload_fileobj(self, file_obj: BinaryIO, destination_path: str, content_type: Optional[str] = None) -> str:
+        """Upload a file object to GCS."""
+        try:
+            blob = self.bucket.blob(destination_path)
+            if content_type:
+                blob.content_type = content_type
+            blob.upload_from_file(file_obj, rewind=True)
+            logger.info(f"Uploaded file object to gs://{settings.gcs_bucket_name}/{destination_path}")
+            return destination_path
+        except Exception as e:
+            logger.error(f"Error uploading file object: {e}")
+            raise
+    
+    def download_file(self, source_path: str, destination_path: str) -> str:
+        """Download a file from GCS."""
+        try:
+            blob = self.bucket.blob(source_path)
+            blob.download_to_filename(destination_path)
+            logger.info(f"Downloaded gs://{settings.gcs_bucket_name}/{source_path} to {destination_path}")
+            return destination_path
+        except Exception as e:
+            logger.error(f"Error downloading file {source_path}: {e}")
+            raise
+    
+    def generate_signed_url(self, blob_path: str, expiration_minutes: int = 60) -> str:
+        """Generate a signed URL for downloading a file.
+        
+        In Cloud Run, this uses the IAM signBlob API since we don't have
+        a private key available. Requires the service account to have
+        roles/iam.serviceAccountTokenCreator on itself.
+        """
+        return self._generate_signed_url_internal(blob_path, "GET", expiration_minutes)
+    
+    def generate_signed_upload_url(self, blob_path: str, content_type: str = "application/octet-stream", expiration_minutes: int = 60) -> str:
+        """Generate a signed URL for uploading a file directly to GCS.
+        
+        This allows clients to upload files directly to GCS without going through
+        the backend, bypassing any request body size limits.
+        
+        Args:
+            blob_path: The destination path in GCS
+            content_type: The expected content type of the upload
+            expiration_minutes: How long the URL is valid for
+            
+        Returns:
+            A signed URL that accepts PUT requests with the file content
+        """
+        return self._generate_signed_url_internal(blob_path, "PUT", expiration_minutes, content_type)
+    
+    def _generate_signed_url_internal(self, blob_path: str, method: str, expiration_minutes: int = 60, content_type: Optional[str] = None) -> str:
+        """Internal method to generate signed URLs for GET or PUT operations."""
+        import google.auth
+        from google.auth.transport import requests
+        
+        try:
+            blob = self.bucket.blob(blob_path)
+            
+            # Get default credentials and refresh to ensure we have a valid token
+            credentials, project = google.auth.default()
+            
+            # Common kwargs for signed URL generation
+            kwargs = {
+                "version": "v4",
+                "expiration": timedelta(minutes=expiration_minutes),
+                "method": method,
+            }
+            
+            # For PUT requests, we need to specify the content type in headers
+            if method == "PUT" and content_type:
+                kwargs["headers"] = {"Content-Type": content_type}
+            
+            # Check if we're using compute credentials (Cloud Run/GCE)
+            # These need to use IAM signBlob via service_account_email + access_token
+            if hasattr(credentials, 'service_account_email'):
+                # Refresh credentials to get a valid access token
+                auth_request = requests.Request()
+                credentials.refresh(auth_request)
+                
+                kwargs["service_account_email"] = credentials.service_account_email
+                kwargs["access_token"] = credentials.token
+            
+            url = blob.generate_signed_url(**kwargs)
+            
+            logger.info(f"Generated signed {method} URL for {blob_path}")
+            return url
+        except Exception as e:
+            logger.error(f"Error generating signed {method} URL for {blob_path}: {e}")
+            raise
+    
+    def delete_file(self, blob_path: str) -> None:
+        """Delete a file from GCS."""
+        try:
+            blob = self.bucket.blob(blob_path)
+            blob.delete()
+            logger.info(f"Deleted gs://{settings.gcs_bucket_name}/{blob_path}")
+        except Exception as e:
+            logger.error(f"Error deleting file {blob_path}: {e}")
+            raise
+    
+    def delete_folder(self, prefix: str) -> int:
+        """
+        Delete all files in GCS with a given prefix (folder).
+        
+        Args:
+            prefix: The folder prefix to delete (e.g., "uploads/abc123/")
+            
+        Returns:
+            Number of files deleted
+        """
+        try:
+            blobs = list(self.bucket.list_blobs(prefix=prefix))
+            deleted_count = 0
+            
+            for blob in blobs:
+                try:
+                    blob.delete()
+                    deleted_count += 1
+                except Exception as e:
+                    logger.warning(f"Error deleting blob {blob.name}: {e}")
+            
+            if deleted_count > 0:
+                logger.info(f"Deleted {deleted_count} files from gs://{settings.gcs_bucket_name}/{prefix}")
+            
+            return deleted_count
+        except Exception as e:
+            logger.error(f"Error deleting folder {prefix}: {e}")
+            return 0  # Don't raise - folder deletion shouldn't break operations
+    
+    def list_files(self, prefix: str) -> list:
+        """List files in GCS with a given prefix."""
+        try:
+            blobs = self.bucket.list_blobs(prefix=prefix)
+            return [blob.name for blob in blobs]
+        except Exception as e:
+            logger.error(f"Error listing files with prefix {prefix}: {e}")
+            raise
+    
+    def file_exists(self, blob_path: str) -> bool:
+        """Check if a file exists in GCS."""
+        try:
+            blob = self.bucket.blob(blob_path)
+            return blob.exists()
+        except Exception as e:
+            logger.error(f"Error checking file existence {blob_path}: {e}")
+            raise
+    
+    def upload_json(self, destination_path: str, data: Dict[str, Any]) -> str:
+        """Upload a JSON object to GCS."""
+        try:
+            blob = self.bucket.blob(destination_path)
+            blob.content_type = "application/json"
+            blob.upload_from_string(
+                json.dumps(data, indent=2, ensure_ascii=False),
+                content_type="application/json"
+            )
+            logger.info(f"Uploaded JSON to gs://{settings.gcs_bucket_name}/{destination_path}")
+            return destination_path
+        except Exception as e:
+            logger.error(f"Error uploading JSON to {destination_path}: {e}")
+            raise
+    
+    def download_json(self, source_path: str) -> Dict[str, Any]:
+        """Download and parse a JSON file from GCS."""
+        try:
+            blob = self.bucket.blob(source_path)
+            content = blob.download_as_text()
+            data = json.loads(content)
+            logger.info(f"Downloaded JSON from gs://{settings.gcs_bucket_name}/{source_path}")
+            return data
+        except Exception as e:
+            logger.error(f"Error downloading JSON from {source_path}: {e}")
+            raise
+

backend/services/stripe_service.py

@@ -0,0 +1,275 @@
+"""
+Stripe service for payment processing.
+
+Handles:
+- Creating checkout sessions for credit purchases
+- Processing webhook events
+- Managing customer records
+"""
+import logging
+import os
+from typing import Optional, Dict, Any, Tuple
+
+import stripe
+
+from backend.config import get_settings
+
+
+logger = logging.getLogger(__name__)
+
+
+# Credit packages available for purchase
+CREDIT_PACKAGES = {
+    "1_credit": {
+        "credits": 1,
+        "price_cents": 500,  # $5.00
+        "name": "1 Karaoke Credit",
+        "description": "Create 1 professional karaoke video",
+    },
+    "3_credits": {
+        "credits": 3,
+        "price_cents": 1200,  # $12.00 (20% discount)
+        "name": "3 Karaoke Credits",
+        "description": "Create 3 professional karaoke videos (Save 20%)",
+    },
+    "5_credits": {
+        "credits": 5,
+        "price_cents": 1750,  # $17.50 (30% discount)
+        "name": "5 Karaoke Credits",
+        "description": "Create 5 professional karaoke videos (Save 30%)",
+    },
+    "10_credits": {
+        "credits": 10,
+        "price_cents": 3000,  # $30.00 (40% discount)
+        "name": "10 Karaoke Credits",
+        "description": "Create 10 professional karaoke videos (Save 40%)",
+    },
+}
+
+
+class StripeService:
+    """Service for Stripe payment processing."""
+
+    def __init__(self):
+        """Initialize Stripe with API key."""
+        self.settings = get_settings()
+        self.secret_key = os.getenv("STRIPE_SECRET_KEY")
+        self.webhook_secret = os.getenv("STRIPE_WEBHOOK_SECRET")
+        self.frontend_url = os.getenv("FRONTEND_URL", "https://gen.nomadkaraoke.com")
+        # After consolidation, buy URL is the same as frontend URL
+        self.buy_url = os.getenv("BUY_URL", self.frontend_url)
+
+        if self.secret_key:
+            stripe.api_key = self.secret_key
+            logger.info("Stripe initialized with API key")
+        else:
+            logger.warning("STRIPE_SECRET_KEY not set - payments disabled")
+
+    def is_configured(self) -> bool:
+        """Check if Stripe is properly configured."""
+        return bool(self.secret_key)
+
+    def get_credit_packages(self) -> Dict[str, Dict[str, Any]]:
+        """Get available credit packages."""
+        return CREDIT_PACKAGES
+
+    def create_checkout_session(
+        self,
+        package_id: str,
+        user_email: str,
+        success_url: Optional[str] = None,
+        cancel_url: Optional[str] = None,
+    ) -> Tuple[bool, Optional[str], str]:
+        """
+        Create a Stripe Checkout session for purchasing credits.
+
+        Args:
+            package_id: ID of the credit package to purchase
+            user_email: Email of the purchasing user
+            success_url: URL to redirect to on success (optional)
+            cancel_url: URL to redirect to on cancel (optional)
+
+        Returns:
+            (success, checkout_url, message)
+        """
+        if not self.is_configured():
+            return False, None, "Payment processing is not configured"
+
+        package = CREDIT_PACKAGES.get(package_id)
+        if not package:
+            return False, None, f"Invalid package: {package_id}"
+
+        try:
+            # Default URLs
+            if not success_url:
+                success_url = f"{self.frontend_url}/payment/success?session_id={{CHECKOUT_SESSION_ID}}"
+            if not cancel_url:
+                cancel_url = f"{self.buy_url}?cancelled=true"
+
+            # Create checkout session
+            session = stripe.checkout.Session.create(
+                payment_method_types=['card'],
+                line_items=[{
+                    'price_data': {
+                        'currency': 'usd',
+                        'product_data': {
+                            'name': package['name'],
+                            'description': package['description'],
+                        },
+                        'unit_amount': package['price_cents'],
+                    },
+                    'quantity': 1,
+                }],
+                mode='payment',
+                success_url=success_url,
+                cancel_url=cancel_url,
+                customer_email=user_email,
+                metadata={
+                    'package_id': package_id,
+                    'credits': str(package['credits']),
+                    'user_email': user_email,
+                },
+                # Allow promotion codes
+                allow_promotion_codes=True,
+            )
+
+            logger.info(f"Created checkout session {session.id} for {user_email}, package {package_id}")
+            return True, session.url, "Checkout session created"
+
+        except stripe.error.StripeError as e:
+            logger.error(f"Stripe error creating checkout session: {e}")
+            return False, None, f"Payment error: {str(e)}"
+        except Exception as e:
+            logger.error(f"Error creating checkout session: {e}")
+            return False, None, "Failed to create checkout session"
+
+    def verify_webhook_signature(self, payload: bytes, signature: str) -> Tuple[bool, Optional[Dict], str]:
+        """
+        Verify a Stripe webhook signature.
+
+        Args:
+            payload: Raw request body
+            signature: Stripe-Signature header value
+
+        Returns:
+            (valid, event_data, message)
+        """
+        if not self.webhook_secret:
+            logger.error("STRIPE_WEBHOOK_SECRET not configured")
+            return False, None, "Webhook secret not configured"
+
+        try:
+            event = stripe.Webhook.construct_event(
+                payload, signature, self.webhook_secret
+            )
+            return True, event, "Webhook verified"
+        except stripe.error.SignatureVerificationError as e:
+            logger.error(f"Invalid webhook signature: {e}")
+            return False, None, "Invalid signature"
+        except Exception as e:
+            logger.error(f"Error verifying webhook: {e}")
+            return False, None, str(e)
+
+    def handle_checkout_completed(self, session: Dict) -> Tuple[bool, Optional[str], int, str]:
+        """
+        Handle a completed checkout session.
+
+        Args:
+            session: Stripe checkout session object
+
+        Returns:
+            (success, user_email, credits_to_add, message)
+        """
+        try:
+            metadata = session.get('metadata', {})
+            user_email = metadata.get('user_email') or session.get('customer_email')
+            try:
+                credits = int(metadata.get('credits', 0))
+            except (ValueError, TypeError):
+                logger.error(f"Invalid credits metadata in session {session.get('id')}: {metadata.get('credits')}")
+                return False, user_email, 0, "Invalid credit amount in session metadata"
+            package_id = metadata.get('package_id')
+
+            if not user_email:
+                logger.error(f"No user email in checkout session {session.get('id')}")
+                return False, None, 0, "No user email found"
+
+            if credits <= 0:
+                logger.error(f"Invalid credits in checkout session {session.get('id')}")
+                return False, user_email, 0, "Invalid credit amount"
+
+            logger.info(
+                f"Checkout completed: {user_email} purchased {credits} credits "
+                f"(package: {package_id}, session: {session.get('id')})"
+            )
+
+            return True, user_email, credits, f"Successfully purchased {credits} credits"
+
+        except Exception as e:
+            logger.error(f"Error handling checkout completed: {e}")
+            return False, None, 0, str(e)
+
+    def get_session(self, session_id: str) -> Optional[Dict]:
+        """
+        Get a checkout session by ID.
+
+        Args:
+            session_id: Stripe checkout session ID
+
+        Returns:
+            Session data or None
+        """
+        if not self.is_configured():
+            return None
+
+        try:
+            session = stripe.checkout.Session.retrieve(session_id)
+            return dict(session)
+        except Exception as e:
+            logger.error(f"Error retrieving session {session_id}: {e}")
+            return None
+
+    def create_customer(self, email: str, name: Optional[str] = None) -> Optional[str]:
+        """
+        Create or get a Stripe customer for a user.
+
+        Args:
+            email: User's email
+            name: User's display name (optional)
+
+        Returns:
+            Stripe customer ID or None
+        """
+        if not self.is_configured():
+            return None
+
+        try:
+            # Check if customer already exists
+            customers = stripe.Customer.list(email=email, limit=1)
+            if customers.data:
+                return customers.data[0].id
+
+            # Create new customer
+            customer = stripe.Customer.create(
+                email=email,
+                name=name,
+                metadata={'source': 'nomad_karaoke'},
+            )
+            logger.info(f"Created Stripe customer {customer.id} for {email}")
+            return customer.id
+
+        except Exception as e:
+            logger.error(f"Error creating Stripe customer: {e}")
+            return None
+
+
+# Global instance
+_stripe_service = None
+
+
+def get_stripe_service() -> StripeService:
+    """Get the global Stripe service instance."""
+    global _stripe_service
+    if _stripe_service is None:
+        _stripe_service = StripeService()
+    return _stripe_service