Update app.py

app.py

@@ -23,10 +23,17 @@ logger = logging.getLogger(__name__)
 # Initialize FastAPI app
 app = FastAPI(title="Kling AI Multi-Image Generator API with Razorpay")
 
-# Enable CORS for the frontend
+# Enable CORS for the frontend - Updated for Lovable domains
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["https://hivili.web.app", "https://your-lovable-app.lovable.dev", "http://localhost:3000"],  # Add your Lovable.dev URL
+    allow_origins=[
+        "https://hivili.web.app", 
+        "http://localhost:3000",
+        "https://*.lovable.dev",
+        "https://*.sandbox.lovable.dev",
+        # Add pattern matching for Lovable subdomains
+    ],
+    allow_origin_regex=r"https://.*\.lovable\.dev|https://.*\.sandbox\.lovable\.dev",
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
@@ -147,6 +154,7 @@ def create_razorpay_order(amount: int):
             "payment_capture": 1  # Auto-capture payment
         }
         order = razorpay_client.order.create(data=order_data)
+        logger.info(f"Razorpay order created successfully: {order['id']}")
         return order
     except Exception as e:
         logger.error(f"Failed to create Razorpay order: {str(e)}")
@@ -161,6 +169,7 @@ def verify_payment_signature(order_id: str, payment_id: str, signature: str):
             "razorpay_signature": signature
         }
         razorpay_client.utility.verify_payment_signature(params_dict)
+        logger.info(f"Payment signature verified successfully for order: {order_id}")
         return True
     except SignatureVerificationError as e:
         logger.error(f"Payment signature verification failed: {str(e)}")
