job del

dependencies.py

@@ -231,6 +231,30 @@ async def verify_credits(
     return user
 
 
+async def verify_video_credits(
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+) -> User:
+    """
+    Verify user has credits for video generation (10 credits) and deduct them.
+    """
+    cost = 10
+    if user.credits < cost:
+        raise HTTPException(
+            status_code=status.HTTP_402_PAYMENT_REQUIRED,
+            detail=f"Insufficient credits. Video generation requires {cost} credits."
+        )
+    
+    # Deduct credits
+    user.credits -= cost
+    user.last_used_at = datetime.utcnow()
+    await db.commit()
+    
+    logger.debug(f"Deducted {cost} credits from user {user.user_id} for video generation. Remaining: {user.credits}")
+    
+    return user
+
+
 async def get_geolocation(ip_address: str) -> Tuple[Optional[str], Optional[str]]:
     """
     Get country and region for an IP address using ip-api.com.

routers/gemini.py

@@ -15,7 +15,7 @@ from sqlalchemy import select, func
 from core.database import get_db
 from core.models import User, GeminiJob
 from services.gemini_service import MODELS, DOWNLOADS_DIR
-from dependencies import verify_credits, get_current_user
+from dependencies import verify_credits, verify_video_credits, get_current_user
 from datetime import datetime
 
 router = APIRouter(prefix="/gemini", tags=["gemini"])
@@ -72,7 +72,8 @@ async def create_job(
     db: AsyncSession,
     user: User,
     job_type: str,
-    input_data: dict
+    input_data: dict,
+    credits_reserved: int = 0
 ) -> GeminiJob:
     """Create a new job in the queue with auto-assigned priority."""
     from services.gemini_job_worker import get_priority_for_job_type, get_pool
@@ -87,7 +88,7 @@ async def create_job(
         status="queued",
         priority=priority,
         input_data=input_data,
-        credits_reserved=1  # Track that 1 credit is reserved for this job
+        credits_reserved=credits_reserved  # Track reserved credits for this job
     )
     db.add(job)
     await db.commit()
@@ -116,7 +117,8 @@ async def generate_animation_prompt(
             "base64_image": request.base64_image,
             "mime_type": request.mime_type,
             "custom_prompt": request.custom_prompt
-        }
+        },
+        credits_reserved=1
     )
     
     position = await get_queue_position(db, job.job_id)
@@ -147,7 +149,8 @@ async def edit_image(
             "base64_image": request.base64_image,
             "mime_type": request.mime_type,
             "prompt": request.prompt
-        }
+        },
+        credits_reserved=1
     )
     
     position = await get_queue_position(db, job.job_id)
@@ -164,7 +167,7 @@ async def edit_image(
 @router.post("/generate-video")
 async def generate_video(
     request: GenerateVideoRequest,
-    user: User = Depends(verify_credits),
+    user: User = Depends(verify_video_credits),
     db: AsyncSession = Depends(get_db)
 ):
     """
@@ -181,7 +184,8 @@ async def generate_video(
             "aspect_ratio": request.aspect_ratio,
             "resolution": request.resolution,
             "number_of_videos": request.number_of_videos
-        }
+        },
+        credits_reserved=10  # Video jobs cost 10 credits
     )
     
     position = await get_queue_position(db, job.job_id)
@@ -211,7 +215,8 @@ async def generate_text(
         input_data={
             "prompt": request.prompt,
             "model": request.model
-        }
+        },
+        credits_reserved=1
     )
     
     position = await get_queue_position(db, job.job_id)
@@ -242,7 +247,8 @@ async def analyze_image(
             "base64_image": request.base64_image,
             "mime_type": request.mime_type,
             "prompt": request.prompt
-        }
+        },
+        credits_reserved=1
     )
     
     position = await get_queue_position(db, job.job_id)
