486 lines
21 KiB
Python
486 lines
21 KiB
Python
import os
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
# Ensure backend root has highest priority in sys.path
|
|
_workspace_root = str(Path(__file__).resolve().parents[2])
|
|
if _workspace_root not in sys.path:
|
|
sys.path.append(_workspace_root)
|
|
_backend_root = str(Path(__file__).resolve().parents[1])
|
|
if _backend_root in sys.path:
|
|
sys.path.remove(_backend_root)
|
|
sys.path.insert(0, _backend_root)
|
|
|
|
import hashlib
|
|
from fastapi import FastAPI, Request, Response, status
|
|
from fastapi.responses import JSONResponse
|
|
from fastapi.middleware.cors import CORSMiddleware
|
|
from fastapi.middleware.gzip import GZipMiddleware
|
|
from fastapi.staticfiles import StaticFiles
|
|
from app.core.config.Config import settings
|
|
|
|
# Ensure all database models are loaded into the SQLAlchemy registry
|
|
import app.models.db_base
|
|
|
|
# Router Imports
|
|
from app.api.v1.routers.StorefrontRouter import router as storefront_legacy_router
|
|
from app.api.v1.routers.AuthenticationRouter import router as auth_router
|
|
from app.api.v1.routers.UserCreationRouter import router as user_router
|
|
from app.api.v1.routers.MasterDataRouter import router as geo_router
|
|
from app.api.v1.routers.SettingsRouter import router as setting_router
|
|
from app.api.v1.routers.FileRouter import router as file_router
|
|
from app.api.v1.routers.MfaRouter import router as mfa_router
|
|
from app.api.v1.routers.AdminSecurityRouter import router as admin_security_router
|
|
from app.api.v1.routers.RolePermissionRouter import router as role_perm_router
|
|
from app.api.v1.routers.CatalogRouter import router as catalog_router
|
|
from app.api.v1.routers.MigrationRouter import router as migration_router
|
|
from app.api.v1.routers.storefront import router as public_storefront_router
|
|
from app.api.v1.routers.admin_storefront import router as admin_storefront_router
|
|
from app.api.v1.routers.CustomerAuthRouter import router as customer_auth_router
|
|
from app.api.v1.routers.CustomerProfileRouter import router as customer_profile_router
|
|
from app.api.v1.routers.CartRouter import router as cart_router
|
|
from app.api.v1.routers.CheckoutRouter import router as checkout_router
|
|
from app.api.v1.routers.OrderRouter import router as order_router
|
|
from app.api.v1.routers.PaymentRouter import router as payment_router
|
|
from app.api.v1.routers.InvoiceRouter import router as invoice_router
|
|
from app.api.v1.routers.PosSyncRouter import router as pos_sync_router
|
|
from app.api.v1.routers.WishlistRouter import router as wishlist_router
|
|
from app.api.v1.routers.ProductCompareRouter import router as product_compare_router
|
|
from app.api.v1.routers.InventoryRouter import router as inventory_router
|
|
from app.api.v1.routers.AdminOrderRouter import router as admin_order_router
|
|
from app.api.v1.routers.AdminInvoiceRouter import router as admin_invoice_router
|
|
from app.api.v1.routers.AdminCustomerRouter import router as admin_customer_router
|
|
from app.api.v1.routers.DashboardRouter import router as dashboard_router
|
|
from app.api.v1.routers.HealthRouter import router as health_router
|
|
from app.api.v1.routers.CrmRouter import router as crm_router
|
|
from app.api.v1.routers.RepairErpRouter import router as repair_erp_router
|
|
from app.api.v1.routers.InventoryPosRouter import router as inventory_pos_router
|
|
from app.api.v1.routers.BillingFinanceRouter import router as billing_finance_router
|
|
from app.api.v1.routers.NotificationGatewayRouter import router as notification_gateway_router
|
|
from app.api.v1.routers.ReviewModerationRouter import router as review_moderation_router
|
|
from app.api.v1.routers.MultiDashboardRouter import router as multi_dashboard_router
|
|
from app.api.v1.routers.ServiceJobRouter import router as service_job_router
|
|
from app.api.v1.routers.SystemConfigRouter import router as system_config_router
|
|
from app.api.v1.routers.DeduplicationRouter import router as deduplication_router
|
|
from app.api.v1.routers.CrmTaskCalendarRouter import router as crm_task_calendar_router
|
|
from app.api.v1.routers.RefundRouter import router as refund_router
|
|
from app.api.v1.routers.NotificationTemplateRouter import router as notification_template_router
|
|
from app.api.v1.routers.CronRouter import router as cron_router
|
|
from app.api.v1.routers.WarrantyRouter import router as warranty_router
|
|
from app.api.v1.routers.CreditRouter import router as credit_router
|
|
from app.api.v1.routers.AdminCouponRouter import router as admin_coupon_router
|
|
# Middleware Imports
|
|
from app.core.middleware.trace_middleware import RequestTraceMiddleware
|
|
from app.core.middleware.security_middleware import SecurityHeadersMiddleware, RequestSizeLimitMiddleware
|
|
from app.core.middleware.kill_switch_middleware import KillSwitchMiddleware
|
|
from app.core.Exception import AppException
|
|
from sqlalchemy.exc import IntegrityError
|
|
|
|
is_prod = str(getattr(settings, "ENVIRONMENT", "")).lower() in ["production", "prod"]
|
|
docs_enabled = os.getenv("ENABLE_DOCS", "0" if is_prod else "1") == "1"
|
|
|
|
app = FastAPI(
|
|
title=settings.PROJECT_NAME,
|
|
description="iFixKart Enterprise ERP/CRM/E-commerce Platform Backend Core Foundation",
|
|
version="1.0.0",
|
|
docs_url="/docs" if docs_enabled else None,
|
|
redoc_url="/redoc" if docs_enabled else None,
|
|
openapi_url="/openapi.json" if docs_enabled else None,
|
|
)
|
|
|
|
# Mount Uploads directory for media serving with transparent upstream cache for missing local files
|
|
from pathlib import Path
|
|
import urllib.request
|
|
from fastapi.responses import FileResponse, Response
|
|
|
|
uploads_path = str(Path(__file__).resolve().parents[1] / "uploads")
|
|
os.makedirs(uploads_path, exist_ok=True)
|
|
|
|
@app.api_route("/uploads/{file_path:path}", methods=["GET", "HEAD"])
|
|
def serve_upload_file(file_path: str):
|
|
local_file = os.path.abspath(os.path.join(uploads_path, file_path))
|
|
if os.path.isfile(local_file) and local_file.startswith(uploads_path):
|
|
return FileResponse(local_file)
|
|
|
|
# Transparent Upstream Fallback with Auto-Caching
|
|
# Prevents 307 redirects that trigger browser CORB/ORB cross-origin blocking
|
|
try:
|
|
remote_url = f"https://ifixkartbe.trionixsolution.com/uploads/{file_path}"
|
|
req = urllib.request.Request(remote_url, headers={"User-Agent": "FastAPILocalProxy/1.0"})
|
|
with urllib.request.urlopen(req, timeout=8) as resp:
|
|
if resp.status == 200:
|
|
content = resp.read()
|
|
content_type = resp.headers.get_content_type() or "application/octet-stream"
|
|
# Cache to disk for instant zero-latency future hits
|
|
try:
|
|
os.makedirs(os.path.dirname(local_file), exist_ok=True)
|
|
with open(local_file, "wb") as f:
|
|
f.write(content)
|
|
return FileResponse(local_file, media_type=content_type)
|
|
except Exception:
|
|
return Response(content=content, media_type=content_type)
|
|
except Exception:
|
|
pass
|
|
|
|
return Response(content=b"Media file not found", status_code=404, media_type="text/plain")
|
|
|
|
# 1. CORS Configuration - Single Source of Truth
|
|
ALLOWED_ORIGINS = [
|
|
"https://ifixkartdev.trionixsolution.com",
|
|
"https://ifixkart.trionixsolution.com",
|
|
"https://ifixkartbe.trionixsolution.com",
|
|
"http://localhost:3000",
|
|
"http://localhost:3021",
|
|
"http://localhost:3022",
|
|
"http://localhost:8000",
|
|
"http://localhost:8010",
|
|
"http://127.0.0.1:3000",
|
|
"http://127.0.0.1:3021",
|
|
"http://127.0.0.1:3022",
|
|
"http://127.0.0.1:8000",
|
|
"http://127.0.0.1:8010",
|
|
]
|
|
ALLOWED_ORIGINS_SET = set(ALLOWED_ORIGINS)
|
|
|
|
app.add_middleware(
|
|
CORSMiddleware,
|
|
allow_origins=ALLOWED_ORIGINS,
|
|
allow_credentials=True,
|
|
allow_methods=["*"],
|
|
allow_headers=["*"],
|
|
)
|
|
|
|
# Enable Gzip Compression for large payloads (minimizing response size)
|
|
app.add_middleware(GZipMiddleware, minimum_size=1000)
|
|
|
|
# ETag and Cache-Control middleware for CDNs / Browsers caching
|
|
@app.middleware("http")
|
|
async def add_cache_headers_and_etag(request: Request, call_next):
|
|
if request.method != "GET":
|
|
return await call_next(request)
|
|
|
|
response = await call_next(request)
|
|
path = request.url.path
|
|
|
|
# Admin requests, authenticated requests, /products/all or layout configs MUST NEVER be cached
|
|
is_no_cache = (
|
|
request.headers.get("authorization") is not None or
|
|
"/products/all" in path or
|
|
"/admin" in path or
|
|
"/storefront/layout" in path
|
|
)
|
|
|
|
if is_no_cache:
|
|
response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
|
|
response.headers["Pragma"] = "no-cache"
|
|
response.headers["Expires"] = "0"
|
|
return response
|
|
|
|
is_cacheable = any(p in path for p in [
|
|
"/api/v1/catalog/products",
|
|
"/api/v1/catalog/brands",
|
|
"/api/v1/catalog/categories",
|
|
"/api/v1/settings/public"
|
|
])
|
|
|
|
if is_cacheable and response.status_code == 200:
|
|
body = b""
|
|
async for chunk in response.body_iterator:
|
|
body += chunk
|
|
|
|
etag_val = f'W/"{hashlib.md5(body).hexdigest()}"'
|
|
|
|
if_none_match = request.headers.get("if-none-match")
|
|
if if_none_match and if_none_match == etag_val:
|
|
return Response(status_code=304, headers={
|
|
"ETag": etag_val,
|
|
"Cache-Control": "public, max-age=60, must-revalidate"
|
|
})
|
|
|
|
headers = dict(response.headers)
|
|
headers["ETag"] = etag_val
|
|
headers["Cache-Control"] = "public, max-age=60, must-revalidate"
|
|
|
|
if "/layout/" in path:
|
|
headers["Cache-Control"] = "public, max-age=300, must-revalidate"
|
|
|
|
return Response(
|
|
content=body,
|
|
status_code=response.status_code,
|
|
headers=headers,
|
|
media_type=response.media_type
|
|
)
|
|
|
|
return response
|
|
|
|
# 2. Register Middleware Stack (Executed in reverse order of addition)
|
|
from app.core.middleware.audit_middleware import AuditMiddleware
|
|
from slowapi import _rate_limit_exceeded_handler
|
|
from slowapi.errors import RateLimitExceeded
|
|
from app.core.limiter import limiter
|
|
|
|
app.state.limiter = limiter
|
|
app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
|
|
|
|
app.add_middleware(AuditMiddleware)
|
|
app.add_middleware(KillSwitchMiddleware)
|
|
app.add_middleware(
|
|
RequestSizeLimitMiddleware,
|
|
max_bytes=50 * 1024 * 1024, # 50MB standard upload limit
|
|
large_paths_max_bytes=4 * 1024 * 1024 * 1024, # 4GB for migration datasets / media archives
|
|
large_paths=("/api/v1/migration", "/api/v1/files/upload")
|
|
)
|
|
app.add_middleware(SecurityHeadersMiddleware)
|
|
app.add_middleware(RequestTraceMiddleware)
|
|
|
|
|
|
from fastapi.exceptions import RequestValidationError
|
|
from starlette.exceptions import HTTPException as StarletteHTTPException
|
|
|
|
def append_cors_headers(response: JSONResponse, request: Request):
|
|
origin = request.headers.get("origin")
|
|
if origin and origin in ALLOWED_ORIGINS_SET:
|
|
response.headers["Access-Control-Allow-Origin"] = origin
|
|
response.headers["Access-Control-Allow-Credentials"] = "true"
|
|
response.headers["Access-Control-Allow-Methods"] = "GET, POST, PUT, DELETE, OPTIONS, PATCH"
|
|
response.headers["Access-Control-Allow-Headers"] = "Authorization, Content-Type, X-Requested-With, X-API-KEY, X-POS-Key"
|
|
|
|
# 3. Register Global Handlers for Custom AppException with CORS safety
|
|
@app.exception_handler(AppException)
|
|
def app_exception_handler(request: Request, exc: AppException):
|
|
req_id = getattr(request.state, "request_id", "unknown")
|
|
response = JSONResponse(
|
|
status_code=exc.status_code,
|
|
content={"detail": exc.detail, "request_id": req_id}
|
|
)
|
|
append_cors_headers(response, request)
|
|
return response
|
|
|
|
@app.exception_handler(StarletteHTTPException)
|
|
def http_exception_handler(request: Request, exc: StarletteHTTPException):
|
|
response = JSONResponse(
|
|
status_code=exc.status_code,
|
|
content={"detail": exc.detail}
|
|
)
|
|
append_cors_headers(response, request)
|
|
return response
|
|
|
|
from fastapi.encoders import jsonable_encoder
|
|
|
|
@app.exception_handler(RequestValidationError)
|
|
def validation_exception_handler(request: Request, exc: RequestValidationError):
|
|
response = JSONResponse(
|
|
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
|
|
content={"detail": jsonable_encoder(exc.errors())}
|
|
)
|
|
append_cors_headers(response, request)
|
|
return response
|
|
|
|
@app.exception_handler(IntegrityError)
|
|
def integrity_error_handler(request: Request, exc: IntegrityError):
|
|
orig_msg = str(exc.orig) if hasattr(exc, "orig") else str(exc)
|
|
detail = "A database integrity conflict occurred."
|
|
if "Duplicate entry" in orig_msg:
|
|
if "phone" in orig_msg.lower():
|
|
detail = "Phone number is already registered or in use."
|
|
elif "email" in orig_msg.lower():
|
|
detail = "Email address is already registered or in use."
|
|
else:
|
|
detail = "A record with this identifier already exists."
|
|
response = JSONResponse(
|
|
status_code=status.HTTP_409_CONFLICT,
|
|
content={"detail": detail}
|
|
)
|
|
append_cors_headers(response, request)
|
|
return response
|
|
|
|
@app.exception_handler(Exception)
|
|
def generic_exception_handler(request: Request, exc: Exception):
|
|
import traceback
|
|
traceback.print_exc()
|
|
req_id = getattr(request.state, "request_id", "unknown")
|
|
# Mask internal exception details from untrusted clients to prevent database schema/credential leaks
|
|
error_msg = str(exc) if settings.ENVIRONMENT == "development" else "Internal server error occurred. Please contact support."
|
|
response = JSONResponse(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
content={"detail": "Internal server error", "request_id": req_id, "error": error_msg}
|
|
)
|
|
append_cors_headers(response, request)
|
|
return response
|
|
|
|
# 4. Register Router Endpoints
|
|
app.include_router(storefront_legacy_router)
|
|
app.include_router(auth_router)
|
|
app.include_router(user_router)
|
|
app.include_router(geo_router)
|
|
app.include_router(setting_router)
|
|
app.include_router(file_router)
|
|
app.include_router(mfa_router)
|
|
app.include_router(admin_security_router)
|
|
app.include_router(role_perm_router)
|
|
app.include_router(catalog_router)
|
|
app.include_router(migration_router)
|
|
app.include_router(public_storefront_router)
|
|
app.include_router(admin_storefront_router)
|
|
app.include_router(customer_auth_router)
|
|
app.include_router(customer_profile_router)
|
|
app.include_router(cart_router)
|
|
app.include_router(checkout_router)
|
|
app.include_router(order_router)
|
|
app.include_router(payment_router)
|
|
# Simulation-only payment capture. The endpoint is not even registered outside
|
|
# the isolated simulation environment.
|
|
if getattr(settings, 'PAYMENT_SIMULATOR_ENABLED', False) and getattr(settings, 'SIMULATION_MODE', False):
|
|
from app.api.v1.routers.SimulationPaymentRouter import router as simulation_payment_router
|
|
app.include_router(simulation_payment_router)
|
|
app.include_router(invoice_router)
|
|
app.include_router(pos_sync_router)
|
|
app.include_router(wishlist_router)
|
|
app.include_router(product_compare_router)
|
|
app.include_router(inventory_router)
|
|
app.include_router(admin_order_router)
|
|
app.include_router(admin_invoice_router)
|
|
app.include_router(admin_customer_router)
|
|
app.include_router(dashboard_router)
|
|
app.include_router(service_job_router)
|
|
app.include_router(health_router)
|
|
app.include_router(crm_router)
|
|
app.include_router(notification_template_router)
|
|
app.include_router(repair_erp_router)
|
|
app.include_router(inventory_pos_router)
|
|
app.include_router(billing_finance_router)
|
|
app.include_router(notification_gateway_router)
|
|
app.include_router(review_moderation_router)
|
|
app.include_router(multi_dashboard_router)
|
|
app.include_router(system_config_router)
|
|
app.include_router(deduplication_router)
|
|
app.include_router(crm_task_calendar_router)
|
|
app.include_router(refund_router)
|
|
from app.api.v1.routers.RoleNotificationSettingsRouter import router as role_notification_settings_router
|
|
app.include_router(role_notification_settings_router)
|
|
app.include_router(cron_router)
|
|
app.include_router(warranty_router)
|
|
app.include_router(credit_router)
|
|
app.include_router(admin_coupon_router)
|
|
|
|
# Enterprise Integration Routers
|
|
from app.api.v1.routers.GoogleAnalyticsRouter import router as ga4_router
|
|
from app.api.v1.routers.GoogleMerchantRouter import router as merchant_router
|
|
from app.api.v1.routers.SocialMediaRouter import router as social_media_router
|
|
from app.api.v1.routers.RazorpayDashboardRouter import router as razorpay_dashboard_router
|
|
from app.api.v1.routers.ReportExportRouter import router as report_export_router
|
|
from app.api.v1.routers.ShiprocketRouter import router as shiprocket_router
|
|
from app.api.v1.routers.DelhiveryRouter import router as delhivery_router
|
|
from app.api.v1.routers.IntegrationRouter import router as integration_hub_router
|
|
|
|
app.include_router(ga4_router)
|
|
app.include_router(merchant_router)
|
|
app.include_router(social_media_router)
|
|
app.include_router(razorpay_dashboard_router)
|
|
app.include_router(report_export_router)
|
|
app.include_router(shiprocket_router)
|
|
app.include_router(delhivery_router)
|
|
app.include_router(integration_hub_router)
|
|
|
|
# Swarm Intelligence & Predictive Simulation Router
|
|
from app.api.v1.routers.SimulationRouter import router as simulation_router
|
|
app.include_router(simulation_router)
|
|
|
|
|
|
@app.get("/")
|
|
def read_root():
|
|
return {
|
|
"status": "online",
|
|
"project": settings.PROJECT_NAME,
|
|
"version": "1.0.0"
|
|
}
|
|
|
|
# 5. Startup Hook for Automatic Database Initialization & Seeding & Media Worker
|
|
@app.on_event("startup")
|
|
def startup_event():
|
|
print("FastAPI Application Booting... Running automatic database schema verification and permission seeding...")
|
|
from app.core.database.init_db import initialize_database
|
|
try:
|
|
initialize_database()
|
|
print("Automatic database initialization and seeding completed successfully.")
|
|
except Exception as e:
|
|
print(f"Error during automatic database initialization: {e}")
|
|
|
|
# Zombie Simulation Reaper (Crash Recovery)
|
|
try:
|
|
from swarm.queue import reap_stale_jobs
|
|
reaped = reap_stale_jobs()
|
|
if reaped > 0:
|
|
print(f"[Swarm Engine] Crash recovery reaped {reaped} interrupted simulation jobs.")
|
|
except Exception as e:
|
|
print(f"[Swarm Engine] Reaper initialization notice: {e}")
|
|
|
|
# Start Async Media Cleanup & Reconciliation Thread Worker
|
|
import threading
|
|
import time
|
|
from app.core.database.db_session import SessionLocal
|
|
from app.core.media.media_garbage_collector import process_async_media_cleanup, reconcile_media_database
|
|
|
|
def run_media_background_worker():
|
|
last_cleanup = 0
|
|
last_reconcile = 0
|
|
while True:
|
|
try:
|
|
now = time.time()
|
|
# Run hourly cleanup
|
|
if now - last_cleanup >= 3600:
|
|
last_cleanup = now
|
|
db = SessionLocal()
|
|
try:
|
|
process_async_media_cleanup(db)
|
|
finally:
|
|
db.close()
|
|
|
|
# Run daily reconciliation (86400s)
|
|
if now - last_reconcile >= 86400:
|
|
last_reconcile = now
|
|
db = SessionLocal()
|
|
try:
|
|
reconcile_media_database(db)
|
|
finally:
|
|
db.close()
|
|
except Exception as err:
|
|
print(f"Error in Media Background Worker loop: {err}")
|
|
|
|
time.sleep(300) # Check every 5 minutes
|
|
|
|
# Centralized background worker thread gating:
|
|
# In multi-worker Gunicorn setups, only the designated worker or sidecar process (ENABLE_MIGRATION_WORKER=1)
|
|
# spawns the database polling threads, preventing N-worker connection pool exhaustion.
|
|
if os.getenv("ENABLE_MIGRATION_WORKER", "0") == "1":
|
|
worker_thread = threading.Thread(target=run_media_background_worker, daemon=True, name="MediaWorkerThread")
|
|
worker_thread.start()
|
|
print("Media Async Garbage Collector & Reconciliation Worker thread started.")
|
|
|
|
# Start Persistent Migration Worker Background Thread
|
|
from app.services.migration_engine.migration_worker import MigrationWorker
|
|
|
|
def run_migration_background_worker():
|
|
worker = MigrationWorker()
|
|
print(f"[{worker.worker_id}] Migration Worker daemon initialized and listening for queued jobs...")
|
|
while True:
|
|
try:
|
|
db = SessionLocal()
|
|
try:
|
|
res = worker.claim_next_job(db)
|
|
if res:
|
|
job_id, lease_version = res
|
|
worker.process_job(job_id, lease_version)
|
|
finally:
|
|
db.close()
|
|
except Exception as err:
|
|
print(f"Error in Migration Worker loop: {err}")
|
|
time.sleep(2)
|
|
|
|
mig_thread = threading.Thread(target=run_migration_background_worker, daemon=True, name="MigrationWorkerThread")
|
|
mig_thread.start()
|
|
print("Persistent Migration Worker background thread started.")
|
|
else:
|
|
print("Background poller threads skipped on this worker (ENABLE_MIGRATION_WORKER != 1).")
|
|
|
|
|