@@ -235,36 +244,54 @@ async def generate_image_endpoint(
         raise HTTPException(status_code=500, detail=str(e))
 
 @app.post("/create-razorpay-order")
-async def create_razorpay_order(
+async def create_order_endpoint(
     request: Request,
     amount: Optional[int] = Form(None),
     body: Optional[CreateOrderRequest] = None
 ):
     """Create a Razorpay order (supports form-data and JSON)"""
+    logger.info("Received create order request")
+    
     if not RAZORPAY_KEY_ID or not RAZORPAY_KEY_SECRET:
+        logger.error("Razorpay configuration missing")
         raise HTTPException(status_code=500, detail="Razorpay configuration missing")
     
     # Handle JSON body if provided
-    if body and body.amount:
-        amount = body.amount
-    elif not amount:
-        raise HTTPException(status_code=422, detail="Missing or invalid 'amount' parameter")
-
     try:
+        if body and body.amount:
+            amount = body.amount
+        elif not amount:
+            # Try to parse JSON from request body
+            try:
+                json_body = await request.json()
+                amount = json_body.get('amount')
+            except:
+                pass
+                
+        if not amount or amount <= 0:
+            raise HTTPException(status_code=422, detail="Missing or invalid 'amount' parameter")
+
         logger.info(f"Creating order with amount: {amount}")
         order = create_razorpay_order(amount)
-        return JSONResponse(content={
+        
+        response_data = {
             "id": order["id"],
             "amount": order["amount"],
             "currency": order["currency"],
             "key_id": RAZORPAY_KEY_ID
-        })
+        }
+        
+        logger.info(f"Order created successfully: {order['id']}")
+        return JSONResponse(content=response_data)
+        
+    except HTTPException:
+        raise
     except Exception as e:
         logger.error(f"Error creating order: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Failed to create order: {str(e)}")
 
 @app.post("/verify-razorpay-payment")
-async def verify_razorpay_payment(
+async def verify_payment_endpoint(
     request: Request,
     razorpay_order_id: Optional[str] = Form(None),
     razorpay_payment_id: Optional[str] = Form(None),
@@ -273,34 +300,81 @@ async def verify_razorpay_payment(
     body: Optional[VerifyPaymentRequest] = None
 ):
     """Verify Razorpay payment signature (supports form-data and JSON)"""
-    # Handle JSON body if provided
-    if body:
-        razorpay_order_id = razorpay_order_id or body.razorpay_order_id
-        razorpay_payment_id = razorpay_payment_id or body.razorpay_payment_id
-        razorpay_signature = razorpay_signature or body.razorpay_signature
-        user_id = user_id or body.user_id
+    logger.info("Received payment verification request")
+    
+    try:
+        # Handle JSON body if provided
+        if body:
+            razorpay_order_id = razorpay_order_id or body.razorpay_order_id
+            razorpay_payment_id = razorpay_payment_id or body.razorpay_payment_id
+            razorpay_signature = razorpay_signature or body.razorpay_signature
+            user_id = user_id or body.user_id
+        else:
+            # Try to parse JSON from request body
+            try:
+                json_body = await request.json()
+                razorpay_order_id = razorpay_order_id or json_body.get('razorpay_order_id')
+                razorpay_payment_id = razorpay_payment_id or json_body.get('razorpay_payment_id')
+                razorpay_signature = razorpay_signature or json_body.get('razorpay_signature')
+                user_id = user_id or json_body.get('user_id')
+            except:
+                pass
 
-    # Validate required fields
-    if not all([razorpay_order_id, razorpay_payment_id, razorpay_signature]):
-        raise HTTPException(status_code=422, detail="Missing required fields: razorpay_order_id, razorpay_payment_id, or razorpay_signature")
+        # Validate required fields
+        if not all([razorpay_order_id, razorpay_payment_id, razorpay_signature]):
+            missing_fields = []
+            if not razorpay_order_id: missing_fields.append("razorpay_order_id")
+            if not razorpay_payment_id: missing_fields.append("razorpay_payment_id")
+            if not razorpay_signature: missing_fields.append("razorpay_signature")
+            
+            logger.error(f"Missing required fields: {missing_fields}")
+            raise HTTPException(
+                status_code=422, 
+                detail=f"Missing required fields: {', '.join(missing_fields)}"
+            )
 
-    try:
         logger.info(f"Verifying payment for order_id: {razorpay_order_id}")
         is_valid = verify_payment_signature(razorpay_order_id, razorpay_payment_id, razorpay_signature)
+        
         if is_valid:
             if user_id and supabase:
                 logger.info(f"Updating Supabase for user_id: {user_id}")
-                supabase.table("users").update({"is_premium": True}).eq("user_id", user_id).execute()
-            return JSONResponse(content={"success": True})
+                try:
+                    supabase.table("users").update({"is_premium": True}).eq("user_id", user_id).execute()
+                    logger.info(f"Successfully updated premium status for user: {user_id}")
+                except Exception as e:
+                    logger.error(f"Failed to update Supabase: {str(e)}")
+                    # Don't fail the payment verification if Supabase update fails
+            
+            return JSONResponse(content={"success": True, "message": "Payment verified successfully"})
         else:
-            return JSONResponse(content={"success": False}, status_code=400)
+            logger.warning(f"Payment verification failed for order: {razorpay_order_id}")
+            return JSONResponse(content={"success": False, "message": "Payment verification failed"}, status_code=400)
+            
+    except HTTPException:
+        raise
     except Exception as e:
         logger.error(f"Error verifying payment: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Verification error: {str(e)}")
 
 @app.get("/")
 async def index():
-    return {"status": "Kling AI Multi-Image Generator API with Razorpay is running"}
+    return {
+        "status": "Kling AI Multi-Image Generator API with Razorpay is running",
+        "endpoints": {
+            "generate": "POST /generate",
+            "create_order": "POST /create-razorpay-order",
+            "verify_payment": "POST /verify-razorpay-payment"
+        }
+    }
+
+@app.get("/health")
+async def health_check():
+    return {
+        "status": "healthy",
+        "razorpay_configured": bool(RAZORPAY_KEY_ID and RAZORPAY_KEY_SECRET),
+        "supabase_configured": bool(SUPABASE_URL and SUPABASE_KEY)
+    }
 
 if __name__ == "__main__":
     import uvicorn