proxy for model viewing

main.py

@@ -8,6 +8,10 @@ from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 from auth import get_current_active_user, User, supabase
 import logging
+import random
+from io import BytesIO
+from urllib.parse import unquote
+from fastapi.responses import StreamingResponse
 
 load_dotenv()
 
@@ -85,13 +89,35 @@ class PlaceOrderRequest(BaseModel):
 @app.post("/auth/signup", tags=["Authentication"])
 async def signup(request: SignUpRequest):
     """
-    Sign up a new user
+    Sign up a new user and create initial profile
     """
     try:
         response = supabase.auth.sign_up({
             "email": request.email,
             "password": request.password
         })
+        
+        # Create user profile entry if user creation was successful
+        if response.user and response.user.id:
+            try:
+                supabase.from_("User").insert({
+                    "user_id": response.user.id,
+                    "email": response.user.email,
+                    "address": None,
+                    "fullname": None,
+                    "phone_number": None
+                }).execute()
+                
+                # Initialize credits
+                supabase.from_("User_Credit_Account").insert({
+                    "user_id": response.user.id,
+                    "num_of_available_gens": 3
+                }).execute()
+
+                print(f"User created successfully: {response.user}")
+            except Exception as profile_error:
+                logging.error(f"Failed to create user profile: {str(profile_error)}")
+        
         return {"message": "User created successfully", "user": response.user}
     except Exception as e:
         raise HTTPException(status_code=400, detail=str(e))
@@ -101,7 +127,7 @@ async def signin(request: SignInRequest):
     """
     Sign in an existing user
     """
