Update app.py

app.py

@@ -249,270 +249,203 @@ async def test_admin_db():
     except Exception as e:
         return {"ok": False, "error": str(e), "url": ADMIN_MONGO_URL}
 
-# @fastapi_app.post("/face-swap", dependencies=[Depends(verify_token)])
-# async def face_swap_api(
-#     source: UploadFile = File(...),
-#     target_category_id: str = Form(None),
-#     new_category_id: str = Form(None),
-#     user_id: Optional[str] = Form(None),
-#     credentials: HTTPAuthorizationCredentials = Security(security)
-# ):
-#     start_time = datetime.utcnow()
-
-#     try:
-#         # ------------------------------------------------------------------
-#         # VALIDATION
-#         # ------------------------------------------------------------------
-#         if target_category_id and new_category_id:
-#             raise HTTPException(400, "Provide only one of new_category_id or target_category_id.")
-
-#         if not target_category_id and not new_category_id:
-#             raise HTTPException(400, "Either new_category_id or target_category_id is required.")
-
-#         # ------------------------------------------------------------------
-#         # READ SOURCE IMAGE
-#         # ------------------------------------------------------------------
-#         src_bytes = await source.read()
-#         src_key = f"faceswap/source/{uuid.uuid4().hex}_{source.filename}"
-#         upload_to_spaces(src_bytes, src_key, content_type=source.content_type)
-
-#         # ------------------------------------------------------------------
-#         # CASE 1 : new_category_id → MongoDB lookup
-#         # ------------------------------------------------------------------
-#         if new_category_id:
-
-#             doc = await subcategories_col.find_one({
-#                 "asset_images._id": ObjectId(new_category_id)
-#             })
-
-#             if not doc:
-#                 raise HTTPException(404, "Asset image not found in database")
-
-#             # extract correct asset
-#             asset = next(
-#                 (img for img in doc["asset_images"] if str(img["_id"]) == new_category_id),
-#                 None
-#             )
-
-#             if not asset:
-#                 raise HTTPException(404, "Asset image URL not found")
-
-#             # correct URL
-#             target_url = asset["url"]
-
-#             # correct categoryId (ObjectId)
-#             #category_oid = doc["categoryId"]   # <-- DO NOT CONVERT TO STRING
-#             subcategory_oid = doc["_id"]
-    
-#             # ------------------------------------------------------------------
-#             # MEDIA_CLICKS (ONLY IF user_id PRESENT)
-#             # ------------------------------------------------------------------
-#             # MEDIA_CLICKS (ONLY IF user_id PRESENT)
-#             if user_id:
-#                 try:
-#                     user_oid = ObjectId(user_id.strip())
-#                     now = datetime.utcnow()
-            
-#                     # Try updating existing subCategory
-#                     update_result = await media_clicks_col.update_one(
-#                         {"userId": user_oid, "subCategories.subCategoryId": subcategory_oid},
-#                         {
-#                             "$set": {
-#                                 "updatedAt": now,
-#                                 "subCategories.$.lastClickedAt": now
-#                             },
-#                             "$inc": {"subCategories.$.click_count": 1}
-#                         }
-#                     )
-            
-#                     # If subCategory does NOT exist → push new one
-#                     if update_result.matched_count == 0:
-#                         await media_clicks_col.update_one(
-#                             {"userId": user_oid},
-#                             {
-#                                 "$setOnInsert": {"createdAt": now},
-#                                 "$set": {"updatedAt": now},
-#                                 "$push": {
-#                                     "subCategories": {
-#                                         "subCategoryId": subcategory_oid,
-#                                         "click_count": 1,
-#                                         "lastClickedAt": now
-#                                     }
-#                                 }
-#                             },
-#                             upsert=True
-#                         )
-            
-#                 except Exception as media_err:
-#                     logger.error(f"MEDIA_CLICK ERROR: {media_err}")
-
-#         # ------------------------------------------------------------------
-#         # CASE 2 : target_category_id → DigitalOcean path (unchanged logic)
-#         # ------------------------------------------------------------------
-#         if target_category_id:
-#             client = get_spaces_client()
-#             base_prefix = "faceswap/target/"
-#             resp = client.list_objects_v2(
-#                 Bucket=DO_SPACES_BUCKET, Prefix=base_prefix, Delimiter="/"
-#             )
-#             categories = [p["Prefix"].split("/")[2] for p in resp.get("CommonPrefixes", [])]
-
-#             target_url = None
-
-#             for category in categories:
-#                 original_prefix = f"faceswap/target/{category}/original/"
-#                 original_objs = client.list_objects_v2(
-#                     Bucket=DO_SPACES_BUCKET, Prefix=original_prefix
-#                 ).get("Contents", [])
-
-#                 original_files = sorted([obj["Key"] for obj in original_objs])
-
-#                 for idx, file_key in enumerate(original_files, start=1):
-#                     cid = f"{category.lower()}image_{idx}"
-#                     if cid == target_category_id:
-#                         target_url = f"{DO_SPACES_ENDPOINT}/{DO_SPACES_BUCKET}/{file_key}"
-#                         break
-
-#                 if target_url:
-#                     break
-
-#             if not target_url:
-#                 raise HTTPException(404, "Target categoryId not found")
-
-#         # ------------------------------------------------------------------
-#         # DOWNLOAD TARGET IMAGE
-#         # ------------------------------------------------------------------
-#         tgt_bytes = requests.get(target_url).content
-
-#         src_bgr = cv2.imdecode(np.frombuffer(src_bytes, np.uint8), cv2.IMREAD_COLOR)
-#         tgt_bgr = cv2.imdecode(np.frombuffer(tgt_bytes, np.uint8), cv2.IMREAD_COLOR)
+@fastapi_app.post("/face-swap", dependencies=[Depends(verify_token)])
+async def face_swap_api(
+    source: UploadFile = File(...),
+    target_category_id: str = Form(None),
+    new_category_id: str = Form(None),
+    user_id: Optional[str] = Form(None),
+    credentials: HTTPAuthorizationCredentials = Security(security)
+):
+    start_time = datetime.utcnow()
 
-#         if src_bgr is None or tgt_bgr is None:
-#             raise HTTPException(400, "Invalid image data")
+    try:
 
-#         src_rgb = cv2.cvtColor(src_bgr, cv2.COLOR_BGR2RGB)
-#         tgt_rgb = cv2.cvtColor(tgt_bgr, cv2.COLOR_BGR2RGB)
+        # --------------------------------------------------------------
+        # NORMALIZE EMPTY STRINGS (BACKWARD COMPATIBILITY FOR ANDROID)
+        # --------------------------------------------------------------
+        if target_category_id == "":
+            target_category_id = None
 
-#         # ------------------------------------------------------------------
-#         # FACE SWAP EXECUTION
-#         # ------------------------------------------------------------------
-#         final_img, final_path, err = face_swap_and_enhance(src_rgb, tgt_rgb)
-#         if err:
-#             raise HTTPException(500, err)
+        if new_category_id == "":
+            new_category_id = None
 
-#         with open(final_path, "rb") as f:
-#             result_bytes = f.read()
+        if user_id == "":
+            user_id = None
 
-#         result_key = f"faceswap/result/{uuid.uuid4().hex}_enhanced.png"
-#         result_url = upload_to_spaces(result_bytes, result_key)
-#         end_time = datetime.utcnow()
-#         response_time_ms = (end_time - start_time).total_seconds() * 1000
+        # --------------------------------------------------------------
+        # VALIDATION
+        # --------------------------------------------------------------
+        if target_category_id and new_category_id:
+            raise HTTPException(400, "Provide only one of new_category_id or target_category_id.")
 
-#         if database is not None:
-#             await database.api_logs.insert_one({
-#                 "endpoint": "/face-swap",
-#                 "status": "success",
-#                 "response_time_ms": response_time_ms,
-#                 "timestamp": end_time
-#             })
+        if not target_category_id and not new_category_id:
+            raise HTTPException(400, "Either new_category_id or target_category_id is required.")
 
