Refund Logic Implementation

.gitignore

@@ -3,4 +3,5 @@
 __pycache__/
 .env
 .DS_Store
-secrets/
+secrets/
+test.html

app/app.py

@@ -62,8 +62,8 @@
         "capacitor://localhost",
         "http://localhost:3000",
         "http://127.0.0.1:3000",
-        "http://localhost:5000",
-        "http://127.0.0.1:5000",
+        "http://localhost:5500",
+        "http://127.0.0.1:5500",
         "http://10.0.2.2:3000",
         "http://10.0.2.2:5000",
         "http://10.0.2.2:8000",

app/user.py

@@ -17,7 +17,7 @@
 
 async def get_user_details(id_token: str):
   try:
     decoded_token = auth.verify_id_token(id_token)
     uid = decoded_token["uid"]
 
     user_doc = db.collection("users").document(uid).get()
@@ -36,7 +36,7 @@
     return data
 
 async def update_user_profile(profile_data: UpdateUserProfileSchema, id_token: str):
   try:
     user_data, user_uid = await get_user_details(id_token)
 
     if not user_data:
@@ -48,7 +48,7 @@
 
     if profile_data.name is not None:
        updates["name"] = profile_data.name.strip()
 
     if profile_data.roll_number is not None:
        updates["roll_number"] = profile_data.roll_number.strip()
 
@@ -98,6 +98,14 @@
                 content={"message": "Order not found"}
             )
 
+        current_status = order_doc.to_dict().get("status")
+
+        if current_status == "PAID":
+          return JSONResponse(
+            status_code=200,
+            content={"message": "Payment already verified"}
+          )
+
         pickup_code = str(1000 + secrets.randbelow(9000))
 
         order_ref.update({
@@ -105,7 +113,7 @@
             "status": "PAID",
           "pickup_code": pickup_code,
             "updated_at": firestore.SERVER_TIMESTAMP
         })
 
         return JSONResponse(
             status_code=200,
@@ -175,7 +183,7 @@
         return JSONResponse(
             status_code=status.HTTP_200_OK,
             content={
                 "college_id": college_id,
                 "stalls": stalls_response
             }
         )
@@ -211,20 +219,20 @@
     stall_doc = db.collection("colleges").document(college_id).collection("stalls").document(stall_id).get()
     stall_name = stall_doc.to_dict().get("name", "Unknown Stall")
 
     for cart_item in order_data.items:
       item_doc = menu_ref.document(cart_item.item_id).get()
 
       if item_doc.exists:
         item_data = item_doc.to_dict()
 
         if item_data.get('is_available') is False:
           return JSONResponse(
             status_code=status.HTTP_400_BAD_REQUEST,
             content={"message": f"Sorry, {item_data.get('name')} is currently out of stock."}
           )
 
         price = item_data.get('price', 0)
         quantity = cart_item.quantity
         total_amount += price * quantity
 
         order_items.append({
@@ -249,7 +257,7 @@
     user_snapshot = {
       "name": user_data.get("name", "Unknown Student"),
       "roll_number": user_data.get("roll_number", "N/A"),
       "phone": user_data.get("phone", "")
     }
 
     new_order_ref = db.collection('orders').document()
@@ -260,23 +268,31 @@
       "user_details": user_snapshot,
       "stall_id": stall_id,
       "stall_name": stall_name,
+      "refund_policy": {
+        "ready_refund_percent": 50,
+        "cancellation_allowed": True
+      },
+      "refund": {
+        "status": "NOT_APPLICABLE",
+        "amount": 0
+      },
       "college_id": college_id,
       "items": order_items,
       "total_amount": total_amount,
       "status": "PENDING",
       "created_at": firestore.SERVER_TIMESTAMP,
       "updated_at": firestore.SERVER_TIMESTAMP
     }
 
     new_order_ref.set(firestore_order_data)
 
     data = {
       "amount": int(total_amount * 100),
       "currency": "INR",
       "receipt": f"rcpt_{internal_order_id[:8]}",
       "notes": {
         "stall_id": stall_id,
         "user_uid": user_uid,
         "college_id": college_id,
         "internal_order_id": internal_order_id
       }
@@ -293,7 +309,7 @@
         "amount": order['amount'],
         "currency": order['currency'],
         "key_id": os.environ.get("RAZORPAY_KEY_ID"),
         "internal_order_id": internal_order_id,
         "message": "Order created successfully"
       }
     )
@@ -303,21 +319,21 @@
       status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
       content={"message": f"Payment Error: {str(e)}"}
     )
 
 async def get_user_orders(id_token: str):
   try:
     user_data, user_uid = await get_user_details(id_token)
     if not user_data:
       return JSONResponse(
         status_code=status.HTTP_401_UNAUTHORIZED,
         content={"message": "Invalid or expired token."}
       )
 
     docs = (
        db.collection("orders")
        .where("user_id","==",user_uid)
        .order_by("created_at",direction=firestore.Query.DESCENDING)
        .stream()
     )
 
     orders = []
@@ -326,13 +342,19 @@
 
       visible_code = data.get("pickup_code") if data.get("status") in ["PAID", "READY"] else None
 
+      refund_data = data.get("refund")
+      if refund_data:
+        refund_data = serialize_firestore_data(refund_data)
+
       orders.append({
          "id": doc.id,
          "items": data["items"],
          "cafeteriaName": data.get("stall_name", "Unknown Stall"),
          "status": normalize_order_status(data["status"]),
          "qrCode": visible_code,
-        "total_amount": data.get("total_amount", 0)
+        "total_amount": data.get("total_amount", 0),
+        "refund": refund_data,
+        "refund_policy": data.get("refund_policy")
       })
 
     return JSONResponse(
@@ -347,86 +369,140 @@
     )
 
 def normalize_order_status(status:str):
-   return{
-      "PENDING": "Payment Pending",
-      "PAID": "Reserved",
-      "CLAIMED": "Claimed",
-      "READY": "Ready",
-      "COMPLETED": "Completed"
-   }.get(status,"Unknown")
+  status = status.upper() if status else ""
+  return {
+    "PENDING": "Payment Pending",
+    "PAID": "Reserved",
+    "CLAIMED": "Claimed",
+    "READY": "Ready",
+    "COMPLETED": "Completed",
+    "CANCELLED": "Cancelled"
+  }.get(status, "Unknown")
+
+def calculate_refund(order: dict):
+  total = order.get("total_amount", 0)
+  status = order.get("status")
+
+  if status in ["CREATED"]:
+    return total, "FULL_REFUND"
+
+  if status == "PAID":
+    return total, "FULL_REFUND"
+
+  if status == "READY":
+    percent = (
+      order.get("refund_policy", {})
+      .get("ready_refund_percent", 50)
+    )
+    refund_amount = int(total * percent / 100)
+    return refund_amount, "PARTIAL_REFUND"
+
+  return 0, "NO_REFUND"
 
 async def cancel_order(order_id: str, id_token: str):
   try:
     user_data, user_uid = await get_user_details(id_token)
+
     if not user_data:
-      return JSONResponse(status_code=status.HTTP_401_UNAUTHORIZED, content={"message": "Unauthorized"})
+      return JSONResponse(status_code=401, content={"message": "Unauthorized"})
 
-    now = datetime.now()
+    now = datetime.utcnow().replace(tzinfo=None)
 
     week_start = user_data.get("cancellation_week_start")
     current_count = user_data.get("cancellations_this_week", 0)
 
     if week_start:
       if isinstance(week_start, str):
         week_start = datetime.fromisoformat(week_start)
+      if hasattr(week_start, "tzinfo") and week_start.tzinfo:
+        week_start = week_start.replace(tzinfo=None)
     else:
       week_start = now
 
-    if (now.replace(tzinfo=None) - week_start.replace(tzinfo=None)).days >= 7:
+    if (now - week_start).days >= 7:
       current_count = 0
       week_start = now
-      db.collection("users").document(user_uid).update({
-        "cancellation_week_start": firestore.SERVER_TIMESTAMP,
-        "cancellations_this_week": 0
-      })
 
-    if current_count >= 2:
+    if current_count >= 3:
       return JSONResponse(
-        status_code=status.HTTP_400_BAD_REQUEST,
-        content={"message": "Cancellation limit reached. You can only cancel 2 orders per week."}
+        status_code=400,
+        content={"message": "Weekly cancellation limit reached"}
       )
 