@@ -433,6 +439,10 @@ async def download_video(
                         yield chunk
         except httpx.HTTPStatusError as e:
             if e.response.status_code in (401, 403, 404, 410):
+                # Mark job as expired
+                job.status = "expired"
+                await db.commit()
+                
                 raise HTTPException(
                     status_code=status.HTTP_410_GONE,
                     detail="Video URL has expired. Please generate a new video."
@@ -498,6 +508,63 @@ async def cancel_job(
     }
 
 
+@router.delete("/job/{job_id}")
+async def delete_job(
+    job_id: str,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    Delete a job.
+    - If queued: Refund 8 credits (10 cost - 2 penalty), delete job.
+    - If processing/completed/failed: Delete job (no refund).
+    """
+    query = select(GeminiJob).where(
+        GeminiJob.job_id == job_id,
+        GeminiJob.user_id == user.user_id
+    )
+    result = await db.execute(query)
+    job = result.scalar_one_or_none()
+    
+    if not job:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Job not found"
+        )
+    
+    refund_amount = 0
+    message = "Job deleted"
+    
+    if job.status == "queued":
+        # Refund logic: Restore 8 credits (10 - 2)
+        # Only if it was a video job (cost 10). For others (cost 1), maybe no refund or full?
+        # Requirement says "restore 8", implying video job context.
+        # Let's check credits_reserved. If 10, refund 8. If 1, refund 0? Or 1?
+        # Assuming this logic is specific to the high-cost video jobs.
+        
+        if job.credits_reserved >= 10:
+            refund_amount = 8
+            user.credits += refund_amount
+            message = f"Job deleted. {refund_amount} credits refunded."
+        elif job.credits_reserved > 0:
+             # For lower cost jobs, maybe full refund if queued? Or partial?
+             # User specifically mentioned "restore 8" for the queued state.
+             # I'll stick to the specific requirement for now, but maybe refund full for 1-credit jobs?
+             # Let's assume strict "restore 8" applies to the 10-credit video jobs.
+             pass
+             
+    await db.delete(job)
+    await db.commit()
+    
+    return {
+        "success": True,
+        "job_id": job_id,
+        "message": message,
+        "credits_refunded": refund_amount,
+        "credits_remaining": user.credits
+    }
+
+
 @router.get("/models")
 async def get_models():
     """

tests/test_job_lifecycle.py

@@ -0,0 +1,90 @@
+import asyncio
+import os
+import sys
+from datetime import datetime
+
+# Add project root to path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from sqlalchemy.orm import sessionmaker
+from core.models import User, GeminiJob
+from core.database import DATABASE_URL
+
+async def test_lifecycle():
+    engine = create_async_engine(DATABASE_URL)
+    async_session = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+
+    async with async_session() as session:
+        # 1. Setup User
+        user_id = "test_user_lifecycle"
+        user = User(user_id=user_id, email="test_lifecycle@example.com", credits=100)
+        session.add(user)
+        await session.commit()
+        print(f"Created user with {user.credits} credits")
+
+        # 2. Simulate Video Job Creation (Cost 10)
+        # We simulate the API logic manually since we can't easily call the API here without a running server
+        # But we can verify the logic we implemented in the router
+        
+        # Deduct 10 credits
+        user.credits -= 10
+        await session.commit()
+        print(f"Deducted 10 credits. Remaining: {user.credits}")
+        assert user.credits == 90
+
+        # Create Job
+        job = GeminiJob(
+            job_id="job_test_video",
+            user_id=user_id,
+            job_type="video",
+            status="queued",
+            credits_reserved=10
+        )
+        session.add(job)
+        await session.commit()
+        print("Created queued video job")
+
+        # 3. Simulate Delete Queued Job (Refund 8)
+        # Logic from router:
+        if job.status == "queued" and job.credits_reserved >= 10:
+            refund = 8
+            user.credits += refund
+            print(f"Refunded {refund} credits")
+        
+        await session.delete(job)
+        await session.commit()
+        print(f"Deleted job. User credits: {user.credits}")
+        assert user.credits == 98  # 90 + 8
+
+        # 4. Simulate Processing Job Deletion (No Refund)
+        # Deduct 10 again
+        user.credits -= 10
+        job2 = GeminiJob(
+            job_id="job_test_processing",
+            user_id=user_id,
+            job_type="video",
+            status="processing",
+            credits_reserved=10
+        )
+        session.add(job2)
+        await session.commit()
+        print(f"Created processing job. User credits: {user.credits}") # 88
+
+        # Delete
+        if job2.status == "queued" and job2.credits_reserved >= 10:
+            refund = 8
+            user.credits += refund
+        
+        await session.delete(job2)
+        await session.commit()
+        print(f"Deleted processing job. User credits: {user.credits}")
+        assert user.credits == 88 # No change
+
+        # Cleanup
+        await session.delete(user)
+        await session.commit()
+        print("Test cleanup complete")
+
+if __name__ == "__main__":
+    asyncio.run(test_lifecycle())