import logging from fastapi import FastAPI, UploadFile, File, HTTPException, Form, Request from fastapi.middleware.cors import CORSMiddleware from fastapi.responses import FileResponse, JSONResponse import requests import base64 import os from pathlib import Path from typing import List import io from PIL import Image import razorpay from razorpay.errors import SignatureVerificationError from supabase import create_client, Client from pydantic import BaseModel from typing import Optional # Configure logging logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) # Initialize FastAPI app app = FastAPI(title="Gemini 2.5 Flash Image Generator API with Razorpay") # Enable CORS for the frontend app.add_middleware( CORSMiddleware, allow_origins=[ "https://hivili.web.app", "http://localhost:3000", "https://*.lovable.dev", "https://*.sandbox.lovable.dev", ], allow_origin_regex=r"https://.*\.lovable\.dev|https://.*\.sandbox\.lovable\.dev", allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) # ===== API CONFIGURATION ===== GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "AIzaSyDL5Rilo7ptJpUOZdY6wy8PJYUcVcnDADs") API_BASE_URL = "https://generativelanguage.googleapis.com" CREATE_TASK_ENDPOINT = f"{API_BASE_URL}/v1beta/models/gemini-2.5-flash-image-preview:generateContent?key={GEMINI_API_KEY}" # ===== RAZORPAY CONFIGURATION ===== RAZORPAY_KEY_ID = os.getenv("RAZORPAY_KEY_ID") RAZORPAY_KEY_SECRET = os.getenv("RAZORPAY_KEY_SECRET") razorpay_client = razorpay.Client(auth=(RAZORPAY_KEY_ID, RAZORPAY_KEY_SECRET)) # ===== SUPABASE CONFIGURATION ===== SUPABASE_URL = os.getenv("SUPABASE_URL") SUPABASE_KEY = os.getenv("SUPABASE_KEY") supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY) if SUPABASE_URL and SUPABASE_KEY else None # Pydantic models for JSON input validation class CreateOrderRequest(BaseModel): amount: int class VerifyPaymentRequest(BaseModel): razorpay_order_id: str razorpay_payment_id: str razorpay_signature: str user_id: Optional[str] = None # ===== IMAGE PROCESSING ===== def prepare_image_base64(image_content: bytes): """Convert image bytes to base64 without prefix""" try: return base64.b64encode(image_content).decode('utf-8') except Exception as e: logger.error(f"Image processing failed: {str(e)}") raise HTTPException(status_code=500, detail=f"Image processing failed: {str(e)}") def validate_image(image_content: bytes): """Validate image meets API requirements""" try: size_mb = len(image_content) / (1024 * 1024) if size_mb > 10: raise HTTPException(status_code=400, detail="Image too large (max 10MB)") img = Image.open(io.BytesIO(image_content)) if img.format != "PNG": raise HTTPException(status_code=400, detail="Only PNG images are supported") return True, "" except Exception as e: raise HTTPException(status_code=400, detail=f"Image validation error: {str(e)}") # ===== API FUNCTIONS ===== def create_multi_image_task(subject_images: List[bytes], prompt: str): """Create image generation task with Gemini API (single image or prompt-only)""" headers = { "Content-Type": "application/json" } subject_image_list = [] if subject_images: # Use only the first image if provided base64_img = prepare_image_base64(subject_images[0]) if base64_img: subject_image_list.append({ "inline_data": { "mime_type": "image/png", "data": base64_img } }) payload = { "contents": [ { "parts": [ {"text": prompt}, *subject_image_list ] } ] } try: logger.info(f"Sending request to Gemini API with payload: {payload}") response = requests.post(CREATE_TASK_ENDPOINT, json=payload, headers=headers) response.raise_for_status() data = response.json() logger.info(f"API response: {data}") if not data.get("candidates") or not data["candidates"][0].get("content"): raise HTTPException(status_code=500, detail="No valid content returned from API") return data except requests.exceptions.RequestException as e: logger.error(f"API request failed: {str(e)}") if hasattr(e, 'response') and e.response: logger.error(f"API response: {e.response.text}") raise HTTPException(status_code=500, detail=f"API Error: {str(e)}") # ===== MAIN PROCESSING ===== async def generate_image(subject_images: List[bytes], prompt: str): """Handle complete image generation workflow""" for img_content in subject_images: if img_content: validate_image(img_content) task_response = create_multi_image_task(subject_images, prompt) try: # Check for error in response if "error" in task_response: error_message = task_response["error"].get("message", "Unknown error") error_code = task_response["error"].get("code", 500) logger.error(f"API returned error: {error_code} - {error_message}") raise HTTPException(status_code=500, detail=f"API error: {error_code} - {error_message}") # Check response structure if "candidates" not in task_response or not task_response["candidates"]: logger.error(f"Invalid response structure: {task_response}") raise HTTPException(status_code=500, detail="Invalid API response: No candidates found") candidate = task_response["candidates"][0] if "content" not in candidate or "parts" not in candidate["content"]: logger.error(f"Invalid content structure: {candidate}") raise HTTPException(status_code=500, detail="Invalid API response: No content parts found") parts = candidate["content"]["parts"] logger.info(f"Response parts: {parts}") # Find the part with inline_data image_base64 = None for part in parts: if "inline_data" in part and "data" in part["inline_data"]: image_base64 = part["inline_data"]["data"] break elif "text" in part: logger.info(f"Text part found: {part['text']}") if not image_base64: logger.error(f"No inline_data found in response parts: {parts}") raise HTTPException(status_code=500, detail="No inline_data found in API response") # Decode and save the image image_data = base64.b64decode(image_base64) output_dir = Path("/tmp") output_dir.mkdir(exist_ok=True) output_path = output_dir / f"gemini_output_{int(time.time())}.png" with open(output_path, "wb") as f: f.write(image_data) return output_path except Exception as e: logger.error(f"Failed to process API response: {str(e)}") raise HTTPException(status_code=500, detail=f"Failed to process result: {str(e)}") # ===== API ENDPOINTS ===== @app.post("/generate") async def generate_image_endpoint( prompt: str = Form(...), images: List[UploadFile] = File(default=[]) ): """Endpoint to generate an image from an optional input image and a prompt""" try: if len(images) > 1: raise HTTPException(status_code=400, detail="Only one image is supported") image_contents = [await image.read() for image in images] output_path = await generate_image(image_contents, prompt) return FileResponse( path=output_path, media_type="image/png", filename=f"gemini_output_{Path(output_path).stem}.png" ) except Exception as e: logger.error(f"Error in /generate: {str(e)}") raise HTTPException(status_code=500, detail=str(e)) @app.post("/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") try: if body and body.amount: amount = body.amount elif not amount: 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) 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_payment_endpoint( request: Request, razorpay_order_id: Optional[str] = Form(None), razorpay_payment_id: Optional[str] = Form(None), razorpay_signature: Optional[str] = Form(None), user_id: Optional[str] = Form(None), body: Optional[VerifyPaymentRequest] = None ): """Verify Razorpay payment signature (supports form-data and JSON)""" logger.info("Received payment verification request") try: 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: 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 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)}" ) 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}") 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)}") return JSONResponse(content={"success": True, "message": "Payment verified successfully"}) else: 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": "Gemini 2.5 Flash 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) } def create_razorpay_order(amount: int): """Create a Razorpay order""" try: if amount <= 0: raise ValueError("Amount must be a positive integer") order_data = { "amount": amount * 100, # Convert INR to paise "currency": "INR", "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)}") raise HTTPException(status_code=500, detail=f"Failed to create order: {str(e)}") def verify_payment_signature(order_id: str, payment_id: str, signature: str): """Verify Razorpay payment signature""" try: params_dict = { "razorpay_order_id": order_id, "razorpay_payment_id": payment_id, "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)}") return False except Exception as e: logger.error(f"Error verifying payment signature: {str(e)}") raise HTTPException(status_code=500, detail=f"Verification error: {str(e)}") if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=7860)