-    order_ref = db.collection("orders").document(order_id)
-    order_doc = order_ref.get()
+    order_doc = db.collection("orders").document(order_id).get()
 
     if not order_doc.exists:
       return JSONResponse(status_code=404, content={"message": "Order not found"})
 
+    order_ref = order_doc.reference
     order_data = order_doc.to_dict()
 
     if order_data.get("user_id") != user_uid:
       return JSONResponse(status_code=403, content={"message": "You do not own this order"})
 
     current_status = order_data.get("status")
 
-    if current_status in ["CLAIMED", "COMPLETED", "CANCELLED"]:
+    if current_status == "CANCELLED":
+      refund = order_data.get("refund", {})
+      return JSONResponse(
+        status_code=200,
+        content={
+          "message": "Order already cancelled",
+          "refund_amount": refund.get("amount", 0),
+          "refund_type": refund.get("type"),
+          "resale_created": False
+        }
+      )
+
+    if current_status in ["CLAIMED", "COMPLETED"]:
       return JSONResponse(
         status_code=400,
-        content={"message": f"Cannot cancel order with status: {current_status}"}
+        content={"message": f"Cannot cancel order with status {current_status}"}
       )
 
-    resale_created = False
+    refund_amount, refund_type = calculate_refund(order_data)
+    total_amount = order_data.get("total_amount", 0)
+    payment_id = order_data.get("razorpay_payment_id")
+
+    existing_refund = order_data.get("refund", {})
+
+    refund_status = existing_refund.get("status", "NOT_APPLICABLE")
+    refund_id = existing_refund.get("razorpay_refund_id")
+
+    if refund_amount > 0 and payment_id and refund_status not in ["INITIATED", "COMPLETED"]:
+      try:
+        refund_response = razorpay_client.payment.refund(
+          payment_id,
+          {
+            "amount": int(refund_amount * 100),
+            "speed": "normal",
+            "notes": {
+              "order_id": order_id,
+              "type": refund_type,
+              "reason": "User Cancelled"
+            }
+          }
+        )
+        refund_id = refund_response.get("id")
+        refund_status = "INITIATED"
+      except Exception as e:
+        print("[Refund Error]", e)
+        refund_status = "FAILED"
 
+    resale_created = False
     if current_status == "READY":
-      college_id = order_data.get("college_id")
-      stall_id = order_data.get("stall_id")
-      original_price = order_data.get("total_amount", 0)
-
-      discounted_price = original_price * 0.5
-
       resale_item = {
         "original_order_id": order_id,
         "original_user_id": user_uid,
-        "college_id": college_id,
-        "stall_id": stall_id,
+        "college_id": order_data.get("college_id"),
+        "stall_id": order_data.get("stall_id"),
         "stall_name": order_data.get("stall_name"),
         "items": order_data.get("items", []),
-        "original_price": original_price,
-        "discounted_price": discounted_price,
+        "original_price": total_amount,
+        "discounted_price": int(total_amount * 0.5),
         "status": "AVAILABLE",
         "created_at": firestore.SERVER_TIMESTAMP
       }
-
       db.collection("resale_items").add(resale_item)
       resale_created = True
 
@@ -435,25 +511,46 @@
     batch.update(order_ref, {
       "status": "CANCELLED",
       "cancelled_at": firestore.SERVER_TIMESTAMP,
-      "cancellation_reason": "User requested"
+      "refund": {
+        "eligible": refund_amount > 0,
+        "amount": refund_amount,
+        "type": refund_type,
+        "status": refund_status,
+        "razorpay_refund_id": refund_id
+      },
+      "staff_payout": {
+        "amount": total_amount - refund_amount,
+        "status": "PENDING"
+      },
+      "updated_at": firestore.SERVER_TIMESTAMP
     })
 
-    user_ref = db.collection("users").document(user_uid)
-    batch.update(user_ref, {
-      "cancellations_this_week": current_count + 1,
-      "cancellation_week_start": week_start
-    })
+    batch.update(
+      db.collection("users").document(user_uid),
+      {
+        "cancellations_this_week": current_count + 1,
+        "cancellation_week_start": week_start
+      }
+    )
 
     batch.commit()
 
