Update app.py

app.py

@@ -8,12 +8,11 @@ import numpy as np
 import threading
 import subprocess
 import logging
-from datetime import datetime
+from datetime import datetime,timedelta
 
 import insightface
 from insightface.app import FaceAnalysis
 from huggingface_hub import hf_hub_download
-
 from fastapi import FastAPI, UploadFile, File, HTTPException, Response, Depends, Security, Form
 from fastapi.responses import RedirectResponse
 from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
@@ -320,14 +319,90 @@ async def face_swap_api(
     
             # ------------------------------------------------------------------
             # # 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()
+            
+            #         # -------------------------------------------------
+            #         # STEP 1: Ensure root fields exist (NO inc here)
+            #         # -------------------------------------------------
+            #         await media_clicks_col.update_one(
+            #             {"userId": user_oid},
+            #             {
+            #                 "$setOnInsert": {
+            #                     "userId": user_oid,
+            #                     "createdAt": now,
+            #                     "ai_edit_complete": 0
+            #                 }
+            #             },
+            #             upsert=True
+            #         )
+            
+            #         # -------------------------------------------------
+            #         # STEP 2: Try updating existing subCategory
+            #         # -------------------------------------------------
+            #         update_result = await media_clicks_col.update_one(
+            #             {
+            #                 "userId": user_oid,
+            #                 "subCategories.subCategoryId": subcategory_oid
+            #             },
+            #             {
+            #                 "$inc": {
+            #                     "subCategories.$.click_count": 1,
+            #                     "ai_edit_complete": 1
+            #                 },
+            #                 "$set": {
+            #                     "subCategories.$.lastClickedAt": now,
+            #                     "ai_edit_last_date": now,
+            #                     "updatedAt": now
+            #                 }
+            #             }
+            #         )
+            
+            #         # -------------------------------------------------
+            #         # STEP 3: Push subCategory if missing
+            #         # -------------------------------------------------
+            #         if update_result.matched_count == 0:
+            #             await media_clicks_col.update_one(
+            #                 {"userId": user_oid},
+            #                 {
+            #                     "$inc": {
+            #                         "ai_edit_complete": 1
+            #                     },
+            #                     "$set": {
+            #                         "ai_edit_last_date": now,
+            #                         "updatedAt": now
+            #                     },
+            #                     "$push": {
+            #                         "subCategories": {
+            #                             "subCategoryId": subcategory_oid,
+            #                             "click_count": 1,
+            #                             "lastClickedAt": now
+            #                         }
+            #                     }
+            #                 }
+            #             )
+            
+            #         logger.info(
+            #             "[MEDIA_CLICK] user=%s subCategory=%s ai_edit_complete++",
+            #             user_id,
+            #             str(subcategory_oid)
+            #         )
+            
+            #     except Exception as media_err:
+            #         logger.error(f"MEDIA_CLICK ERROR: {media_err}")
             if user_id:
                 try:
                     user_oid = ObjectId(user_id.strip())
                     now = datetime.utcnow()
             
+                    # Normalize dates (UTC midnight)
+                    today_date = datetime(now.year, now.month, now.day)
+                    yesterday_date = today_date - timedelta(days=1)
+            
                     # -------------------------------------------------
-                    # STEP 1: Ensure root fields exist (NO inc here)
+                    # STEP 1: Ensure root document exists
                     # -------------------------------------------------
                     await media_clicks_col.update_one(
                         {"userId": user_oid},
@@ -335,14 +410,59 @@ async def face_swap_api(
                             "$setOnInsert": {
                                 "userId": user_oid,
                                 "createdAt": now,
-                                "ai_edit_complete": 0
+                                "ai_edit_complete": 0,
+                                "ai_edit_daily_count": []
                             }
                         },
                         upsert=True
                     )
             
                     # -------------------------------------------------
-                    # STEP 2: Try updating existing subCategory
+                    # STEP 2: Handle DAILY USAGE (binary per day)
+                    # -------------------------------------------------
+            
+                    doc = await media_clicks_col.find_one(
+                        {"userId": user_oid},
+                        {"ai_edit_daily_count": 1}
+                    )
+            
+                    daily_entries = doc.get("ai_edit_daily_count", []) if doc else []
+            
+                    existing_dates = {
+                        entry["date"].date(): entry["count"]
+                        for entry in daily_entries
+                    }
+            
+                    daily_updates = []
+            
+                    # Insert yesterday if missing
+                    if yesterday_date.date() not in existing_dates:
+                        daily_updates.append({
+                            "date": yesterday_date,
+                            "count": 0
+                        })
+            
+                    # Insert today if missing
+                    if today_date.date() not in existing_dates:
+                        daily_updates.append({
+                            "date": today_date,
+                            "count": 1
+                        })
+            
+                    if daily_updates:
+                        await media_clicks_col.update_one(
+                            {"userId": user_oid},
+                            {
+                                "$push": {
+                                    "ai_edit_daily_count": {
+                                        "$each": daily_updates
+                                    }
+                                }
+                            }
+                        )
+            
+                    # -------------------------------------------------
+                    # STEP 3: Try updating existing subCategory
                     # -------------------------------------------------
                     update_result = await media_clicks_col.update_one(
                         {
@@ -363,7 +483,7 @@ async def face_swap_api(
                     )
             
                     # -------------------------------------------------
-                    # STEP 3: Push subCategory if missing
+                    # STEP 4: Push subCategory if missing
                     # -------------------------------------------------
                     if update_result.matched_count == 0:
                         await media_clicks_col.update_one(
@@ -387,7 +507,7 @@ async def face_swap_api(
                         )
             
                     logger.info(
-                        "[MEDIA_CLICK] user=%s subCategory=%s ai_edit_complete++",
+                        "[MEDIA_CLICK] user=%s subCategory=%s ai_edit_complete++ daily_tracked",
                         user_id,
                         str(subcategory_oid)
                     )
@@ -395,53 +515,6 @@ async def face_swap_api(
                 except Exception as media_err:
                     logger.error(f"MEDIA_CLICK ERROR: {media_err}")
 
-
-
-
-        
-            # if user_id:
-            #     try:
-            #         user_oid = ObjectId(user_id.strip())
-            #         now = datetime.utcnow()
-
-            #         # 1) 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
-            #                 }
-            #             }
-            #         )
-
-            #         # 2) If no subCategory exists → push new one (or create doc)
-            #         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)
 #         # ------------------------------------------------------------------
@@ -484,10 +557,9 @@ async def face_swap_api(
                 # Replicate the old indexing logic based on sorted filenames
                 for idx, filename in enumerate(original_filenames, start=1):
                     cid = f"{category.lower()}image_{idx}"
-                    
+
                     # Optional: Replicate the thumb file check for 100% parity
                     # if filename in thumb_filenames and cid == target_category_id:
-                    
                     # Simpler check just on the ID, assuming thumb files are present
                     if cid == target_category_id:
                         # Construct the final target URL using the full prefix and the filename
@@ -500,7 +572,6 @@ async def face_swap_api(
 
             if not target_url:
                 raise HTTPException(404, "Target categoryId not found")
-
 #         # ------------------------------------------------------------------
 #         # DOWNLOAD TARGET IMAGE
 #         # ------------------------------------------------------------------
@@ -544,7 +615,6 @@ async def face_swap_api(
             "result_url": result_url
         }
         
-
     except Exception as e:
         end_time = datetime.utcnow()
         response_time_ms = (end_time - start_time).total_seconds() * 1000
@@ -560,108 +630,6 @@ async def face_swap_api(
 
         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)}")
-
-
-
 @fastapi_app.get("/preview/{result_key:path}")
 async def preview_result(result_key: str):
     try: