verify

routers/payments.py

@@ -122,6 +122,86 @@ def generate_transaction_id() -> str:
     return f"txn_{uuid.uuid4().hex[:16]}"
 
 
+def update_verified_by(transaction: PaymentTransaction, source: str) -> bool:
+    """
+    Update the verified_by field based on the verification source.
+    
+    Args:
+        transaction: The payment transaction to update
+        source: Either "client" or "webhook"
+    
+    Returns:
+        True if the value was changed, False otherwise
+    """
+    current = transaction.verified_by
+    other = "webhook" if source == "client" else "client"
+    
+    if current == other:
+        # Already verified by the other source, mark as "both"
+        transaction.verified_by = "both"
+        return True
+    elif current is None or current == source:
+        # First verification or same source
+        transaction.verified_by = source
+        return current != source
+    # Already "both" or same value - no change needed
+    return False
+
+
+async def process_successful_payment(
+    transaction: PaymentTransaction,
+    user: User,
+    payment_id: str,
+    source: str,
+    db: AsyncSession,
+    signature: Optional[str] = None
+) -> int:
+    """
+    Process a successful payment - update transaction and add credits.
+    
+    Args:
+        transaction: The payment transaction
+        user: The user to credit
+        payment_id: Gateway payment ID
+        source: "client" or "webhook"
+        db: Database session
+        signature: Optional Razorpay signature (client-side only)
+    
+    Returns:
+        Number of credits added (0 if already processed)
+    """
+    credits_added = 0
+    
+    if transaction.status != "paid":
+        # First time processing - add credits
+        transaction.status = "paid"
+        transaction.gateway_payment_id = payment_id
+        transaction.paid_at = datetime.utcnow()
+        if signature:
+            transaction.razorpay_signature = signature
+        
+        update_verified_by(transaction, source)
+        
+        user.credits += transaction.credits_amount
+        credits_added = transaction.credits_amount
+        
+        logger.info(
+            f"Payment processed ({source}): {transaction.transaction_id}, "
+            f"added {credits_added} credits to user {user.user_id}, "
+            f"new balance: {user.credits}"
+        )
+    else:
+        # Already paid - just update verified_by if needed
+        if update_verified_by(transaction, source):
+            logger.info(
+                f"Payment {transaction.transaction_id} was already verified, "
+                f"{source} also verified - marked as '{transaction.verified_by}'"
+            )
+    
+    await db.commit()
+    return credits_added
+
+
 # =============================================================================
 # Endpoints
 # =============================================================================
@@ -261,16 +341,10 @@ async def verify_payment(
                 detail="Transaction not found"
             )
         
-        # Check if already processed
+        # Check if already processed - still track verification source
         if transaction.status == "paid":
-            # Still update verified_by to track that client also called verify
-            if transaction.verified_by == "webhook":
-                transaction.verified_by = "both"
-                await db.commit()
-                logger.info(
-                    f"Payment {transaction.transaction_id} was already verified by webhook, "
-                    f"client also verified - marked as 'both'"
-                )
+            update_verified_by(transaction, "client")
+            await db.commit()
             
             return VerifyPaymentResponse(
                 success=True,
@@ -301,34 +375,21 @@ async def verify_payment(
                 detail="Payment verification failed"
             )
         
-        # Update transaction
-        transaction.status = "paid"
-        transaction.gateway_payment_id = request.razorpay_payment_id
-        transaction.razorpay_signature = request.razorpay_signature
-        transaction.paid_at = datetime.utcnow()
-        
-        # Track who verified - if webhook already set it, mark as "both"
-        if transaction.verified_by == "webhook":
-            transaction.verified_by = "both"
-        else:
-            transaction.verified_by = "client"
-        
-        # Add credits to user
-        user.credits += transaction.credits_amount
-        
-        await db.commit()
-        
-        logger.info(
-            f"Payment verified: {transaction.transaction_id}, "
-            f"added {transaction.credits_amount} credits to user {user.user_id}, "
-            f"new balance: {user.credits}"
+        # Process the payment using helper function
+        credits_added = await process_successful_payment(
+            transaction=transaction,
+            user=user,
+            payment_id=request.razorpay_payment_id,
+            source="client",
+            db=db,
+            signature=request.razorpay_signature
         )
         
         return VerifyPaymentResponse(
             success=True,
             message="Payment successful! Credits added.",
             transaction_id=transaction.transaction_id,
-            credits_added=transaction.credits_amount,
+            credits_added=credits_added,
             new_balance=user.credits
         )
         
@@ -398,41 +459,21 @@ async def razorpay_webhook(
                 )
                 transaction = result.scalar_one_or_none()
                 
-                if transaction and transaction.status != "paid":
-                    # Update transaction
-                    transaction.status = "paid"
-                    transaction.gateway_payment_id = payment_id
-                    transaction.paid_at = datetime.utcnow()
-                    
-                    # Track who verified - if client already set it, mark as "both"
-                    if transaction.verified_by == "client":
-                        transaction.verified_by = "both"
-                    else:
-                        transaction.verified_by = "webhook"
-                    
-                    # Find user and add credits
+                if transaction:
+                    # Find user
                     user_result = await db.execute(
                         select(User).where(User.user_id == transaction.user_id)
                     )
                     user = user_result.scalar_one_or_none()
                     
                     if user:
-                        user.credits += transaction.credits_amount
-                        logger.info(
-                            f"Webhook: Added {transaction.credits_amount} credits "
-                            f"to user {user.user_id} for transaction {transaction.transaction_id}"
-                        )
-                    
-                    await db.commit()
-                
-                elif transaction and transaction.status == "paid":
-                    # Transaction already paid by client - update verified_by to "both"
-                    if transaction.verified_by == "client":
-                        transaction.verified_by = "both"
-                        await db.commit()
-                        logger.info(
-                            f"Webhook: Transaction {transaction.transaction_id} was already "
-                            f"verified by client - marked as 'both'"
+                        # Process payment using helper function
+                        await process_successful_payment(
+                            transaction=transaction,
+                            user=user,
+                            payment_id=payment_id,
+                            source="webhook",
+                            db=db
                         )
         
         # Handle payment failed event