import hmac from fastapi import APIRouter, Depends, HTTPException, Request, status from sqlalchemy.orm import Session from sqlalchemy import select from typing import Dict, Any from datetime import datetime, timedelta, timezone from app.core.database.db_session import get_db from app.core.config.Config import settings from app.core.permissions.RoleChecker import get_current_user from app.models.OrderModel import Order from app.models.WarrantyModel import Warranty from app.schemas.NotificationGateway import EntityNotificationDispatchCreate from app.models.ServiceModel import ServiceJob from app.core.events.notification_events import dispatch_internal_notification def verify_cron_access( request: Request, db: Session = Depends(get_db) ): """ Authenticate cron execution via X-Cron-Key header or Admin Bearer token. Prevents unauthorized external triggers of business logic and notifications. """ cron_key = request.headers.get("X-Cron-Key") or request.headers.get("X-CRON-KEY") if cron_key: if settings.SECRET_KEY and hmac.compare_digest(cron_key, settings.SECRET_KEY): return True if settings.PUBLIC_API_KEY and hmac.compare_digest(cron_key, settings.PUBLIC_API_KEY): return True raise HTTPException( status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid Cron authentication key" ) auth_header = request.headers.get("Authorization") if auth_header and auth_header.startswith("Bearer "): token = auth_header.split(" ")[1] user = get_current_user(request=request, token=token, db=db) if user and user.role and user.role.role_name.lower() in ["super admin", "superadmin", "admin"]: return True raise HTTPException( status_code=status.HTTP_403_FORBIDDEN, detail="Insufficient permissions to execute cron tasks" ) raise HTTPException( status_code=status.HTTP_401_UNAUTHORIZED, detail="Cron endpoint requires authentication (X-Cron-Key header or Admin Bearer token)" ) router = APIRouter( prefix="/api/v1/cron", tags=["Cron Scheduled Tasks"], dependencies=[Depends(verify_cron_access)] ) @router.post("/end-of-day-report") def trigger_end_of_day_report(db: Session = Depends(get_db)): """ Generate End of Day report and trigger END_OF_DAY_REPORT internal notification. Intended to be hit by an external cron job at closing time. """ # Calculate simple stats for today today = datetime.utcnow().date() start_of_day = datetime(today.year, today.month, today.day) # Orders today orders = db.execute(select(Order).where(Order.created_at >= start_of_day)).scalars().all() revenue_orders = sum(float(o.final_amount) for o in orders if o.payment_status in ["PAYMENT_CAPTURED", "PAID"]) # Service jobs completed today services_completed = db.execute( select(ServiceJob).where( ServiceJob.status.in_(["COMPLETED", "READY_FOR_DELIVERY", "DELIVERED"]), ServiceJob.updated_at >= start_of_day ) ).scalars().all() context = { "report_date": today.strftime("%Y-%m-%d"), "total_orders": len(orders), "order_revenue": f"₹{revenue_orders:.2f}", "services_completed": len(services_completed) } dispatch_internal_notification( "END_OF_DAY_REPORT", f"End of Day Report for {context['report_date']}: {len(orders)} orders (₹{revenue_orders:.2f}), {len(services_completed)} services completed.", context=context ) return {"message": "End of Day Report triggered successfully", "stats": context} @router.post("/repair-sla-breach") def check_repair_sla_breaches(db: Session = Depends(get_db)): """ Check for any service jobs that are breaching SLA (e.g., > 3 days open) Intended to be hit daily. """ threshold_date = datetime.utcnow() - timedelta(days=3) breaching_jobs = db.execute( select(ServiceJob).where( ServiceJob.status.not_in(["COMPLETED", "DELIVERED", "CLOSED", "READY_FOR_DELIVERY", "CANCELLED"]), ServiceJob.created_at <= threshold_date ) ).scalars().all() notified_count = 0 for job in breaching_jobs: days_open = (datetime.utcnow() - job.created_at).days dispatch_internal_notification( "REPAIR_SLA_BREACH", f"SLA Breach! Job {job.job_no} has been open for {days_open} days. Status: {job.status}", context={"job_no": job.job_no, "days_open": days_open, "status": job.status} ) notified_count += 1 return {"message": "SLA checks completed", "breaches_found": notified_count} @router.post("/warranty-expiration") def process_warranty_expiration(db: Session = Depends(get_db)): """ Check for warranties expiring in 7 days and send notifications. Also expire warranties whose end_date has passed. """ now = datetime.now(timezone.utc) warning_date = now + timedelta(days=7) # 1. Notification Sweep expiring_soon = db.execute( select(Warranty).where( Warranty.status == "ACTIVE", Warranty.end_date <= warning_date, Warranty.end_date > now, Warranty.expiry_notification_sent == False ) ).scalars().all() notified_count = 0 for warranty in expiring_soon: # We assume _dispatch_bg_notification can be used for WARRANTY_EXPIRING_SOON from app.api.v1.routers.AdminOrderRouter import _dispatch_bg_notification # Here we could enqueue it # For simplicity, we just dispatch internal or entity notification # The frontend will need a template for WARRANTY_EXPIRING_SOON dispatch_internal_notification( "WARRANTY_EXPIRING_SOON", f"Warranty {warranty.warranty_id} is expiring on {warranty.end_date.strftime('%Y-%m-%d')}", context={ "warranty_id": warranty.warranty_id, "reference_id": warranty.reference_id, "end_date": warranty.end_date.strftime("%Y-%m-%d") } ) warranty.expiry_notification_sent = True notified_count += 1 db.commit() # 2. Expiration Sweep expired_warranties = db.execute( select(Warranty).where( Warranty.status == "ACTIVE", Warranty.end_date <= now ) ).scalars().all() expired_count = 0 for warranty in expired_warranties: warranty.status = "EXPIRED" expired_count += 1 db.commit() return { "message": "Warranty expiration sweep completed", "notified": notified_count, "expired": expired_count } @router.post("/process-credit-maturity") def trigger_credit_maturity_sweep(db: Session = Depends(get_db)): """ Process pending store credits whose return/claim window has passed. Transitions verified PENDING credits to MATURED active balance. """ from app.services.CreditService import CreditService result = CreditService.process_maturing_credits(db) return { "message": "Store credit maturity sweep completed", "result": result } @router.post("/send-appointment-reminders") def trigger_appointment_reminders(db: Session = Depends(get_db)): """ Sends 2-hour pre-appointment WhatsApp reminders with location & directions to both walk-in customers and their assigned technicians. """ from app.services.CalendarInviteService import CalendarInviteService result = CalendarInviteService.send_appointment_reminders(db) return { "message": "Appointment reminder sweep completed", "result": result } @router.post("/pending-walkin-tasks-eod") def trigger_pending_walkin_tasks_eod(db: Session = Depends(get_db)): """ Closing time (8:00 PM) audit: checks for pending walk-in repair tasks and dispatches internal WhatsApp summary to Admin. """ from app.services.CalendarInviteService import CalendarInviteService result = CalendarInviteService.audit_pending_walkin_tasks_eod(db) return { "message": "Pending walk-in tasks EOD audit completed", "result": result }