ifixkart-backend/app/services/IntegrationService.py

699 lines
31 KiB
Python

import os
import json
import logging
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from datetime import datetime, timezone
from typing import Dict, Any, List, Optional
import httpx
from sqlalchemy.orm import Session
from sqlalchemy import text
from app.core.config.Config import settings
from app.models.SettingModel import Setting
import ulid
logger = logging.getLogger(__name__)
class IntegrationService:
"""
Central service for all third-party integrations in iFixKart ERP.
Architectural rule:
1. Config.py is PRIMARY. If credentials exist in settings, they are used.
2. Database settings table is FALLBACK. If Config.py is missing/empty, DB is consulted.
"""
# ---------------------------------------------------------
# Helper: Resolve settings (Config.py primary, DB fallback)
# ---------------------------------------------------------
@staticmethod
def get_setting_from_db(db: Session, group: str, key: str) -> Optional[Any]:
try:
row = db.query(Setting).filter(Setting.setting_key == key, Setting.group == group).first()
if row and row.setting_value is not None:
return row.setting_value
except Exception as e:
logger.warning(f"Error reading DB setting {key} ({group}): {e}")
return None
@staticmethod
def save_setting_to_db(db: Session, group: str, key: str, value: Any, description: str = ""):
try:
row = db.query(Setting).filter(Setting.setting_key == key, Setting.group == group).first()
if row:
row.setting_value = value
row.description = description
row.updated_at = datetime.now(timezone.utc)
else:
row = Setting(
setting_id=str(ulid.ULID()),
setting_key=key,
group=group,
type="json" if isinstance(value, (dict, list)) else "string",
setting_value=value,
description=description,
is_public=False,
is_editable=True
)
db.add(row)
db.commit()
return True
except Exception as e:
db.rollback()
logger.error(f"Error saving setting {key}: {e}")
raise e
# ---------------------------------------------------------
# Overview of all integrations
# ---------------------------------------------------------
@staticmethod
def get_overview(db: Session) -> Dict[str, Any]:
"""
Returns real-time status of all configured services.
"""
# 1. OpenWA (Internal WhatsApp)
openwa_status = "Disconnected"
openwa_phone = None
openwa_push_name = None
try:
headers = {"X-Api-Key": settings.OPENWA_MASTER_KEY}
with httpx.Client(timeout=3.0) as client:
r = client.get(f"{settings.OPENWA_GATEWAY_URL}/api/sessions", headers=headers)
if r.status_code == 200:
sessions = r.json()
if sessions and isinstance(sessions, list):
default_s = next((s for s in sessions if s.get("name") == "default"), sessions[0])
raw_st = default_s.get("status", "")
openwa_status = "QR_READY" if raw_st == "qr_ready" else ("Connected" if raw_st in ("connected", "authenticated") else raw_st.upper())
openwa_phone = default_s.get("phone")
openwa_push_name = default_s.get("pushName")
except Exception:
openwa_status = "Gateway Offline"
# 2. WATI (Customer WhatsApp)
wati_creds = IntegrationService.get_wati_credentials(db)
wati_connected = bool(wati_creds.get("api_token") and wati_creds.get("api_endpoint"))
# 3. Email (ZeptoMail / SMTP)
email_creds = IntegrationService.get_email_credentials(db)
email_connected = bool(email_creds.get("active_provider") and email_creds.get("active_provider") != "None")
# 4. Meta Ads
meta_creds = IntegrationService.get_meta_credentials(db)
meta_connected = bool(meta_creds.get("access_token") and meta_creds.get("ad_account_id"))
# 5. Google Analytics 4
ga4_connected = bool(settings.GA4_ENABLED and settings.GA4_PROPERTY_ID)
# 6. Knowlarity Telephony
knowlarity_creds = IntegrationService.get_knowlarity_credentials(db)
knowlarity_connected = bool(knowlarity_creds.get("api_key") or knowlarity_creds.get("authorization"))
# 7. Shiprocket Logistics
shiprocket_creds = IntegrationService.get_shiprocket_credentials(db)
shiprocket_connected = bool(shiprocket_creds.get("email") or shiprocket_creds.get("token") or settings.SHIPROCKET_ENABLED)
return {
"whatsapp_internal": {
"name": "Internal WhatsApp Gateway (OpenWA)",
"channel": "Internal Staff & Operations",
"status": openwa_status,
"phone": openwa_phone,
"push_name": openwa_push_name,
"gateway_url": settings.OPENWA_GATEWAY_URL,
"source": "config.py"
},
"whatsapp_customer": {
"name": "Customer WhatsApp (WATI Cloud API)",
"channel": "Customer Marketing & Broadcasts",
"status": "Connected" if wati_connected else "Pending Configuration",
"source": wati_creds.get("source"),
"endpoint": wati_creds.get("api_endpoint")
},
"email": {
"name": "Transactional Email (ZeptoMail & SMTP)",
"provider": email_creds.get("active_provider", "ZeptoMail"),
"status": "Connected" if email_connected else "Pending Configuration",
"sender": email_creds.get("sender_email"),
"source": email_creds.get("source")
},
"meta_ads": {
"name": "Meta Graph API & Ads (Facebook/Instagram)",
"status": "Connected" if meta_connected else "Pending Configuration",
"app_id": meta_creds.get("app_id"),
"ad_account_id": meta_creds.get("ad_account_id"),
"page_id": meta_creds.get("page_id"),
"source": meta_creds.get("source")
},
"google_analytics": {
"name": "Google Analytics 4 (GA4)",
"status": "Connected" if ga4_connected else "Disabled",
"property_id": settings.GA4_PROPERTY_ID,
"source": "config.py"
},
"knowlarity": {
"name": "Knowlarity Cloud Telephony (IVR / Calls)",
"status": "Connected" if knowlarity_connected else "Pending Configuration",
"virtual_number": knowlarity_creds.get("virtual_number"),
"source": knowlarity_creds.get("source")
},
"shiprocket": {
"name": "Shiprocket Logistics & Delivery",
"status": "Connected" if shiprocket_connected else "Pending Configuration",
"source": shiprocket_creds.get("source"),
"pickup_location": shiprocket_creds.get("pickup_location")
}
}
# ---------------------------------------------------------
# 1. Internal WhatsApp (OpenWA Gateway on Port 8088)
# ---------------------------------------------------------
@staticmethod
def get_openwa_qr() -> Dict[str, Any]:
"""
Streams live QR code directly from OpenWA session for browser scanning.
"""
headers = {"X-Api-Key": settings.OPENWA_MASTER_KEY}
with httpx.Client(timeout=8.0) as client:
sess_res = client.get(f"{settings.OPENWA_GATEWAY_URL}/api/sessions", headers=headers)
if sess_res.status_code != 200:
return {"status": "OFFLINE", "message": "OpenWA gateway is offline"}
sessions = sess_res.json()
if not sessions:
return {"status": "NO_SESSION", "message": "No OpenWA sessions found"}
default_s = next((s for s in sessions if s.get("name") == "default"), sessions[0])
sess_id = default_s.get("id")
raw_status = default_s.get("status", "")
if raw_status in ("connected", "authenticated"):
return {
"status": "CONNECTED",
"session_id": sess_id,
"phone": default_s.get("phone"),
"push_name": default_s.get("pushName"),
"connected_at": default_s.get("connectedAt"),
"qr_code": None
}
qr_res = client.get(f"{settings.OPENWA_GATEWAY_URL}/api/sessions/{sess_id}/qr", headers=headers)
if qr_res.status_code == 200:
qr_data = qr_res.json()
qr_str = qr_data.get("qrCode") or qr_data.get("qr_code_base64")
return {
"status": "QR_READY",
"session_id": sess_id,
"qr_code": qr_str,
"phone": default_s.get("phone"),
"push_name": default_s.get("pushName")
}
return {
"status": raw_status.upper() or "INITIALIZING",
"session_id": sess_id,
"qr_code": None,
"message": "Session is initializing or waiting for QR generation"
}
@staticmethod
def send_test_openwa_message(phone: str, message: str) -> Dict[str, Any]:
"""
Sends real test message through OpenWA.
"""
clean_phone = "".join(filter(str.isdigit, phone))
if len(clean_phone) == 10:
clean_phone = "91" + clean_phone
headers = {
"X-Api-Key": settings.OPENWA_MASTER_KEY,
"Content-Type": "application/json"
}
payload = {
"chatId": f"{clean_phone}@c.us",
"message": message or "Test verification message from iFixKart ERP"
}
with httpx.Client(timeout=10.0) as client:
r = client.post(f"{settings.OPENWA_GATEWAY_URL}/api/send/text", json=payload, headers=headers)
if r.status_code in (200, 201):
return {"status": "SUCCESS", "response": r.json()}
return {"status": "FAILED", "code": r.status_code, "detail": r.text}
@staticmethod
def restart_openwa_session() -> Dict[str, Any]:
headers = {"X-Api-Key": settings.OPENWA_MASTER_KEY}
with httpx.Client(timeout=10.0) as client:
sess_res = client.get(f"{settings.OPENWA_GATEWAY_URL}/api/sessions", headers=headers)
if sess_res.status_code == 200 and sess_res.json():
sess_id = sess_res.json()[0].get("id")
r = client.post(f"{settings.OPENWA_GATEWAY_URL}/api/sessions/{sess_id}/restart", headers=headers)
return {"status": "SUCCESS", "detail": "Session restart initiated"}
return {"status": "FAILED", "detail": "Could not locate active session"}
# ---------------------------------------------------------
# 2. External Customer WhatsApp (WATI Cloud API)
# ---------------------------------------------------------
@staticmethod
def get_wati_credentials(db: Session) -> Dict[str, Any]:
"""
Primary: Config.py | Fallback: DB settings
"""
endpoint = settings.WATI_API_ENDPOINT
token = settings.WATI_API_TOKEN
if token and endpoint:
return {
"api_endpoint": endpoint,
"api_token": token,
"source": "config.py",
"is_locked_by_config": True
}
db_val = IntegrationService.get_setting_from_db(db, "integration_wati", "credentials")
if db_val and isinstance(db_val, dict):
return {
"api_endpoint": db_val.get("api_endpoint", "https://live-mt-server.wati.io"),
"api_token": db_val.get("api_token", ""),
"source": "database",
"is_locked_by_config": False
}
return {
"api_endpoint": "https://live-mt-server.wati.io",
"api_token": "",
"source": "unconfigured",
"is_locked_by_config": False
}
@staticmethod
def save_wati_credentials(payload: Dict[str, Any], db: Session):
return IntegrationService.save_setting_to_db(
db, "integration_wati", "credentials",
{
"api_endpoint": payload.get("api_endpoint", "https://live-mt-server.wati.io").strip(),
"api_token": payload.get("api_token", "").strip(),
"updated_at": datetime.now(timezone.utc).isoformat()
},
description="WATI Customer WhatsApp Cloud API Credentials"
)
@staticmethod
def test_wati_connection(endpoint: str, token: str) -> Dict[str, Any]:
clean_endpoint = endpoint.rstrip("/")
headers = {"Authorization": token if token.startswith("Bearer ") else f"Bearer {token}"}
with httpx.Client(timeout=10.0) as client:
r = client.get(f"{clean_endpoint}/api/v1/getMessageTemplates", headers={"Authorization": token})
if r.status_code != 200:
r = client.get(f"{clean_endpoint}/api/v1/getMessageTemplates", headers=headers)
if r.status_code == 200:
data = r.json()
templates = data.get("templates") or data.get("messageTemplates") or []
return {
"status": "SUCCESS",
"templates_count": len(templates),
"templates": templates[:15]
}
return {
"status": "FAILED",
"status_code": r.status_code,
"detail": r.text
}
@staticmethod
def get_wati_templates(db: Session) -> List[Dict[str, Any]]:
creds = IntegrationService.get_wati_credentials(db)
if not creds.get("api_token"):
return []
res = IntegrationService.test_wati_connection(creds["api_endpoint"], creds["api_token"])
return res.get("templates", []) if res.get("status") == "SUCCESS" else []
@staticmethod
def send_wati_template_message(phone: str, template_name: str, broadcast_name: str, parameters: list, db: Session) -> Dict[str, Any]:
creds = IntegrationService.get_wati_credentials(db)
if not creds.get("api_token"):
return {"status": "FAILED", "detail": "WATI credentials not configured"}
clean_phone = "".join(filter(str.isdigit, phone))
endpoint = creds["api_endpoint"].rstrip("/")
payload = {
"template_name": template_name,
"broadcast_name": broadcast_name or f"test_{int(datetime.now().timestamp())}",
"whatsappNumber": clean_phone,
"parameters": parameters or []
}
headers = {"Authorization": creds["api_token"]}
with httpx.Client(timeout=10.0) as client:
r = client.post(f"{endpoint}/api/v1/sendTemplateMessage", json=payload, headers=headers)
if r.status_code == 200:
return {"status": "SUCCESS", "response": r.json()}
return {"status": "FAILED", "code": r.status_code, "detail": r.text}
# ---------------------------------------------------------
# 3. Transactional Email (ZeptoMail & SMTP)
# ---------------------------------------------------------
@staticmethod
def get_email_credentials(db: Session) -> Dict[str, Any]:
"""
Primary: ZeptoMail from Config.py | Fallback: Custom SMTP in DB
"""
if settings.ZEPTOMAIL_API_KEY:
return {
"active_provider": "ZeptoMail",
"sender_email": settings.EMAIL_SENDER_ADDRESS,
"sender_name": "iFixKart",
"host": settings.ZEPTOMAIL_HOST,
"endpoint": settings.ZEPTOMAIL_API_ENDPOINT,
"source": "config.py",
"is_locked_by_config": True
}
db_val = IntegrationService.get_setting_from_db(db, "integration_email", "credentials")
if db_val and isinstance(db_val, dict):
return {
"active_provider": db_val.get("provider", "SMTP"),
"sender_email": db_val.get("sender_email", ""),
"sender_name": db_val.get("sender_name", "iFixKart"),
"smtp_server": db_val.get("smtp_server", ""),
"smtp_port": db_val.get("smtp_port", 587),
"smtp_username": db_val.get("smtp_username", ""),
"use_tls": db_val.get("use_tls", True),
"source": "database",
"is_locked_by_config": False
}
return {
"active_provider": "None",
"source": "unconfigured",
"is_locked_by_config": False
}
@staticmethod
def save_email_credentials(payload: Dict[str, Any], db: Session):
return IntegrationService.save_setting_to_db(
db, "integration_email", "credentials", payload,
description="Custom SMTP Email Dispatcher Settings"
)
@staticmethod
def send_test_email(recipient: str, subject: str, body: str, db: Session) -> Dict[str, Any]:
creds = IntegrationService.get_email_credentials(db)
# 1. ZeptoMail path
if creds.get("active_provider") == "ZeptoMail" and settings.ZEPTOMAIL_API_KEY:
headers = {
"Accept": "application/json",
"Content-Type": "application/json",
"Authorization": f"Zoho-enczapikey {settings.ZEPTOMAIL_API_KEY}"
}
payload = {
"from": {"address": settings.EMAIL_SENDER_ADDRESS, "name": "iFixKart ERP"},
"to": [{"email_address": {"address": recipient, "name": recipient.split("@")[0]}}],
"subject": subject or "iFixKart Email Integration Active",
"htmlbody": f"<div style='font-family:sans-serif;padding:20px;'><h2 style='color:#0284c7;'>iFixKart Email Integration Active</h2><p>{body or 'This is a verified test email sent from iFixKart ERP.'}</p><hr/><small>Sent via Zoho ZeptoMail CPaaS</small></div>"
}
with httpx.Client(timeout=8.0) as client:
r = client.post(settings.ZEPTOMAIL_API_ENDPOINT, json=payload, headers=headers)
if r.status_code in (200, 201):
return {"status": "SUCCESS", "provider": "ZeptoMail", "response": r.json()}
return {"status": "FAILED", "provider": "ZeptoMail", "detail": r.text}
# 2. Custom SMTP fallback path
smtp_server = creds.get("smtp_server")
smtp_port = int(creds.get("smtp_port", 587))
smtp_user = creds.get("smtp_username")
smtp_pass = creds.get("smtp_password")
if not smtp_server or not smtp_user:
return {"status": "FAILED", "detail": "No valid ZeptoMail or SMTP credentials configured"}
try:
msg = MIMEMultipart()
msg["From"] = creds.get("sender_email", smtp_user)
msg["To"] = recipient
msg["Subject"] = subject or "iFixKart SMTP Verification Test"
msg.attach(MIMEText(body or "This is a test email sent from iFixKart SMTP integration.", "html"))
with smtplib.SMTP(smtp_server, smtp_port, timeout=10) as server:
if creds.get("use_tls", True):
server.starttls()
if smtp_pass:
server.login(smtp_user, smtp_pass)
server.send_message(msg)
return {"status": "SUCCESS", "provider": "SMTP", "recipient": recipient}
except Exception as e:
return {"status": "FAILED", "provider": "SMTP", "detail": str(e)}
# ---------------------------------------------------------
# 4. Meta Ads & Graph API (Facebook & Instagram)
# ---------------------------------------------------------
@staticmethod
def get_meta_credentials(db: Session) -> Dict[str, Any]:
"""
Primary: Config.py | Fallback: DB
"""
if settings.META_ACCESS_TOKEN and settings.META_APP_ID:
return {
"app_id": settings.META_APP_ID,
"ad_account_id": settings.META_AD_ACCOUNT_ID,
"page_id": settings.FACEBOOK_PAGE_ID,
"instagram_id": settings.INSTAGRAM_BUSINESS_ACCOUNT_ID,
"access_token": settings.META_ACCESS_TOKEN,
"source": "config.py",
"is_locked_by_config": True
}
db_val = IntegrationService.get_setting_from_db(db, "integration_meta", "credentials")
if db_val and isinstance(db_val, dict):
return {
"app_id": db_val.get("app_id", ""),
"ad_account_id": db_val.get("ad_account_id", ""),
"page_id": db_val.get("page_id", ""),
"instagram_id": db_val.get("instagram_id", ""),
"access_token": db_val.get("access_token", ""),
"source": "database",
"is_locked_by_config": False
}
return {
"app_id": "",
"ad_account_id": "",
"page_id": "",
"access_token": "",
"source": "unconfigured",
"is_locked_by_config": False
}
@staticmethod
def save_meta_credentials(payload: Dict[str, Any], db: Session):
return IntegrationService.save_setting_to_db(
db, "integration_meta", "credentials", payload,
description="Meta Ads & Facebook/Instagram Graph API Credentials"
)
@staticmethod
def test_meta_connection(token: str, ad_account_id: str = "") -> Dict[str, Any]:
clean_token = token.strip()
url = f"{settings.META_GRAPH_API_BASE}/me?fields=id,name,accounts&access_token={clean_token}"
with httpx.Client(timeout=10.0) as client:
r = client.get(url)
if r.status_code == 200:
user_data = r.json()
ad_account_info = None
if ad_account_id:
act_clean = ad_account_id if ad_account_id.startswith("act_") else f"act_{ad_account_id}"
act_url = f"{settings.META_GRAPH_API_BASE}/{act_clean}?fields=id,name,account_status,currency,amount_spent&access_token={clean_token}"
act_r = client.get(act_url)
if act_r.status_code == 200:
ad_account_info = act_r.json()
return {
"status": "SUCCESS",
"user": user_data,
"ad_account": ad_account_info
}
return {"status": "FAILED", "code": r.status_code, "detail": r.text}
# ---------------------------------------------------------
# 5. Knowlarity Cloud Telephony (IVR / Click-to-Call)
# ---------------------------------------------------------
@staticmethod
def get_knowlarity_credentials(db: Session) -> Dict[str, Any]:
"""
Primary: Config.py | Fallback: DB
"""
if settings.KNOWLARITY_API_KEY and settings.KNOWLARITY_AUTHORIZATION:
return {
"api_key": settings.KNOWLARITY_API_KEY,
"authorization": settings.KNOWLARITY_AUTHORIZATION,
"virtual_number": settings.KNOWLARITY_SR_NUMBER,
"call_url": settings.KNOWLARITY_CALL_URL,
"log_url": settings.KNOWLARITY_LOG_URL,
"source": "config.py",
"is_locked_by_config": True
}
db_val = IntegrationService.get_setting_from_db(db, "integration_knowlarity", "credentials")
if db_val and isinstance(db_val, dict):
return {
"api_key": db_val.get("api_key", ""),
"authorization": db_val.get("authorization", ""),
"virtual_number": db_val.get("virtual_number", ""),
"call_url": db_val.get("call_url", "https://kpi.knowlarity.com/Basic/v1/account/call/makecall"),
"log_url": db_val.get("log_url", "https://kpi.knowlarity.com/Basic/v1/account/calllog"),
"source": "database",
"is_locked_by_config": False
}
return {
"api_key": "",
"authorization": "",
"virtual_number": "",
"source": "unconfigured",
"is_locked_by_config": False
}
@staticmethod
def save_knowlarity_credentials(payload: Dict[str, Any], db: Session):
return IntegrationService.save_setting_to_db(
db, "integration_knowlarity", "credentials", payload,
description="Knowlarity SuperReceptionist Telephony Settings"
)
@staticmethod
def knowlarity_make_call(agent_number: str, customer_number: str, db: Session) -> Dict[str, Any]:
creds = IntegrationService.get_knowlarity_credentials(db)
if not creds.get("api_key") or not creds.get("authorization"):
return {"status": "FAILED", "detail": "Knowlarity API Key / Authorization missing"}
headers = {
"x-api-key": creds["api_key"],
"authorization": creds["authorization"],
"content-type": "application/json"
}
payload = {
"k_number": creds.get("virtual_number", ""),
"agent_number": agent_number.strip(),
"customer_number": customer_number.strip()
}
call_url = creds.get("call_url", "https://kpi.knowlarity.com/Basic/v1/account/call/makecall")
with httpx.Client(timeout=12.0) as client:
try:
r = client.post(call_url, json=payload, headers=headers)
if r.status_code in (200, 201):
return {"status": "SUCCESS", "response": r.json()}
return {"status": "FAILED", "code": r.status_code, "detail": r.text}
except Exception as e:
return {"status": "FAILED", "detail": str(e)}
@staticmethod
def knowlarity_get_call_logs(page: int, limit: int, db: Session) -> Dict[str, Any]:
creds = IntegrationService.get_knowlarity_credentials(db)
if not creds.get("api_key") or not creds.get("authorization"):
return {"status": "FAILED", "detail": "Knowlarity credentials missing", "call_logs": []}
headers = {
"x-api-key": creds["api_key"],
"authorization": creds["authorization"]
}
log_url = creds.get("log_url", "https://kpi.knowlarity.com/Basic/v1/account/calllog")
with httpx.Client(timeout=10.0) as client:
try:
r = client.get(f"{log_url}?page={page}&limit={limit}", headers=headers)
if r.status_code == 200:
return {"status": "SUCCESS", "data": r.json()}
return {"status": "FAILED", "code": r.status_code, "detail": r.text, "call_logs": []}
except Exception as e:
return {"status": "FAILED", "detail": str(e), "call_logs": []}
# ---------------------------------------------------------
# 6. Shiprocket Logistics
# ---------------------------------------------------------
@staticmethod
def get_shiprocket_credentials(db: Session) -> Dict[str, Any]:
"""
Primary: Config.py | Fallback: DB
"""
if settings.SHIPROCKET_EMAIL and settings.SHIPROCKET_PASSWORD:
return {
"email": settings.SHIPROCKET_EMAIL,
"pickup_location": settings.SHIPROCKET_PICKUP_LOCATION,
"pickup_pin": settings.SHIPROCKET_PICKUP_PIN,
"api_url": settings.SHIPROCKET_API_URL,
"source": "config.py",
"is_locked_by_config": True
}
db_val = IntegrationService.get_setting_from_db(db, "integration_shiprocket", "credentials")
if db_val and isinstance(db_val, dict):
return {
"email": db_val.get("email", ""),
"pickup_location": db_val.get("pickup_location", "Primary"),
"pickup_pin": db_val.get("pickup_pin", ""),
"api_url": db_val.get("api_url", "https://apiv2.shiprocket.in/v1/external"),
"token": db_val.get("token", ""),
"source": "database",
"is_locked_by_config": False
}
return {
"email": "",
"pickup_location": "Primary",
"pickup_pin": "",
"api_url": "https://apiv2.shiprocket.in/v1/external",
"source": "unconfigured",
"is_locked_by_config": False
}
@staticmethod
def save_shiprocket_credentials(payload: Dict[str, Any], db: Session):
return IntegrationService.save_setting_to_db(
db, "integration_shiprocket", "credentials", payload,
description="Shiprocket API Logistics Credentials"
)
@staticmethod
def test_shiprocket_auth(email: str, password: str, db: Session = None) -> Dict[str, Any]:
payload = {"email": email.strip(), "password": password.strip()}
url = "https://apiv2.shiprocket.in/v1/external/auth/login"
with httpx.Client(timeout=10.0) as client:
try:
r = client.post(url, json=payload)
if r.status_code == 200:
token = r.json().get("token")
if db and token:
IntegrationService.save_setting_to_db(
db, "integration_shiprocket", "cached_token",
{"token": token, "generated_at": datetime.now(timezone.utc).isoformat()}
)
return {"status": "SUCCESS", "token": token}
return {"status": "FAILED", "code": r.status_code, "detail": r.text}
except Exception as e:
return {"status": "FAILED", "detail": str(e)}
@staticmethod
def check_shiprocket_serviceability(pickup_pin: str, delivery_pin: str, weight: float, cod: bool, db: Session) -> Dict[str, Any]:
creds = IntegrationService.get_shiprocket_credentials(db)
token = creds.get("token") or ""
cached = IntegrationService.get_setting_from_db(db, "integration_shiprocket", "cached_token")
if cached and isinstance(cached, dict):
token = cached.get("token", token)
if not token:
return {"status": "FAILED", "detail": "Shiprocket authentication token required"}
headers = {"Authorization": f"Bearer {token}"}
url = f"https://apiv2.shiprocket.in/v1/external/courier/serviceability/?pickup_postcode={pickup_pin}&delivery_postcode={delivery_pin}&weight={weight}&cod={1 if cod else 0}"
with httpx.Client(timeout=10.0) as client:
try:
r = client.get(url, headers=headers)
if r.status_code == 200:
return {"status": "SUCCESS", "data": r.json()}
return {"status": "FAILED", "code": r.status_code, "detail": r.text}
except Exception as e:
return {"status": "FAILED", "detail": str(e)}