-    logging.basicConfig(level=logging.DEBUG)
+    #logging.basicConfig(level=logging.DEBUG)
     logging.debug(f"SignIn request: email={request.email}")
     try:
         response = supabase.auth.sign_in_with_password({
@@ -118,6 +144,7 @@ async def signin(request: SignInRequest):
         logging.error(f"SignIn error: {str(e)}")
         raise HTTPException(status_code=401, detail=f"Invalid credentials: {str(e)}")
 
+# TODO: The signup also creates a profile, so this endpoint should either be removed or /signup updated.
 @app.post("/auth/complete-profile", tags=["Authentication"])
 async def complete_profile(request: CompleteProfileRequest, current_user: User = Depends(get_current_active_user)):
     """
@@ -147,13 +174,16 @@ async def complete_profile(request: CompleteProfileRequest, current_user: User =
 # Protected endpoints
 async def check_and_decrement_credits(user_id: str):
     # Get current credits
-    credit = supabase.from_("User_Credit_Account").select("num_of_available_gens").eq("user_id", user_id).single().execute()
-    if not credit.data or credit.data["num_of_available_gens"] is None:
+    credit = supabase.from_("User_Credit_Account").select("num_of_available_gens").eq("user_id", user_id).execute()
+    if not credit.data:
         raise HTTPException(status_code=403, detail="No credit account found. Please complete your profile.")
-    if credit.data["num_of_available_gens"] <= 0:
+    
+    credit_data = credit.data[0]
+    if credit_data["num_of_available_gens"] is None or credit_data["num_of_available_gens"] <= 0:
         raise HTTPException(status_code=402, detail="No credits left. Please purchase more to generate models.")
+    
     # Decrement credits atomically
-    new_credits = credit.data["num_of_available_gens"] - 1
+    new_credits = credit_data["num_of_available_gens"] - 1
     supabase.from_("User_Credit_Account").update({"num_of_available_gens": new_credits}).eq("user_id", user_id).execute()
 
 @app.post("/req-img-to-3d", tags=["Image-to-3D"])
@@ -179,9 +209,34 @@ async def req_img_to_3d(
         json=payload,
         headers=headers,
     )
-    if resp.status_code not in (200, 201):
+    if resp.status_code not in (200, 201, 202):
         raise HTTPException(status_code=resp.status_code, detail=resp.text)
-    return resp.json()
+    
+    meshy_response = resp.json()
+    meshy_job_id = meshy_response.get("id") or meshy_response.get("task_id")
+    
+    if not meshy_job_id:
+        raise HTTPException(status_code=500, detail="No task ID received from Meshy API")
+    
+    # Save to database
+    try:
+        supabase.from_("Generated_Models").insert({
+            "user_id": current_user.id,
+            "meshy_api_job_id": meshy_job_id,
+            "model_name": f"Image to 3D - {image.filename}",
+            "prompts_and_models_config": {
+                "generation_type": "image_to_3d",
+                "source_filename": image.filename,
+                "content_type": image.content_type,
+                "status": "processing",
+                "meshy_response": meshy_response
+            }
+        }).execute()
+    except Exception as e:
+        logging.error(f"Failed to save model to database: {str(e)}")
+        # Don't fail the request if database save fails
+    
+    return {"id": meshy_job_id, "status": "processing", "meshy_response": meshy_response}
 
 @app.get("/req-result-img-to-3d/{task_id}", tags=["Image-to-3D"])
 async def req_result_img_to_3d(
@@ -197,7 +252,33 @@ async def req_result_img_to_3d(
     resp = await app.state.client.get(url, headers=headers)
     if resp.status_code != 200:
         raise HTTPException(status_code=resp.status_code, detail=resp.text)
-    return resp.json()
+    
+    result = resp.json()
+    
+    # Update database with current status
+    try:
+        # Get existing config to merge with new data
+        existing_model = supabase.from_("Generated_Models").select("prompts_and_models_config").eq("meshy_api_job_id", task_id).eq("user_id", current_user.id).single().execute()
+        
+        if existing_model.data:
+            config = existing_model.data.get("prompts_and_models_config", {})
+            config.update({
+                "status": result.get("status", "unknown"),
+                "meshy_response": result
+            })
+            
+            # If completed, add the model URLs
+            if result.get("status") == "SUCCEEDED" and "model_urls" in result:
+                config["model_urls"] = result["model_urls"]
+                config["thumbnail_url"] = result.get("thumbnail_url")
+            
+            supabase.from_("Generated_Models").update({
+                "prompts_and_models_config": config
+            }).eq("meshy_api_job_id", task_id).eq("user_id", current_user.id).execute()
+    except Exception as e:
+        logging.error(f"Failed to update model status in database: {str(e)}")
+    
+    return result
 
 @app.get("/list-img-to-3d-req", tags=["Image-to-3D"])
 async def list_img_to_3d_req(
@@ -227,12 +308,33 @@ async def req_text_to_3d(
     """
     # Credit check and decrement
     await check_and_decrement_credits(current_user.id)
+    
+    # Save initial record to database immediately after credit check
+    initial_record_id = None
+    try:
+        initial_result = supabase.from_("Generated_Models").insert({
+            "user_id": current_user.id,
+            "meshy_api_job_id": None,
+            "model_name": f"Text to 3D - {prompt.text[:50]}{'...' if len(prompt.text) > 50 else ''}",
+            "prompts_and_models_config": {
+                "generation_type": "text_to_3d",
+                "original_prompt": prompt.text,
+                "status": "initializing",
+                "stage": "reframing_prompt"
+            }
+        }).execute()
+        initial_record_id = initial_result.data[0]["generated_model_id"] if initial_result.data else None
+        print(f"Created initial database record: {initial_record_id}")
+    except Exception as e:
+        print(f"Failed to create initial database record: {str(e)}")
+        # Continue with the request even if database save fails
+    
     # Reframe prompt
     openai_resp = await app.state.client.post(
         "https://api.openai.com/v1/chat/completions",
         headers={"Authorization": f"Bearer {settings.openai_api_key}"},
         json={
-            "model": "gpt-3.5-turbo",
+            "model": "gpt-4o-mini",
             "messages": [
                 {"role": "system", "content": "Rephrase the user description to be an ideal prompt for 3D model generation."},
                 {"role": "user", "content": prompt.text}
@@ -240,17 +342,117 @@ async def req_text_to_3d(
         }
     )
     if openai_resp.status_code != 200:
+        # Update database with error status if initial record was created
+        if initial_record_id:
+            try:
+                supabase.from_("Generated_Models").update({
+                    "prompts_and_models_config": {
+                        "generation_type": "text_to_3d",
+                        "original_prompt": prompt.text,
+                        "status": "failed",
+                        "stage": "reframing_prompt",
+                        "error": f"OpenAI API error: {openai_resp.text}"
+                    }
+                }).eq("generated_model_id", initial_record_id).execute()
+            except Exception as e:
+                print(f"Failed to update database with error: {str(e)}")
         raise HTTPException(status_code=openai_resp.status_code, detail=openai_resp.text)
+    
     reframed = openai_resp.json()["choices"][0]["message"]["content"]
+    
+    # Update database with reframed prompt
+    if initial_record_id:
+        try:
+            supabase.from_("Generated_Models").update({
+                "prompts_and_models_config": {
+                    "generation_type": "text_to_3d",
+                    "original_prompt": prompt.text,
+                    "reframed_prompt": reframed,
+                    "status": "processing",
+                    "stage": "creating_3d_model"
+                }
+            }).eq("generated_model_id", initial_record_id).execute()
+        except Exception as e:
+            print(f"Failed to update database with reframed prompt: {str(e)}")
+    
     # Create Meshy Text-to-3D task
+    meshy_payload = {"mode": "preview", "prompt": reframed}
+    print(f"Sending to Meshy API: {meshy_payload}")
+    
     meshy_resp = await app.state.client.post(
         "https://api.meshy.ai/openapi/v2/text-to-3d",
         headers={"Authorization": f"Bearer {settings.mesh_api_key}"},
-        json={"mode": "preview", "prompt": reframed}
+        json=meshy_payload
     )
-    if meshy_resp.status_code not in (200, 201):
-        raise HTTPException(status_code=meshy_resp.status_code, detail=meshy_resp.text)
-    return meshy_resp.json()
+    if meshy_resp.status_code not in (200, 201, 202):
+        # Log the full response for debugging
+        error_text = meshy_resp.text
+        print(f"Meshy API error - Status: {meshy_resp.status_code}, Response: {error_text}")
+        
+        # Try to parse the response as JSON to provide better error details
+        try:
+            error_json = meshy_resp.json()
+            error_detail = f"Meshy API error (status {meshy_resp.status_code}): {error_json}"
+        except:
+            error_detail = f"Meshy API error (status {meshy_resp.status_code}): {error_text}"
+        
+        # Update database with error status if initial record was created
+        if initial_record_id:
+            try:
+                supabase.from_("Generated_Models").update({
+                    "prompts_and_models_config": {
+                        "generation_type": "text_to_3d",
+                        "original_prompt": prompt.text,
+                        "reframed_prompt": reframed,
+                        "status": "failed",
+                        "stage": "creating_3d_model",
+                        "error": error_detail
+                    }
+                }).eq("generated_model_id", initial_record_id).execute()
+            except Exception as e:
+                print(f"Failed to update database with error: {str(e)}")
+        raise HTTPException(status_code=meshy_resp.status_code, detail=error_detail)
+    
+    meshy_response = meshy_resp.json()
+    task_id = meshy_response.get("result") or meshy_response.get("id") or meshy_response.get("task_id")
+    
+    if not task_id:
+        # Update database with error status if initial record was created
+        if initial_record_id:
+            try:
+                supabase.from_("Generated_Models").update({
+                    "prompts_and_models_config": {
+                        "generation_type": "text_to_3d",
+                        "original_prompt": prompt.text,
+                        "reframed_prompt": reframed,
+                        "status": "failed",
+                        "stage": "creating_3d_model",
+                        "error": "No task ID received from Meshy API"
+                    }
+                }).eq("generated_model_id", initial_record_id).execute()
+            except Exception as e:
+                print(f"Failed to update database with error: {str(e)}")
+        raise HTTPException(status_code=500, detail="No task ID received from Meshy API")
+    
+    # Update database with final successful response
+    print(f"Updating database record with task ID: {task_id}")
+    try:
+        supabase.from_("Generated_Models").update({
+            "meshy_api_job_id": task_id,
+            "prompts_and_models_config": {
+                "generation_type": "text_to_3d",
+                "original_prompt": prompt.text,
+                "reframed_prompt": reframed,
+                "status": "processing",
+                "stage": "generating",
+                "meshy_response": meshy_response
+            }
+        }).eq("generated_model_id", initial_record_id).execute()
+    except Exception as e:
+        print(f"Failed to update database with final response: {str(e)}")
+        # Don't fail the request if database save fails
+    
+    return {"id": initial_record_id, "meshy_task_id": task_id, "status": "processing", "original_prompt": prompt.text, "reframed_prompt": reframed, "meshy_response": meshy_response}
 
 @app.get("/req-result-text-to-3d/{task_id}", tags=["Text-to-3D"])
 async def req_result_text_to_3d(
@@ -267,7 +469,33 @@ async def req_result_text_to_3d(
     )
     if resp.status_code != 200:
         raise HTTPException(status_code=resp.status_code, detail=resp.text)
-    return resp.json()
+    
+    result = resp.json()
+    
+    # Update database with current status
+    try:
+        # Get existing config to merge with new data
+        existing_model = supabase.from_("Generated_Models").select("prompts_and_models_config").eq("meshy_api_job_id", task_id).eq("user_id", current_user.id).single().execute()
+        
+        if existing_model.data:
+            config = existing_model.data.get("prompts_and_models_config", {})
+            config.update({
+                "status": result.get("status", "unknown"),
+                "meshy_response": result
+            })
+            
+            # If completed, add the model URLs
+            if result.get("status") == "SUCCEEDED" and "model_urls" in result:
+                config["model_urls"] = result["model_urls"]
+                config["thumbnail_url"] = result.get("thumbnail_url")
+            
+            supabase.from_("Generated_Models").update({
+                "prompts_and_models_config": config
+            }).eq("meshy_api_job_id", task_id).eq("user_id", current_user.id).execute()
+    except Exception as e:
+        logging.error(f"Failed to update model status in database: {str(e)}")
+    
+    return result
 
 @app.get("/list-text-to-3d-req", tags=["Text-to-3D"])
 async def list_text_to_3d_req(
@@ -326,9 +554,161 @@ async def get_orders(current_user: User = Depends(get_current_active_user)):
 
 @app.get("/user/models", tags=["User"])
 async def get_models(current_user: User = Depends(get_current_active_user)):
-    models = supabase.from_("Generated_Models").select("*").eq("user_id", current_user.id).execute()
+    models = supabase.from_("Generated_Models").select("*").eq("user_id", current_user.id).order("created_at", desc=True).execute()
     return models.data
 
+@app.get("/user/models/{task_id}", tags=["User"])
+async def get_model_by_task_id(task_id: str, current_user: User = Depends(get_current_active_user)):
+    """
+    Get a specific model by task ID for the current user.
+    """
+    model = supabase.from_("Generated_Models").select("*").eq("meshy_api_job_id", task_id).eq("user_id", current_user.id).single().execute()
+    if not model.data:
+        raise HTTPException(status_code=404, detail="Model not found")
+    return model.data
+
+@app.post("/user/models/{task_id}/refresh", tags=["User"])
+async def refresh_model_status(
+    task_id: str, 
+    current_user: User = Depends(get_current_active_user),
+    settings: Settings = Depends(get_settings)
+):
+    """
+    Manually refresh the status of a model by checking with Meshy API.
+    """
+    # First check if the model exists and belongs to the user
+    try:
+        model = supabase.from_("Generated_Models").select("*").eq("meshy_api_job_id", task_id).eq("user_id", current_user.id).single().execute()
+        if not model.data:
+            raise HTTPException(status_code=404, detail="Model not found")
+    except Exception:
+        raise HTTPException(status_code=404, detail="Model not found")
+    
+    config = model.data.get("prompts_and_models_config", {})
+    generation_type = config.get("generation_type")
+    
+    try:
+        # Call the appropriate API based on generation type
+        if generation_type == "text_to_3d":
+            resp = await app.state.client.get(
+                f"https://api.meshy.ai/openapi/v2/text-to-3d/{task_id}",
+                headers={"Authorization": f"Bearer {settings.mesh_api_key}"}
+            )
+        elif generation_type == "image_to_3d":
+            resp = await app.state.client.get(
+                f"https://api.meshy.ai/openapi/v1/image-to-3d/{task_id}",
+                headers={"Authorization": f"Bearer {settings.mesh_api_key}"}
+            )
+        else:
+            raise HTTPException(status_code=400, detail="Unknown generation type")
+        
+        if resp.status_code != 200:
+            raise HTTPException(status_code=resp.status_code, detail=resp.text)
+        
+        result = resp.json()
+        
+        # Update database with current status
+        config.update({
+            "status": result.get("status", "unknown"),
+            "meshy_response": result
+        })
+        
+        # If completed, add the model URLs
+        if result.get("status") == "SUCCEEDED" and "model_urls" in result:
+            config["model_urls"] = result["model_urls"]
+            config["thumbnail_url"] = result.get("thumbnail_url")
+        
+        supabase.from_("Generated_Models").update({
+            "prompts_and_models_config": config
+        }).eq("meshy_api_job_id", task_id).eq("user_id", current_user.id).execute()
+        
+        # Return updated model data
+        updated_model = supabase.from_("Generated_Models").select("*").eq("meshy_api_job_id", task_id).eq("user_id", current_user.id).single().execute()
+        return updated_model.data
+        
+    except Exception as e:
+        logging.error(f"Failed to refresh model status: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Failed to refresh model status: {str(e)}")
+
+@app.post("/user/models/{generated_model_id}/refresh", tags=["User"])
+async def refresh_model_status_by_id(
+    generated_model_id: str, 
+    current_user: User = Depends(get_current_active_user),
+    settings: Settings = Depends(get_settings)
+):
+    """
+    Manually refresh the status of a model by checking with Meshy API using the generated model ID.
+    """
+    # First check if the model exists and belongs to the user
+    try:
+        model = supabase.from_("Generated_Models").select("*").eq("generated_model_id", generated_model_id).eq("user_id", current_user.id).single().execute()
+        if not model.data:
+            raise HTTPException(status_code=404, detail="Model not found")
+    except Exception:
+        raise HTTPException(status_code=404, detail="Model not found")
+    
+    task_id = model.data.get("meshy_api_job_id")
+    if not task_id:
+        raise HTTPException(status_code=400, detail="No Meshy API task ID found for this model")
+    
+    config = model.data.get("prompts_and_models_config", {})
+    generation_type = config.get("generation_type")
+    
+    try:
+        # Call the appropriate API based on generation type
+        if generation_type == "text_to_3d":
+            resp = await app.state.client.get(
+                f"https://api.meshy.ai/openapi/v2/text-to-3d/{task_id}",
+                headers={"Authorization": f"Bearer {settings.mesh_api_key}"}
+            )
+        elif generation_type == "image_to_3d":
+            resp = await app.state.client.get(
+                f"https://api.meshy.ai/openapi/v1/image-to-3d/{task_id}",
+                headers={"Authorization": f"Bearer {settings.mesh_api_key}"}
+            )
+        else:
+            raise HTTPException(status_code=400, detail="Unknown generation type")
+        
+        if resp.status_code != 200:
+            raise HTTPException(status_code=resp.status_code, detail=resp.text)
+        
+        result = resp.json()
+        
+        # Update database with current status
+        config.update({
+            "status": result.get("status", "unknown"),
+            "meshy_response": result
+        })
+        
+        # If completed, add the model URLs
+        if result.get("status") == "SUCCEEDED" and "model_urls" in result:
+            config["model_urls"] = result["model_urls"]
+            config["thumbnail_url"] = result.get("thumbnail_url")
+        
+        supabase.from_("Generated_Models").update({
+            "prompts_and_models_config": config
+        }).eq("generated_model_id", generated_model_id).eq("user_id", current_user.id).execute()
+        
+        # Return updated model data
+        updated_model = supabase.from_("Generated_Models").select("*").eq("generated_model_id", generated_model_id).eq("user_id", current_user.id).single().execute()
+        return updated_model.data
+        
+    except Exception as e:
+        logging.error(f"Failed to refresh model status: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Failed to refresh model status: {str(e)}")
+
+# Keeping the old endpoint for backward compatibility
+@app.post("/user/models/refresh/{generated_model_id}", tags=["User"])
+async def refresh_model_status_by_id_legacy(
+    generated_model_id: str, 
+    current_user: User = Depends(get_current_active_user),
+    settings: Settings = Depends(get_settings)
+):
+    """
+    Legacy endpoint - use /user/models/{generated_model_id}/refresh instead.
+    """
+    return await refresh_model_status_by_id(generated_model_id, current_user, settings)
+
 @app.post("/orders/place", tags=["Orders"])
 async def place_order(request: PlaceOrderRequest, current_user: User = Depends(get_current_active_user)):
     """
@@ -355,6 +735,29 @@ async def health_check():
     """Basic health-check endpoint returning service status."""
     return {"status": "ok"}
 
+@app.get("/proxy/model", tags=["Proxy"])
+async def proxy_model(url: str):
+    """
+    Simple CORS-friendly proxy for GLB (or any binary) files.
+    The front-end should call this endpoint with the target URL percent-encoded,
+    e.g. /proxy/model?url=https%3A%2F%2Fassets.meshy.ai%2F....glb
+    """
+    try:
+        # Decode once in case the URL is already percent-encoded
+        target_url = unquote(url)
+        upstream_resp = await app.state.client.get(target_url)
+        if upstream_resp.status_code != 200:
+            raise HTTPException(status_code=upstream_resp.status_code,
+                                detail=f"Failed to fetch remote model: {upstream_resp.text}")
+
+        content_type = upstream_resp.headers.get("Content-Type", "model/gltf-binary")
+        headers = {"Access-Control-Allow-Origin": "*"}
+
+        # Stream the content back to the client
+        return StreamingResponse(BytesIO(upstream_resp.content), media_type=content_type, headers=headers)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run("main:app", host="0.0.0.0", port=8000, log_level="info")