-    msg = "Order cancelled."
-    if resale_created:
-      msg += " Item has been added to the discounted feed."
-
-    return JSONResponse(status_code=200, content={"message": msg, "resale_created": resale_created})
+    return JSONResponse(
+      status_code=200,
+      content={
+        "message": f"Order cancelled. Refund status: {refund_status}",
+        "refund_amount": refund_amount,
+        "refund_type": refund_type,
+        "resale_created": resale_created
+      }
+    )
 
   except Exception as e:
-    return JSONResponse(status_code=500, content={"message": str(e)})
+    print("[Cancel Order Error]", repr(e))
+    return JSONResponse(
+      status_code=500,
+      content={"message": "Internal server error"}
+    )
 
 async def buy_resale_item(resale_id: str, id_token: str):
   try:
@@ -465,7 +562,7 @@
 
     if resale_ref.get("original_user_id") == user_uid:
       raise Exception("You cannot purchase your own cancelled order.")
 
     transaction = db.transaction()
 
     @firestore.transactional

app/webhook.py

@@ -16,7 +16,10 @@
   secret = os.environ.get("RAZORPAY_WEBHOOK_SECRET")
   body = await request.body()
 
   try:
+    if not secret:
+      raise Exception("RAZORPAY_WEBHOOK_SECRET not set")
+
     expected_signature = hmac.new(
       key=secret.encode(),
       msg=body,
@@ -25,7 +28,8 @@
 
     if not hmac.compare_digest(expected_signature, signature):
       raise HTTPException(status_code=400, detail="Invalid signature")
-  except Exception:
+  except Exception as e:
+    print(f"Webhook Signature Error: {e}")
     raise HTTPException(status_code=400, detail="Signature verification failed")
 
   payload = await request.json()
@@ -37,22 +41,22 @@
 
     internal_order_id = notes.get('internal_order_id')
     payment_id = payment.get('id')
 
     is_resale = notes.get('type') == 'RESALE'
     resale_item_id = notes.get('resale_item_id')
 
     if internal_order_id:
       order_ref = db.collection('orders').document(internal_order_id)
 
       transaction = db.transaction()
 
       @firestore.transactional
       def update_in_transaction(transaction, order_ref):
         snapshot = order_ref.get(transaction=transaction)
         if not snapshot.exists:
           print(f"❌ Order {internal_order_id} not found!")
           return
 
         current_data = snapshot.to_dict()
 
         if current_data.get("status") == "PAID":
@@ -87,4 +91,51 @@
     else:
       print(f"⚠️ Payment received without internal_order_id: {payment.get('id')}")
 
+  elif event_type == 'refund.processed':
+    try:
+      refund_entity = payload['payload']['refund']['entity']
+      payment_id = refund_entity.get('payment_id')
+
+      notes = refund_entity.get('notes', {})
+      order_id = notes.get('order_id')
+
+      if order_id:
+        order_ref = db.collection('orders').document(order_id)
+
+        snapshot = order_ref.get()
+        if snapshot.exists:
+          if snapshot.to_dict().get("refund", {}).get("status") == "COMPLETED":
+            print("ℹ️ Refund already completed, skipping")
+            return
+
+        order_ref.update({
+          "refund.status": "COMPLETED",
+          "refund.processed_at": firestore.SERVER_TIMESTAMP,
+          "refund.razorpay_refund_id": refund_entity.get('id'),
+          "refund.bank_ref": refund_entity.get('acquirer_data', {}).get('rrn'),
+          "updated_at": firestore.SERVER_TIMESTAMP
+        })
+        print(f"✅ REFUND COMPLETE: Order {order_id} refunded successfully.")
+      else:
+        print(f"⚠️ Refund processed but no order_id found in notes. Payment ID: {payment_id}")
+
+    except Exception as e:
+      print(f"❌ Error processing refund webhook: {e}")
+
+  elif event_type == 'refund.failed':
+    try:
+      refund_entity = payload['payload']['refund']['entity']
+      notes = refund_entity.get('notes', {})
+      order_id = notes.get('order_id')
+
+      if order_id:
+        db.collection('orders').document(order_id).update({
+          "refund.status": "FAILED",
+          "refund.failure_reason": refund_entity.get('status_details', {}).get('description', 'Unknown Error'),
+          "updated_at": firestore.SERVER_TIMESTAMP
+        })
+        print(f"❌ REFUND FAILED: Order {order_id}")
+    except Exception as e:
+      print(f"❌ Error handling refund failure: {e}")
+
   return {"status": "ok"}