+        # ------------------------------------------------------------------
+        # READ SOURCE IMAGE
+        # ------------------------------------------------------------------
+        src_bytes = await source.read()
+        src_key = f"faceswap/source/{uuid.uuid4().hex}_{source.filename}"
+        upload_to_spaces(src_bytes, src_key, content_type=source.content_type)
 
-#         return {
-#             "result_key": result_key,
-#             "result_url": result_url
-#         }
-        
+        # ------------------------------------------------------------------
+        # CASE 1 : new_category_id → MongoDB lookup
+        # ------------------------------------------------------------------
+        if new_category_id:
 
-#     except Exception as e:
-#         end_time = datetime.utcnow()
-#         response_time_ms = (end_time - start_time).total_seconds() * 1000
+            doc = await subcategories_col.find_one({
+                "asset_images._id": ObjectId(new_category_id)
+            })
 
-#         if database is not None:
-#             await database.api_logs.insert_one({
-#                 "endpoint": "/face-swap",
-#                 "status": "fail",
-#                 "response_time_ms": response_time_ms,
-#                 "timestamp": end_time,
-#                 "error": str(e)
-#             })
+            if not doc:
+                raise HTTPException(404, "Asset image not found in database")
 
-#         raise HTTPException(500, f"Face swap failed: {str(e)}")
+            # extract correct asset
+            asset = next(
+                (img for img in doc["asset_images"] if str(img["_id"]) == new_category_id),
+                None
+            )
 
+            if not asset:
+                raise HTTPException(404, "Asset image URL not found")
 
+            # correct URL
+            target_url = asset["url"]
 
+            # correct categoryId (ObjectId)
+            #category_oid = doc["categoryId"]   # <-- DO NOT CONVERT TO STRING
+            subcategory_oid = doc["_id"]
+    
+            # ------------------------------------------------------------------
+            # MEDIA_CLICKS (ONLY IF user_id PRESENT)
+            # ------------------------------------------------------------------
+            if user_id:
+                try:
+                    user_oid = ObjectId(user_id.strip())
+                    now = datetime.utcnow()
+            
+                    # ----------------------------------------------------------
+                    # 1. UPDATE EXISTING SUBCATEGORY IF PRESENT
+                    # ----------------------------------------------------------
+                    update_result = await media_clicks_col.update_one(
+                        {
+                            "userId": user_oid,
+                            "subCategories.subCategoryId": subcategory_oid
+                        },
+                        {
+                            "$set": {
+                                "updatedAt": now,
+                                "subCategories.$.lastClickedAt": now
+                            },
+                            "$inc": {
+                                "subCategories.$.click_count": 1
+                            }
+                        }
+                    )
+            
+                    # ----------------------------------------------------------
+                    # 2. If user exists BUT subCategory NOT found → push subCategory
+                    # ----------------------------------------------------------
+                    if update_result.matched_count == 0:
+                        update_result_user = await media_clicks_col.update_one(
+                            {"userId": user_oid},
+                            {
+                                "$set": {"updatedAt": now},
+                                "$push": {
+                                    "subCategories": {
+                                        "subCategoryId": subcategory_oid,
+                                        "click_count": 1,
+                                        "lastClickedAt": now
+                                    }
+                                }
+                            }
+                        )
+            
+                        # ------------------------------------------------------
+                        # 3. If user document does NOT exist → CREATE NEW DOC
+                        # ------------------------------------------------------
+                        if update_result_user.matched_count == 0:
+                            await media_clicks_col.insert_one({
+                                "userId": user_oid,
+                                "createdAt": now,
+                                "updatedAt": now,
+                                "categories": [],       # keep empty or retain existing structure
+                                "subCategories": [
+                                    {
+                                        "subCategoryId": subcategory_oid,
+                                        "click_count": 1,
+                                        "lastClickedAt": now
+                                    }
+                                ]
+                            })
+            
+                except Exception as media_err:
+                    logger.error(f"MEDIA_CLICK ERROR: {media_err}")
+
+
+        # ------------------------------------------------------------------
+        # CASE 2 : target_category_id → DigitalOcean path (unchanged logic)
+        # ------------------------------------------------------------------
+        if target_category_id:
+            client = get_spaces_client()
+            base_prefix = "faceswap/target/"
+            resp = client.list_objects_v2(
+                Bucket=DO_SPACES_BUCKET, Prefix=base_prefix, Delimiter="/"
+            )
+            categories = [p["Prefix"].split("/")[2] for p in resp.get("CommonPrefixes", [])]
+
+            target_url = None
+
+            for category in categories:
+                original_prefix = f"faceswap/target/{category}/original/"
+                original_objs = client.list_objects_v2(
+                    Bucket=DO_SPACES_BUCKET, Prefix=original_prefix
+                ).get("Contents", [])
+
+                original_files = sorted([obj["Key"] for obj in original_objs])
+
+                for idx, file_key in enumerate(original_files, start=1):
+                    cid = f"{category.lower()}image_{idx}"
+                    if cid == target_category_id:
+                        target_url = f"{DO_SPACES_ENDPOINT}/{DO_SPACES_BUCKET}/{file_key}"
+                        break
+
+                if target_url:
+                    break
 
