forked from hesabix/arc
382 lines
12 KiB
Python
382 lines
12 KiB
Python
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import logging
|
|
from datetime import datetime, timedelta
|
|
from typing import Any, Optional
|
|
|
|
from sqlalchemy import and_, or_, select
|
|
from sqlalchemy.exc import IntegrityError
|
|
from sqlalchemy.orm import Session
|
|
|
|
from adapters.db.models.document import Document
|
|
from adapters.db.models.quick_sale_invoice_job import QuickSaleInvoiceJob
|
|
from app.core.responses import ApiError
|
|
from app.core.transaction_lock import acquire_transaction_lock
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
MAX_ATTEMPTS = 5
|
|
JOB_LEASE = timedelta(minutes=10)
|
|
|
|
|
|
def find_quick_sale_invoice(db: Session, business_id: int, request_id: str) -> Optional[Document]:
|
|
return (
|
|
db.query(Document)
|
|
.filter(
|
|
Document.business_id == int(business_id),
|
|
Document.document_type == "invoice_sales",
|
|
Document.extra_info["quick_sale"].as_string() == "true",
|
|
Document.extra_info["quick_sale_request_id"].as_string() == request_id,
|
|
)
|
|
.first()
|
|
)
|
|
|
|
|
|
def serialize_quick_sale_job(job: QuickSaleInvoiceJob) -> dict[str, Any]:
|
|
return {
|
|
"job_id": int(job.id),
|
|
"request_id": job.request_id,
|
|
"status": job.status,
|
|
"invoice_id": int(job.invoice_id) if job.invoice_id is not None else None,
|
|
"invoice_code": job.invoice_code,
|
|
"error_code": job.error_code,
|
|
"error_message": job.error_message,
|
|
"error_details": job.error_details,
|
|
"attempt_count": int(job.attempt_count or 0),
|
|
"created_at": job.created_at.isoformat() if job.created_at else None,
|
|
"finished_at": job.finished_at.isoformat() if job.finished_at else None,
|
|
}
|
|
|
|
|
|
def enqueue_quick_sale_invoice(
|
|
db: Session,
|
|
*,
|
|
business_id: int,
|
|
user_id: int,
|
|
request_id: str,
|
|
payload: dict[str, Any],
|
|
user_can_select_fx_rate: bool,
|
|
user_can_change_invoice_unit_price: bool,
|
|
) -> QuickSaleInvoiceJob:
|
|
"""Insert the request into the durable DB outbox, idempotently."""
|
|
acquire_transaction_lock(db, f"quick_sale_invoice:{business_id}:{request_id}")
|
|
existing_invoice = find_quick_sale_invoice(db, business_id, request_id)
|
|
if existing_invoice is not None:
|
|
job = (
|
|
db.query(QuickSaleInvoiceJob)
|
|
.filter(
|
|
QuickSaleInvoiceJob.business_id == business_id,
|
|
QuickSaleInvoiceJob.request_id == request_id,
|
|
)
|
|
.first()
|
|
)
|
|
if job is not None and int(job.user_id) != int(user_id):
|
|
raise ApiError(
|
|
"QUICK_SALE_REQUEST_ID_CONFLICT",
|
|
"شناسهٔ این درخواست قبلاً برای کاربر دیگری استفاده شده است.",
|
|
http_status=409,
|
|
)
|
|
if int(existing_invoice.created_by_user_id or 0) != int(user_id):
|
|
raise ApiError(
|
|
"QUICK_SALE_REQUEST_ID_CONFLICT",
|
|
"شناسهٔ این درخواست قبلاً برای کاربر دیگری استفاده شده است.",
|
|
http_status=409,
|
|
)
|
|
if job is None:
|
|
job = QuickSaleInvoiceJob(
|
|
business_id=business_id,
|
|
user_id=user_id,
|
|
request_id=request_id,
|
|
payload=payload,
|
|
status="completed",
|
|
invoice_id=int(existing_invoice.id),
|
|
invoice_code=existing_invoice.code,
|
|
finished_at=datetime.utcnow(),
|
|
)
|
|
db.add(job)
|
|
db.flush()
|
|
return job
|
|
|
|
job = (
|
|
db.query(QuickSaleInvoiceJob)
|
|
.filter(
|
|
QuickSaleInvoiceJob.business_id == business_id,
|
|
QuickSaleInvoiceJob.request_id == request_id,
|
|
)
|
|
.first()
|
|
)
|
|
if job is not None:
|
|
if int(job.user_id) != int(user_id):
|
|
raise ApiError(
|
|
"QUICK_SALE_REQUEST_ID_CONFLICT",
|
|
"شناسهٔ این درخواست قبلاً برای کاربر دیگری استفاده شده است.",
|
|
http_status=409,
|
|
)
|
|
return job
|
|
|
|
job = QuickSaleInvoiceJob(
|
|
business_id=business_id,
|
|
user_id=user_id,
|
|
request_id=request_id,
|
|
payload=payload,
|
|
user_can_select_fx_rate=bool(user_can_select_fx_rate),
|
|
user_can_change_invoice_unit_price=bool(user_can_change_invoice_unit_price),
|
|
status="queued",
|
|
attempt_count=0,
|
|
available_at=datetime.utcnow(),
|
|
)
|
|
db.add(job)
|
|
try:
|
|
with db.begin_nested():
|
|
db.flush()
|
|
except IntegrityError:
|
|
job = (
|
|
db.query(QuickSaleInvoiceJob)
|
|
.filter(
|
|
QuickSaleInvoiceJob.business_id == business_id,
|
|
QuickSaleInvoiceJob.request_id == request_id,
|
|
)
|
|
.first()
|
|
)
|
|
if job is None:
|
|
raise
|
|
if int(job.user_id) != int(user_id):
|
|
raise ApiError(
|
|
"QUICK_SALE_REQUEST_ID_CONFLICT",
|
|
"شناسهٔ این درخواست قبلاً برای کاربر دیگری استفاده شده است.",
|
|
http_status=409,
|
|
)
|
|
return job
|
|
|
|
|
|
def get_quick_sale_invoice_job(
|
|
db: Session,
|
|
*,
|
|
business_id: int,
|
|
user_id: int,
|
|
request_id: str,
|
|
) -> Optional[QuickSaleInvoiceJob]:
|
|
return (
|
|
db.query(QuickSaleInvoiceJob)
|
|
.filter(
|
|
QuickSaleInvoiceJob.business_id == int(business_id),
|
|
QuickSaleInvoiceJob.user_id == int(user_id),
|
|
QuickSaleInvoiceJob.request_id == request_id,
|
|
)
|
|
.first()
|
|
)
|
|
|
|
|
|
def list_quick_sale_invoice_jobs(
|
|
db: Session,
|
|
*,
|
|
business_id: int,
|
|
user_id: int,
|
|
limit: int = 20,
|
|
) -> list[QuickSaleInvoiceJob]:
|
|
now = datetime.utcnow()
|
|
active_stmt = (
|
|
select(QuickSaleInvoiceJob)
|
|
.where(
|
|
QuickSaleInvoiceJob.business_id == int(business_id),
|
|
QuickSaleInvoiceJob.user_id == int(user_id),
|
|
QuickSaleInvoiceJob.status.in_(("queued", "processing", "failed")),
|
|
)
|
|
.order_by(QuickSaleInvoiceJob.created_at.desc(), QuickSaleInvoiceJob.id.desc())
|
|
.limit(max(1, min(int(limit), 50)))
|
|
)
|
|
completed_stmt = (
|
|
select(QuickSaleInvoiceJob)
|
|
.where(
|
|
QuickSaleInvoiceJob.business_id == int(business_id),
|
|
QuickSaleInvoiceJob.user_id == int(user_id),
|
|
QuickSaleInvoiceJob.status == "completed",
|
|
QuickSaleInvoiceJob.created_at >= now - timedelta(days=1),
|
|
)
|
|
.order_by(QuickSaleInvoiceJob.created_at.desc(), QuickSaleInvoiceJob.id.desc())
|
|
.limit(max(1, min(int(limit), 50)))
|
|
)
|
|
jobs = [
|
|
*db.execute(active_stmt).scalars().all(),
|
|
*db.execute(completed_stmt).scalars().all(),
|
|
]
|
|
return sorted(jobs, key=lambda job: (job.created_at, job.id), reverse=True)
|
|
|
|
|
|
def _claim_one_job() -> Optional[int]:
|
|
from adapters.db.session import get_db_session
|
|
|
|
now = datetime.utcnow()
|
|
with get_db_session() as db:
|
|
stmt = (
|
|
select(QuickSaleInvoiceJob)
|
|
.where(
|
|
or_(
|
|
and_(
|
|
QuickSaleInvoiceJob.status == "queued",
|
|
QuickSaleInvoiceJob.available_at <= now,
|
|
),
|
|
and_(
|
|
QuickSaleInvoiceJob.status == "processing",
|
|
QuickSaleInvoiceJob.locked_until.is_not(None),
|
|
QuickSaleInvoiceJob.locked_until <= now,
|
|
),
|
|
)
|
|
)
|
|
.order_by(QuickSaleInvoiceJob.created_at.asc(), QuickSaleInvoiceJob.id.asc())
|
|
.limit(1)
|
|
.with_for_update(skip_locked=True)
|
|
)
|
|
job = db.execute(stmt).scalars().first()
|
|
if job is None:
|
|
return None
|
|
if int(job.attempt_count or 0) >= MAX_ATTEMPTS:
|
|
job.status = "failed"
|
|
job.error_code = "QUICK_SALE_WORKER_RETRIES_EXHAUSTED"
|
|
job.error_message = "پردازش فروش پس از چند تلاش ناموفق متوقف شد."
|
|
job.error_details = None
|
|
job.locked_until = None
|
|
job.finished_at = now
|
|
db.commit()
|
|
return None
|
|
job.status = "processing"
|
|
job.attempt_count = int(job.attempt_count or 0) + 1
|
|
job.locked_until = now + JOB_LEASE
|
|
job.error_code = None
|
|
job.error_message = None
|
|
job.error_details = None
|
|
db.commit()
|
|
return int(job.id)
|
|
|
|
|
|
def _error_data(exc: Exception) -> tuple[str, str, bool, Optional[dict[str, Any]]]:
|
|
if isinstance(exc, ApiError):
|
|
code = str(getattr(exc, "code", "QUICK_SALE_INVOICE_FAILED"))
|
|
message = str(getattr(exc, "message", None) or getattr(exc, "detail", None) or code)
|
|
status_code = int(getattr(exc, "status_code", 400) or 400)
|
|
details = None
|
|
if code == "INSUFFICIENT_STOCK":
|
|
raw_details = getattr(exc, "details", None)
|
|
raw_shortages = raw_details.get("shortages") if isinstance(raw_details, dict) else None
|
|
if isinstance(raw_shortages, list):
|
|
allowed_fields = {
|
|
"product_id",
|
|
"product_name",
|
|
"product_code",
|
|
"warehouse_id",
|
|
"warehouse_name",
|
|
"inventory_mode",
|
|
"available_quantity",
|
|
"requested_quantity",
|
|
"shortage_quantity",
|
|
}
|
|
details = {
|
|
"shortages": [
|
|
{key: value for key, value in item.items() if key in allowed_fields}
|
|
for item in raw_shortages
|
|
if isinstance(item, dict)
|
|
]
|
|
}
|
|
return code[:100], message[:4000], status_code >= 500, details
|
|
return (
|
|
"QUICK_SALE_INVOICE_FAILED",
|
|
"پردازش فروش به دلیل خطای داخلی ناموفق شد. لطفاً دوباره تلاش کنید.",
|
|
True,
|
|
None,
|
|
)
|
|
|
|
|
|
def _process_job(job_id: int) -> None:
|
|
from adapters.db.session import get_db_session
|
|
from app.services.invoice_service import create_invoice
|
|
|
|
with get_db_session() as db:
|
|
job = db.query(QuickSaleInvoiceJob).filter(QuickSaleInvoiceJob.id == int(job_id)).first()
|
|
if job is None or job.status != "processing":
|
|
return
|
|
business_id = int(job.business_id)
|
|
request_id = str(job.request_id)
|
|
acquire_transaction_lock(db, f"quick_sale_invoice:{business_id}:{request_id}")
|
|
invoice = find_quick_sale_invoice(db, business_id, request_id)
|
|
if invoice is None:
|
|
payload = dict(job.payload or {})
|
|
payload.pop("_quick_sale_stock_correction_token", None)
|
|
result = create_invoice(
|
|
db=db,
|
|
business_id=business_id,
|
|
user_id=int(job.user_id),
|
|
data=payload,
|
|
user_can_select_fx_rate=bool(job.user_can_select_fx_rate),
|
|
user_can_change_invoice_unit_price=bool(job.user_can_change_invoice_unit_price),
|
|
lightweight_response=True,
|
|
)
|
|
data = result.get("data") if isinstance(result, dict) else None
|
|
if isinstance(data, dict):
|
|
invoice_id = data.get("id")
|
|
invoice_code = data.get("code")
|
|
else:
|
|
invoice_id = result.get("id") if isinstance(result, dict) else None
|
|
invoice_code = result.get("code") if isinstance(result, dict) else None
|
|
else:
|
|
invoice_id = invoice.id
|
|
invoice_code = invoice.code
|
|
|
|
job = db.query(QuickSaleInvoiceJob).filter(QuickSaleInvoiceJob.id == int(job_id)).first()
|
|
if job is None:
|
|
return
|
|
job.status = "completed"
|
|
job.invoice_id = int(invoice_id) if invoice_id is not None else None
|
|
job.invoice_code = str(invoice_code) if invoice_code is not None else None
|
|
job.error_code = None
|
|
job.error_message = None
|
|
job.error_details = None
|
|
job.locked_until = None
|
|
job.finished_at = datetime.utcnow()
|
|
db.commit()
|
|
|
|
|
|
def process_quick_sale_invoice_jobs_once() -> bool:
|
|
job_id = _claim_one_job()
|
|
if job_id is None:
|
|
return False
|
|
try:
|
|
_process_job(job_id)
|
|
except Exception as exc:
|
|
code, message, transient, details = _error_data(exc)
|
|
logger.exception("quick_sale_invoice_job_failed job_id=%s code=%s", job_id, code)
|
|
from adapters.db.session import get_db_session
|
|
with get_db_session() as db:
|
|
job = db.query(QuickSaleInvoiceJob).filter(QuickSaleInvoiceJob.id == int(job_id)).first()
|
|
if job is None:
|
|
return True
|
|
if details is not None:
|
|
payload = job.payload if isinstance(job.payload, dict) else {}
|
|
if payload.get("_quick_sale_stock_correction_token"):
|
|
details["stock_correction_already_applied"] = True
|
|
job.error_code = code
|
|
job.error_message = message
|
|
job.error_details = details
|
|
job.locked_until = None
|
|
if transient and int(job.attempt_count or 0) < MAX_ATTEMPTS:
|
|
delay_seconds = min(30 * (2 ** max(0, int(job.attempt_count or 1) - 1)), 300)
|
|
job.status = "queued"
|
|
job.available_at = datetime.utcnow() + timedelta(seconds=delay_seconds)
|
|
else:
|
|
job.status = "failed"
|
|
job.finished_at = datetime.utcnow()
|
|
db.commit()
|
|
return True
|
|
|
|
|
|
async def quick_sale_invoice_outbox_loop(interval_seconds: float = 0.5) -> None:
|
|
while True:
|
|
try:
|
|
processed = await asyncio.to_thread(process_quick_sale_invoice_jobs_once)
|
|
if processed:
|
|
continue
|
|
except Exception:
|
|
logger.exception("quick_sale_invoice_outbox_loop_failed")
|
|
await asyncio.sleep(max(5.0, interval_seconds))
|
|
continue
|
|
await asyncio.sleep(interval_seconds)
|