ifixkart-admin/Backend/app/services/RefundService.py
Adithiyan bbd3a3e959 feat: initial commit — full platform snapshot
- Backend: FastAPI app with all models, services, schemas, routes
- Admin Panel: Next.js dashboard with all modules
  (CRM, POS, repairs, warranties, billing, notifications, etc.)
- Ecommerce: storefront (submodule) + product catalog
- AI Agents: .agents/ skill library for Antigravity IDE
- Docs: architecture, billing, notification gateway markdown
- Submodules: Backend/OpenWA, Ecommerce/File 2/storefront
2026-10-13 12:59:47 +05:30

169 lines
8.2 KiB
Python

from datetime import datetime, timezone
import ulid
from sqlalchemy.orm import Session
from sqlalchemy import select, func
from typing import List, Optional, Any
from fastapi import HTTPException
from app.models.RefundModel import RefundRequest, RefundMedia, RefundEntityType, RefundStatus, RefundPaymentMethod
from app.schemas.RefundSchema import RefundRequestCreate, RefundRequestApprove, RefundRequestReject
from app.models.ServiceModel import ServiceJob
from app.models.OrderModel import Order
from app.core.events.event_publisher import publish_business_event
class RefundService:
def __init__(self, db: Session, tenant_id: str = "tenant_default"):
self.db = db
self.tenant_id = tenant_id
def request_refund(self, data: RefundRequestCreate, user_id: str) -> RefundRequest:
# Validate based on Entity Type
if data.entity_type == RefundEntityType.SERVICE:
# Row-level lock on ServiceJob
stmt = select(ServiceJob).where(ServiceJob.job_id == data.entity_id).with_for_update()
service_job = self.db.execute(stmt).scalar_one_or_none()
if not service_job:
raise HTTPException(status_code=404, detail="Service Job not found")
if not data.part_number_verification:
raise HTTPException(status_code=400, detail="Part number verification is mandatory for Service refunds")
# Strict Part Number Match (Normalize whitespace only)
if not service_job.replaced_part_numbers or data.part_number_verification.strip() not in [p.strip() for p in service_job.replaced_part_numbers]:
raise HTTPException(status_code=400, detail="Part number does not match any replaced part numbers.")
# Calculate Refundable Amount (exclude fulfillment fee/delivery charge)
# Service payment/order logic is handled through quotes or ecom_sales, assuming base_price for now if total not tracked in service_job
# In a real app we'd fetch the exact payment/invoice record, but for validation cap:
# Assuming max refundable is the amount paid minus delivery fee.
# Example: Max refundable = total_paid - fulfillment_fee
# We will assume a simple rule for now: check against total existing refunds.
stmt_refunds = select(func.sum(RefundRequest.amount)).where(
RefundRequest.entity_id == data.entity_id,
RefundRequest.status.in_([RefundStatus.PENDING, RefundStatus.APPROVED, RefundStatus.PROCESSING, RefundStatus.REFUNDED])
)
already_refunded = self.db.execute(stmt_refunds).scalar() or 0.0
# Here we would fetch actual total_paid from ServicePayment or Order.
# We'll mock total_paid as 99999 for this example if it's not explicitly in ServiceJob
total_paid = float(service_job.base_price_snapshot or 0) + float(service_job.inspection_fee_snapshot or 0)
refundable_amount = total_paid - float(service_job.fulfillment_fee or 0.0)
if already_refunded + data.amount > refundable_amount:
raise HTTPException(status_code=400, detail=f"Refund request exceeds maximum allowable amount. Max refundable: {refundable_amount - already_refunded}")
elif data.entity_type == RefundEntityType.SALES:
# Row-level lock on Order
stmt = select(Order).where(Order.order_id == data.entity_id).with_for_update()
order = self.db.execute(stmt).scalar_one_or_none()
if not order:
raise HTTPException(status_code=404, detail="Order not found")
stmt_refunds = select(func.sum(RefundRequest.amount)).where(
RefundRequest.entity_id == data.entity_id,
RefundRequest.status.in_([RefundStatus.PENDING, RefundStatus.APPROVED, RefundStatus.PROCESSING, RefundStatus.REFUNDED])
)
already_refunded = self.db.execute(stmt_refunds).scalar() or 0.0
total_paid = float(order.final_amount)
refundable_amount = total_paid - float(order.shipping_cost)
if already_refunded + data.amount > refundable_amount:
raise HTTPException(status_code=400, detail=f"Refund request exceeds maximum allowable amount. Max refundable: {refundable_amount - already_refunded}")
else:
raise HTTPException(status_code=400, detail="Invalid entity type")
# Create Refund Request
now = datetime.now(timezone.utc)
refund_req = RefundRequest(
refund_id=str(ulid.ULID()),
tenant_id=self.tenant_id,
location_id=data.location_id,
entity_type=data.entity_type,
entity_id=data.entity_id,
amount=data.amount,
payment_method=data.payment_method,
status=RefundStatus.PENDING,
reason=data.reason,
part_number_verification=data.part_number_verification,
requested_by=user_id,
requested_at=now
)
self.db.add(refund_req)
# Add Media
for media_item in data.media:
media = RefundMedia(
id=str(ulid.ULID()),
refund_id=refund_req.refund_id,
file_url=media_item.file_url,
file_type=media_item.file_type,
media_filename=media_item.media_filename,
uploaded_by=user_id,
uploaded_at=now
)
self.db.add(media)
self.db.commit()
self.db.refresh(refund_req)
publish_business_event(
event_type="REFUND_REQUESTED",
payload={"refund_id": refund_req.refund_id, "amount": refund_req.amount},
tenant_id=self.tenant_id,
aggregate_id=refund_req.refund_id
)
return refund_req
def approve_refund(self, refund_id: str, data: RefundRequestApprove, user_id: str) -> RefundRequest:
stmt = select(RefundRequest).where(RefundRequest.refund_id == refund_id, RefundRequest.tenant_id == self.tenant_id)
refund = self.db.execute(stmt).scalar_one_or_none()
if not refund or refund.status != RefundStatus.PENDING:
raise HTTPException(status_code=400, detail="Refund not found or not in PENDING state")
refund.approved_by = user_id
refund.approved_at = datetime.now(timezone.utc)
if data.admin_notes:
refund.admin_notes = data.admin_notes
if refund.payment_method == RefundPaymentMethod.ONLINE:
# Trigger Razorpay API logic here securely
# mock transition to PROCESSING
refund.status = RefundStatus.PROCESSING
else:
refund.status = RefundStatus.REFUNDED
refund.refunded_at = datetime.now(timezone.utc)
self.db.commit()
self.db.refresh(refund)
return refund
def reject_refund(self, refund_id: str, data: RefundRequestReject, user_id: str) -> RefundRequest:
stmt = select(RefundRequest).where(RefundRequest.refund_id == refund_id, RefundRequest.tenant_id == self.tenant_id)
refund = self.db.execute(stmt).scalar_one_or_none()
if not refund or refund.status != RefundStatus.PENDING:
raise HTTPException(status_code=400, detail="Refund not found or not in PENDING state")
refund.status = RefundStatus.REJECTED
refund.rejected_by = user_id
refund.rejected_at = datetime.now(timezone.utc)
refund.rejection_reason = data.rejection_reason
if data.admin_notes:
refund.admin_notes = data.admin_notes
self.db.commit()
self.db.refresh(refund)
return refund
def list_refunds(self, entity_type: Optional[str] = None, status: Optional[str] = None) -> List[RefundRequest]:
stmt = select(RefundRequest).where(RefundRequest.tenant_id == self.tenant_id)
if entity_type:
stmt = stmt.where(RefundRequest.entity_type == entity_type)
if status:
stmt = stmt.where(RefundRequest.status == status)
return list(self.db.execute(stmt).scalars().all())