+            if not target_url:
+                raise HTTPException(404, "Target categoryId not found")
 
-@fastapi_app.post("/face-swap", dependencies=[Depends(verify_token)])
-async def face_swap_api(
-    source: UploadFile = File(...),
-    target_category_id: str = Form(...),
-    credentials: HTTPAuthorizationCredentials = Security(security)
-):
-    start_time = datetime.utcnow()  # start timer
-    try:
-        # Read source image
-        src_bytes = await source.read()
+        # ------------------------------------------------------------------
+        # DOWNLOAD TARGET IMAGE
+        # ------------------------------------------------------------------
+        tgt_bytes = requests.get(target_url).content
 
-        # Save source to Spaces
-        src_key = f"faceswap/source/{uuid.uuid4().hex}_{source.filename}"
-        upload_to_spaces(src_bytes, src_key, content_type=source.content_type)
+        src_bgr = cv2.imdecode(np.frombuffer(src_bytes, np.uint8), cv2.IMREAD_COLOR)
+        tgt_bgr = cv2.imdecode(np.frombuffer(tgt_bytes, np.uint8), cv2.IMREAD_COLOR)
 
-        # Find target image URL from categoryId
-        client = get_spaces_client()
-        base_prefix = "faceswap/target/"
-        resp = client.list_objects_v2(Bucket=DO_SPACES_BUCKET, Prefix=base_prefix, Delimiter="/")
-        categories = [prefix["Prefix"].split("/")[2] for prefix in resp.get("CommonPrefixes", [])]
-        target_url = None
-        for category in categories:
-            original_prefix = f"faceswap/target/{category}/original/"
-            thumb_prefix = f"faceswap/target/{category}/thumb/"
-            original_objects = client.list_objects_v2(Bucket=DO_SPACES_BUCKET, Prefix=original_prefix)
-            thumb_objects = client.list_objects_v2(Bucket=DO_SPACES_BUCKET, Prefix=thumb_prefix)
-            original_files = [obj["Key"].split("/")[-1] for obj in original_objects.get("Contents", []) if obj["Key"].endswith(".png")]
-            thumb_files = [obj["Key"].split("/")[-1] for obj in thumb_objects.get("Contents", []) if obj["Key"].endswith(".png")]
-            for idx, filename in enumerate(sorted(original_files), start=1):
-                cid = f"{category.lower()}image_{idx}"
-                if filename in thumb_files and cid == target_category_id:
-                    target_url = f"https://{DO_SPACES_BUCKET}.blr1.digitaloceanspaces.com/{original_prefix}{filename}"
-                    break
-            if target_url:
-                break
-        if not target_url:
-            raise HTTPException(status_code=404, detail="Target categoryId not found")
-
-        # Download target image from Spaces
-        resp = requests.get(target_url)
-        if resp.status_code != 200:
-            raise HTTPException(status_code=404, detail="Target image not found in Spaces")
-        tgt_bytes = resp.content
-
-        # Decode for processing
-        src_array = np.frombuffer(src_bytes, np.uint8)
-        tgt_array = np.frombuffer(tgt_bytes, np.uint8)
-        src_bgr = cv2.imdecode(src_array, cv2.IMREAD_COLOR)
-        tgt_bgr = cv2.imdecode(tgt_array, cv2.IMREAD_COLOR)
         if src_bgr is None or tgt_bgr is None:
-            raise HTTPException(status_code=400, detail="Invalid image data")
+            raise HTTPException(400, "Invalid image data")
 
         src_rgb = cv2.cvtColor(src_bgr, cv2.COLOR_BGR2RGB)
         tgt_rgb = cv2.cvtColor(tgt_bgr, cv2.COLOR_BGR2RGB)
 
-        # Run face swap pipeline
+        # ------------------------------------------------------------------
+        # FACE SWAP EXECUTION
+        # ------------------------------------------------------------------
         final_img, final_path, err = face_swap_and_enhance(src_rgb, tgt_rgb)
         if err:
-            raise HTTPException(status_code=500, detail=err)
+            raise HTTPException(500, err)
 
-        # Upload result to Spaces
         with open(final_path, "rb") as f:
             result_bytes = f.read()
-        result_key = f"faceswap/result/{uuid.uuid4().hex}_enhanced.png"
-        result_url = upload_to_spaces(result_bytes, result_key, content_type="image/png")
 
-        # Calculate response time
+        result_key = f"faceswap/result/{uuid.uuid4().hex}_enhanced.png"
+        result_url = upload_to_spaces(result_bytes, result_key,content_type="image/png")
+        
         end_time = datetime.utcnow()
         response_time_ms = (end_time - start_time).total_seconds() * 1000
-
-        # Log response time only
         if database is not None:
             await database.api_logs.insert_one({
                 "endpoint": "/face-swap",
@@ -521,12 +454,17 @@ async def face_swap_api(
                 "timestamp": end_time
             })
 
-        return {"result_key": result_key, "result_url": result_url}
+
+        return {
+            "result_key": result_key,
+            "result_url": result_url
+        }
+        
 
     except Exception as e:
-        # Log response time even on error
         end_time = datetime.utcnow()
         response_time_ms = (end_time - start_time).total_seconds() * 1000
+
         if database is not None:
             await database.api_logs.insert_one({
                 "endpoint": "/face-swap",
@@ -535,7 +473,108 @@ async def face_swap_api(
                 "timestamp": end_time,
                 "error": str(e)
             })
-        raise HTTPException(status_code=500, detail=f"Face swap failed: {str(e)}")
+
+        raise HTTPException(500, f"Face swap failed: {str(e)}")
+
+
+
+
+#-------------------------------------------------------------------------------------------------------------------------------#
+####OLD CODE------------------------------------------------------------------------------------
+# @fastapi_app.post("/face-swap", dependencies=[Depends(verify_token)])
+# async def face_swap_api(
+#     source: UploadFile = File(...),
+#     target_category_id: str = Form(...),
+#     credentials: HTTPAuthorizationCredentials = Security(security)
+# ):
+#     start_time = datetime.utcnow()  # start timer
+#     try:
+#         # Read source image
+#         src_bytes = await source.read()
+
+#         # Save source to Spaces
+#         src_key = f"faceswap/source/{uuid.uuid4().hex}_{source.filename}"
+#         upload_to_spaces(src_bytes, src_key, content_type=source.content_type)
+
+#         # Find target image URL from categoryId
+#         client = get_spaces_client()
+#         base_prefix = "faceswap/target/"
+#         resp = client.list_objects_v2(Bucket=DO_SPACES_BUCKET, Prefix=base_prefix, Delimiter="/")
+#         categories = [prefix["Prefix"].split("/")[2] for prefix in resp.get("CommonPrefixes", [])]
+#         target_url = None
+#         for category in categories:
+#             original_prefix = f"faceswap/target/{category}/original/"
+#             thumb_prefix = f"faceswap/target/{category}/thumb/"
+#             original_objects = client.list_objects_v2(Bucket=DO_SPACES_BUCKET, Prefix=original_prefix)
+#             thumb_objects = client.list_objects_v2(Bucket=DO_SPACES_BUCKET, Prefix=thumb_prefix)
+#             original_files = [obj["Key"].split("/")[-1] for obj in original_objects.get("Contents", []) if obj["Key"].endswith(".png")]
+#             thumb_files = [obj["Key"].split("/")[-1] for obj in thumb_objects.get("Contents", []) if obj["Key"].endswith(".png")]
+#             for idx, filename in enumerate(sorted(original_files), start=1):
+#                 cid = f"{category.lower()}image_{idx}"
+#                 if filename in thumb_files and cid == target_category_id:
+#                     target_url = f"https://{DO_SPACES_BUCKET}.blr1.digitaloceanspaces.com/{original_prefix}{filename}"
+#                     break
+#             if target_url:
+#                 break
+#         if not target_url:
+#             raise HTTPException(status_code=404, detail="Target categoryId not found")
+
+#         # Download target image from Spaces
+#         resp = requests.get(target_url)
+#         if resp.status_code != 200:
+#             raise HTTPException(status_code=404, detail="Target image not found in Spaces")
+#         tgt_bytes = resp.content
+
+#         # Decode for processing
+#         src_array = np.frombuffer(src_bytes, np.uint8)
+#         tgt_array = np.frombuffer(tgt_bytes, np.uint8)
+#         src_bgr = cv2.imdecode(src_array, cv2.IMREAD_COLOR)
+#         tgt_bgr = cv2.imdecode(tgt_array, cv2.IMREAD_COLOR)
+#         if src_bgr is None or tgt_bgr is None:
+#             raise HTTPException(status_code=400, detail="Invalid image data")
+
+#         src_rgb = cv2.cvtColor(src_bgr, cv2.COLOR_BGR2RGB)
+#         tgt_rgb = cv2.cvtColor(tgt_bgr, cv2.COLOR_BGR2RGB)
+
+#         # Run face swap pipeline
+#         final_img, final_path, err = face_swap_and_enhance(src_rgb, tgt_rgb)
+#         if err:
+#             raise HTTPException(status_code=500, detail=err)
+
+#         # Upload result to Spaces
+#         with open(final_path, "rb") as f:
+#             result_bytes = f.read()
+#         result_key = f"faceswap/result/{uuid.uuid4().hex}_enhanced.png"
+#         result_url = upload_to_spaces(result_bytes, result_key, content_type="image/png")
+
+#         # Calculate response time
+#         end_time = datetime.utcnow()
+#         response_time_ms = (end_time - start_time).total_seconds() * 1000
+
+#         # Log response time only
+#         if database is not None:
+#             await database.api_logs.insert_one({
+#                 "endpoint": "/face-swap",
+#                 "status": "success",
+#                 "response_time_ms": response_time_ms,
+#                 "timestamp": end_time
+#             })
+
+#         return {"result_key": result_key, "result_url": result_url}
+
+#     except Exception as e:
+#         # Log response time even on error
+#         end_time = datetime.utcnow()
+#         response_time_ms = (end_time - start_time).total_seconds() * 1000
+#         if database is not None:
+#             await database.api_logs.insert_one({
+#                 "endpoint": "/face-swap",
+#                 "status": "fail",
+#                 "response_time_ms": response_time_ms,
+#                 "timestamp": end_time,
+#                 "error": str(e)
+#             })
+#         raise HTTPException(status_code=500, detail=f"Face swap failed: {str(e)}")