Files
shanxia2.0/backend/app/crud/order.py
T
2026-05-12 16:35:07 +08:00

1007 lines
35 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""订单CRUD"""
from typing import Optional, List
import json
from datetime import datetime
from decimal import Decimal
from sqlalchemy.orm import Session
from sqlalchemy import and_, or_, func, select, exists
from app.models.models import BizOrder, BizOrderItem, BizOrderStatusLog, BizOrderHis, BizOrderAdjust, SysUser
from app.crud.base import CRUDBase
from app.core.utils import generate_id
from app.core.order_status_compat import derive_three_status_from_legacy, derive_legacy_status_from_three
class OrderCRUD(CRUDBase[BizOrder]):
@staticmethod
def normalize_payment_method(payment_method: Optional[str]) -> str:
"""统一支付方式值,仅保留 online/offline。"""
method = (payment_method or "").strip().lower()
if method in ("wechat", "wx", "online"):
return "online"
if method == "offline":
return "offline"
return "online"
def sync_pay_fields_from_amounts(self, order: BizOrder) -> None:
"""根据已付/应收同步 pay_status、payment_time 与兼容字段 status(付清后才是 paid)。"""
pa = order.paid_amount or Decimal("0")
ra = order.receivable_amount or Decimal("0")
if ra > 0 and pa >= ra:
order.pay_status = "paid"
if not order.payment_time:
order.payment_time = datetime.now()
else:
order.pay_status = "pending_payment"
order.status = derive_legacy_status_from_three(
order_status=getattr(order, "order_status", None) or "pending_confirm",
delivery_status=getattr(order, "delivery_status", None) or "pending_dispatch",
pay_status=order.pay_status,
)
"""订单CRUD操作"""
def _sync_three_status_fields_from_legacy(self, order: BizOrder):
"""阶段A:保持三字段与旧 status 一致(先兼容,再逐步迁移逻辑)。"""
ts = derive_three_status_from_legacy(order.status, paid_amount=order.paid_amount)
order.order_status = ts.order_status
order.delivery_status = ts.delivery_status
order.pay_status = ts.pay_status
def _apply_three_status(self, order: BizOrder, *, order_status: str = None, delivery_status: str = None, pay_status: str = None):
"""阶段D收尾:优先写三字段,再回写兼容 status。"""
if order_status is not None:
order.order_status = order_status
if delivery_status is not None:
order.delivery_status = delivery_status
if pay_status is not None:
order.pay_status = pay_status
order.status = derive_legacy_status_from_three(
order_status=order.order_status,
delivery_status=order.delivery_status,
pay_status=order.pay_status,
)
def get_by_client(self, db: Session, client_id: str) -> List[BizOrder]:
"""根据客户获取订单列表"""
return db.query(BizOrder).filter(
and_(
BizOrder.client_id == client_id,
BizOrder.is_del == 0
)
).order_by(BizOrder.create_at.desc()).all()
def get_multi_with_filters(
self,
db: Session,
client_id: str = None,
region_id: str = None,
status: str = None,
order_status: str = None,
delivery_status: str = None,
pay_status: str = None,
payment_method: str = None,
cancel_status: str = None,
order_no: str = None,
keyword: str = None,
start_date: str = None,
end_date: str = None,
skip: int = 0,
limit: int = 10,
list_tab: str = None,
) -> tuple[List[BizOrder], int]:
"""多条件查询订单"""
query = db.query(BizOrder).filter(BizOrder.is_del == 0)
if client_id:
query = query.filter(BizOrder.client_id == client_id)
if region_id:
query = query.filter(BizOrder.region_id == region_id)
if status:
query = query.filter(BizOrder.status == status)
if order_status:
query = query.filter(BizOrder.order_status == order_status)
if delivery_status:
query = query.filter(BizOrder.delivery_status == delivery_status)
if pay_status:
query = query.filter(BizOrder.pay_status == pay_status)
if payment_method:
pm = self.normalize_payment_method(payment_method)
if pm == "offline":
query = query.filter(BizOrder.payment_method == "offline")
else:
query = query.filter(
or_(
BizOrder.payment_method == "online",
BizOrder.payment_method.is_(None),
BizOrder.payment_method == "",
)
)
if cancel_status:
query = query.filter(BizOrder.cancel_status == cancel_status)
if order_no:
query = query.filter(BizOrder.order_no.like(f"%{order_no}%"))
if keyword:
kw = (keyword or "").strip()
if kw:
pattern = f"%{kw}%"
client_user_match = exists(
select(1).select_from(SysUser).where(
and_(
SysUser.id == BizOrder.client_id,
SysUser.is_del == 0,
or_(
SysUser.real_name.like(pattern),
SysUser.username.like(pattern),
SysUser.phone.like(pattern),
),
)
)
)
query = query.filter(
or_(
BizOrder.order_no.like(pattern),
BizOrder.contact_person.like(pattern),
BizOrder.contact_phone.like(pattern),
client_user_match,
)
)
if start_date:
query = query.filter(BizOrder.create_at >= start_date)
if end_date:
query = query.filter(BizOrder.create_at <= end_date)
# 客户端订单列表 Tab(与小程序 order.vue 分段一致,保证分页有效)
if list_tab == "pending_payment":
query = query.filter(
and_(
BizOrder.order_status == "pending_payment",
BizOrder.pay_status == "pending_payment",
BizOrder.cancel_status != "pending_review",
)
)
elif list_tab == "pending_confirm":
query = query.filter(
and_(
BizOrder.order_status == "pending_confirm",
BizOrder.cancel_status != "pending_review",
)
)
elif list_tab == "completed":
query = query.filter(BizOrder.order_status == "completed")
elif list_tab == "cancelled":
query = query.filter(BizOrder.order_status == "cancelled")
total = query.count()
orders = query.order_by(BizOrder.create_at.desc()).offset(skip).limit(limit).all()
return orders, total
def get_by_order_no(self, db: Session, order_no: str) -> Optional[BizOrder]:
"""根据订单号获取订单"""
return db.query(BizOrder).filter(
and_(
BizOrder.order_no == order_no,
BizOrder.is_del == 0
)
).first()
def create_order(
self,
db: Session,
client_id: str,
region_id: str,
price_list_id: str,
price_version: int,
items: List[dict],
address_id: str,
address_info: dict,
payment_method: str,
remark: str = None,
creator: dict = None
) -> BizOrder:
"""创建订单"""
# 生成订单号
order_no = self._generate_order_no(db)
# 计算订单总金额
total_amount = sum(
Decimal(str(item.get("quantity", 0))) * Decimal(str(item.get("unitPrice", 0)))
for item in items
)
normalized_payment_method = self.normalize_payment_method(payment_method)
# 线上:未支付前主状态为待支付;线下:未收款前 pay_status 仍为待支付,但主状态进入待收货/履约阶段,可与 pending_dispatch 一并参与分配配送
if normalized_payment_method == "offline":
init_order_status = "pending_confirm"
else:
init_order_status = "pending_payment"
init_delivery_status = "pending_dispatch"
init_pay_status = "pending_payment"
order = BizOrder(
id=generate_id(),
order_no=order_no,
region_id=region_id,
client_id=client_id,
price_list_id=price_list_id,
price_version=price_version,
status=derive_legacy_status_from_three(
order_status=init_order_status,
delivery_status=init_delivery_status,
pay_status=init_pay_status,
),
order_status=init_order_status,
delivery_status=init_delivery_status,
pay_status=init_pay_status,
cancel_status="none",
payment_method=normalized_payment_method,
client_settlement_status="settled" if normalized_payment_method == "online" else "pending",
supplier_settlement_status="pending",
client_settlement_at=datetime.now() if normalized_payment_method == "online" else None,
supplier_settlement_at=None,
total_amount=total_amount,
paid_amount=Decimal("0"),
receivable_amount=total_amount,
refund_amount=Decimal("0"),
contact_person=address_info.get("contactPerson"),
contact_phone=address_info.get("contactPhone"),
delivery_address=address_info.get("fullAddress"),
remark=remark,
payment_time=None,
create_by=creator.get("user_id") if creator else None,
create_name=creator.get("real_name") if creator else None
)
db.add(order)
db.flush()
# 创建订单项
for item in items:
amount = Decimal(str(item.get("quantity", 0))) * Decimal(str(item.get("unitPrice", 0)))
order_item = BizOrderItem(
id=generate_id(),
order_id=order.id,
product_id=item.get("productId"),
unit_id=item.get("unitId"),
quantity=Decimal(str(item.get("quantity", 0))),
unit_price=Decimal(str(item.get("unitPrice", 0))),
amount=amount,
delivered_quantity=Decimal("0"),
status="normal",
note=item.get("note"),
create_by=creator.get("user_id") if creator else None,
create_name=creator.get("real_name") if creator else None
)
db.add(order_item)
# 创建订单状态日志
self._create_status_log(
db,
order.id,
None,
order.status,
creator.get("user_id") if creator else client_id,
"client",
"创建订单"
)
db.commit()
db.refresh(order)
return order
def update_status(
self,
db: Session,
order_id: str,
new_status: str,
operator_id: str,
operator_role: str,
reason: str = None,
note: str = None
) -> Optional[BizOrder]:
"""更新订单状态"""
order = self.get(db, order_id)
if not order:
return None
old_status = order.status
order.status = new_status
order.update_at = datetime.now()
# 特殊状态处理
if new_status == "paid":
order.payment_time = datetime.now()
elif new_status == "completed":
order.completed_time = datetime.now()
order.completed_by = operator_id
# 阶段A:同步三字段
self._sync_three_status_fields_from_legacy(order)
# 创建状态变更日志
self._create_status_log(
db,
order_id,
old_status,
new_status,
operator_id,
operator_role,
reason,
note
)
db.commit()
db.refresh(order)
return order
def cancel_order(
self,
db: Session,
order_id: str,
cancel_type: str,
reason: str,
operator_id: str,
operator_role: str
) -> Optional[BizOrder]:
"""取消订单"""
order = self.get(db, order_id)
if not order:
return None
# 待支付订单直接取消
if order.status == "pending_payment":
return self.update_status(
db,
order_id,
"cancelled",
operator_id,
operator_role,
reason=reason
)
# 已支付订单申请取消
if order.delivery_status in ["pending_dispatch", "delivering"]:
self._apply_three_status(order, order_status="pending_confirm")
order.cancel_status = "pending_review"
order.cancel_reason = reason
order.update_at = datetime.now()
self._create_status_log(
db,
order_id,
order.status,
"pending_review_cancel", # 兼容历史日志标识
operator_id,
operator_role,
reason=reason
)
db.commit()
db.refresh(order)
return order
return None
def review_cancel(
self,
db: Session,
order_id: str,
approved: bool,
reviewer_id: str,
review_note: str = None
) -> Optional[BizOrder]:
"""审核取消订单"""
order = self.get(db, order_id)
if not order or order.cancel_status != "pending_review":
return None
if approved:
order.cancel_status = "approved"
self._apply_three_status(order, order_status="cancelled")
new_status = order.status
else:
# 从状态日志获取取消前的状态
from app.models.models import BizOrderStatusLog
cancel_log = db.query(BizOrderStatusLog).filter(
BizOrderStatusLog.order_id == order_id,
BizOrderStatusLog.to_status == "pending_review_cancel"
).order_by(BizOrderStatusLog.create_at.desc()).first()
# 恢复为取消前的状态(pending_delivery, delivering, partial_delivered)
if cancel_log and cancel_log.from_status:
# 兼容历史:尽量从旧状态恢复到三字段
order.status = cancel_log.from_status
self._sync_three_status_fields_from_legacy(order)
else:
self._apply_three_status(order, order_status="pending_confirm", delivery_status="pending_dispatch")
order.cancel_status = "rejected"
new_status = order.status
order.cancel_review_time = datetime.now()
order.cancel_reviewed_by = reviewer_id
order.cancel_review_note = review_note
order.update_at = datetime.now()
self._create_status_log(
db,
order_id,
"pending_review_cancel",
new_status,
reviewer_id,
"admin",
reason=f"审核{'通过' if approved else '拒绝'}: {review_note}"
)
db.commit()
db.refresh(order)
return order
def confirm_receive(
self,
db: Session,
order_id: str,
operator_id: str
) -> Optional[BizOrder]:
"""确认收货"""
order = self.get(db, order_id)
if not order:
return None
# 仅待确认收货状态支持确认收货
if order.status == "pending_confirm":
return self.update_status(
db,
order_id,
"completed",
operator_id,
"client",
reason="客户确认收货"
)
return None
def auto_confirm_receive_overdue(
self,
db: Session,
*,
before_threshold: datetime,
configured_days: int,
) -> int:
"""送达后超过 configured_days 未确认收货的订单,系统自动确认(与 force_complete 一致写三字段与日志)。"""
threshold_expr = func.coalesce(BizOrder.delivered_time, BizOrder.update_at)
orders = (
db.query(BizOrder)
.filter(
BizOrder.is_del == 0,
BizOrder.order_status == "pending_confirm",
BizOrder.delivery_status == "delivered",
BizOrder.cancel_status.in_(("none", "rejected")),
threshold_expr <= before_threshold,
)
.all()
)
if not orders:
return 0
note = f"送达后超过{configured_days}天未确认收货,系统自动确认"
count = 0
for order in orders:
old_status = order.status
self._apply_three_status(order, order_status="completed")
order.completed_time = datetime.now()
order.completed_by = "system"
order.update_at = datetime.now()
self._create_status_log(
db,
order.id,
old_status,
"completed",
"system",
"system",
reason=note,
)
count += 1
db.commit()
return count
def _generate_order_no(self, db: Session) -> str:
"""生成订单号"""
today = datetime.now().strftime("%Y%m%d")
prefix = f"ORD{today}"
# 查询当天最大订单号
last_order = db.query(BizOrder).filter(
BizOrder.order_no.like(f"{prefix}%")
).order_by(BizOrder.order_no.desc()).first()
if last_order:
last_no = int(last_order.order_no[-4:])
new_no = last_no + 1
else:
new_no = 1
return f"{prefix}{str(new_no).zfill(4)}"
def _create_status_log(
self,
db: Session,
order_id: str,
from_status: str,
to_status: str,
operator_id: str,
operator_role: str,
reason: str = None,
note: str = None,
create_name: str = None,
log_create_at: Optional[datetime] = None,
):
"""创建订单状态变更日志"""
ts = log_create_at or datetime.now()
log = BizOrderStatusLog(
id=generate_id(),
order_id=order_id,
from_status=from_status,
to_status=to_status,
operator_id=operator_id,
operator_role=operator_role,
reason=reason,
note=note,
create_by=operator_id,
create_name=create_name or None,
create_at=ts,
update_at=ts,
)
db.add(log)
def close_unpaid_online_orders(
self,
db: Session,
*,
before_time: datetime,
timeout_note: str,
) -> int:
"""关闭超时未支付的线上订单。"""
candidates = db.query(BizOrder).filter(
BizOrder.is_del == 0,
BizOrder.payment_method == "online",
BizOrder.pay_status == "pending_payment",
BizOrder.order_status == "pending_payment",
BizOrder.create_at <= before_time,
).all()
count = 0
for order in candidates:
self._apply_three_status(order, order_status="cancelled", delivery_status="pending_dispatch", pay_status="pending_payment")
order.cancel_status = "approved"
order.cancel_reason = "线上支付超时自动关闭"
order.cancel_review_note = "系统自动关闭"
order.update_at = datetime.now()
self._create_status_log(
db,
order.id,
"pending_payment",
"cancelled",
"system",
"system",
reason="线上支付超时自动关闭",
note=timeout_note,
)
count += 1
if count:
db.commit()
return count
def admin_cancel(
self,
db: Session,
*,
order_id: str,
operator_id: str,
operator_name: str,
reason: str,
note: Optional[str] = None,
evidence_image_urls: Optional[List[str]] = None,
) -> Optional[BizOrder]:
"""运营取消订单。"""
order = self.get(db, order_id)
if not order:
return None
old_status = order.status
self._apply_three_status(order, order_status="cancelled")
order.cancel_status = "approved"
order.cancel_reason = reason
if note:
order.cancel_review_note = note
order.cancel_review_time = datetime.now()
order.cancel_reviewed_by = operator_id
order.update_at = datetime.now()
self._create_status_log(
db,
order.id,
old_status,
"cancelled",
operator_id,
"admin",
reason=reason,
note=json.dumps({"note": note or "", "evidenceImageUrls": evidence_image_urls or []}, ensure_ascii=False),
)
db.commit()
db.refresh(order)
return order
def update_with_history(self, db: Session, id: str, obj_in: dict, updater: dict = None) -> Optional[BizOrder]:
"""更新订单并记录历史"""
original = self.get(db, id)
if not original:
return None
his_data = {
"id": original.id,
"order_no": original.order_no,
"region_id": original.region_id,
"client_id": original.client_id,
"price_list_id": original.price_list_id,
"price_version": original.price_version,
"status": original.status,
"order_status": getattr(original, "order_status", None),
"delivery_status": getattr(original, "delivery_status", None),
"pay_status": getattr(original, "pay_status", None),
"cancel_status": getattr(original, "cancel_status", None),
"payment_method": original.payment_method,
"client_settlement_status": getattr(original, "client_settlement_status", "pending"),
"supplier_settlement_status": getattr(original, "supplier_settlement_status", "pending"),
"client_settlement_at": getattr(original, "client_settlement_at", None),
"supplier_settlement_at": getattr(original, "supplier_settlement_at", None),
"total_amount": original.total_amount,
"paid_amount": original.paid_amount,
"receivable_amount": original.receivable_amount,
"refund_amount": original.refund_amount,
"contact_person": original.contact_person,
"contact_phone": original.contact_phone,
"delivery_address": original.delivery_address,
"cancel_reason": original.cancel_reason,
"cancel_review_time": original.cancel_review_time,
"cancel_reviewed_by": original.cancel_reviewed_by,
"cancel_review_note": original.cancel_review_note,
"completed_time": original.completed_time,
"completed_by": original.completed_by,
"remark": original.remark,
"payment_time": original.payment_time,
"delivery_assign_time": original.delivery_assign_time,
"delivered_time": getattr(original, "delivered_time", None),
"create_at": original.create_at,
"create_by": original.create_by,
"create_name": original.create_name,
"update_at": original.update_at,
"update_by": original.update_by,
}
his = BizOrderHis(**his_data)
db.add(his)
return self.update(db, id, obj_in, updater)
def soft_delete_with_history(self, db: Session, id: str) -> bool:
"""删除订单并记录历史"""
original = self.get(db, id)
if not original:
return False
his_data = {
"id": original.id,
"order_no": original.order_no,
"region_id": original.region_id,
"client_id": original.client_id,
"price_list_id": original.price_list_id,
"price_version": original.price_version,
"status": original.status,
"order_status": getattr(original, "order_status", None),
"delivery_status": getattr(original, "delivery_status", None),
"pay_status": getattr(original, "pay_status", None),
"cancel_status": getattr(original, "cancel_status", None),
"payment_method": original.payment_method,
"client_settlement_status": getattr(original, "client_settlement_status", "pending"),
"supplier_settlement_status": getattr(original, "supplier_settlement_status", "pending"),
"client_settlement_at": getattr(original, "client_settlement_at", None),
"supplier_settlement_at": getattr(original, "supplier_settlement_at", None),
"total_amount": original.total_amount,
"paid_amount": original.paid_amount,
"receivable_amount": original.receivable_amount,
"refund_amount": original.refund_amount,
"contact_person": original.contact_person,
"contact_phone": original.contact_phone,
"delivery_address": original.delivery_address,
"delivered_time": getattr(original, "delivered_time", None),
"create_at": original.create_at,
"create_by": original.create_by,
"create_name": original.create_name,
"update_at": original.update_at,
"update_by": original.update_by,
}
his = BizOrderHis(**his_data)
db.add(his)
return self.delete(db, id)
def lock_order(
self,
db: Session,
order_id: str,
operator_id: str
) -> Optional[BizOrder]:
"""锁定订单,防止并发操作"""
order = self.get(db, order_id)
if not order:
return None
# 如果已被其他操作员锁定,不能重复锁定
if order.lock_operator_id and order.lock_operator_id != operator_id:
lock_time = order.lock_time.strftime("%Y-%m-%d %H:%M:%S") if order.lock_time else "未知"
raise ValueError(f"订单已被用户 {order.lock_operator_id} 于 {lock_time} 锁定")
order.lock_operator_id = operator_id
order.lock_time = datetime.now()
order.update_at = datetime.now()
db.commit()
db.refresh(order)
return order
def unlock_order(
self,
db: Session,
order_id: str,
operator_id: str
) -> Optional[BizOrder]:
"""解锁订单"""
order = self.get(db, order_id)
if not order:
return None
# 只能解锁自己锁定的订单
if order.lock_operator_id and order.lock_operator_id != operator_id:
raise ValueError("只能解锁自己锁定的订单")
order.lock_operator_id = None
order.lock_time = None
order.update_at = datetime.now()
db.commit()
db.refresh(order)
return order
def force_complete(
self,
db: Session,
order_id: str,
operator_id: str,
operator_role: str,
reason: str = None
) -> Optional[BizOrder]:
"""运营强制完结订单"""
order = self.get(db, order_id)
if not order:
return None
# 只有待确认收货状态可以强制完结
if order.order_status not in ["pending_confirm"]:
raise ValueError("只有待确认收货状态的订单可以强制完结")
old_status = order.status
self._apply_three_status(order, order_status="completed")
order.completed_time = datetime.now()
order.completed_by = operator_id
order.update_at = datetime.now()
# 记录状态变更
self._create_status_log(
db,
order_id,
old_status,
"completed",
operator_id,
operator_role,
reason=reason or "运营强制完结"
)
db.commit()
db.refresh(order)
return order
def update_to_partial_delivered(
self,
db: Session,
order_id: str,
operator_id: str,
operator_role: str,
reason: str = None
) -> Optional[BizOrder]:
"""已废弃:旧的部分送达流程不再支持。"""
raise ValueError("部分送达流程已下线")
def update_to_confirm(
self,
db: Session,
order_id: str,
operator_id: str,
operator_role: str,
reason: str = None
) -> Optional[BizOrder]:
"""已废弃:旧的部分送达确认流程不再支持。"""
raise ValueError("部分送达确认流程已下线")
class OrderItemCRUD(CRUDBase[BizOrderItem]):
"""订单项CRUD操作"""
def get_by_order(self, db: Session, order_id: str) -> List[BizOrderItem]:
"""获取订单的所有订单项"""
return db.query(BizOrderItem).filter(
and_(
BizOrderItem.order_id == order_id,
BizOrderItem.is_del == 0
)
).all()
def get_count_by_order(self, db: Session, order_id: str) -> int:
"""获取订单项数量"""
return db.query(BizOrderItem).filter(
and_(
BizOrderItem.order_id == order_id,
BizOrderItem.is_del == 0
)
).count()
def update_item_adjustment(
self,
db: Session,
item_id: str,
new_quantity: Decimal = None,
new_amount: Decimal = None,
new_status: str = None,
note: str = None,
updater_id: str = None,
updater_name: str = None
) -> Optional[BizOrderItem]:
"""更新订单项(调整后)"""
item = self.get(db, item_id)
if not item:
return None
if new_quantity is not None:
item.quantity = new_quantity
if new_amount is not None:
item.amount = new_amount
if new_status is not None:
item.status = new_status
if note is not None:
item.note = note
item.update_at = datetime.now()
item.update_by = updater_id
db.commit()
db.refresh(item)
return item
def mark_as_reduced(
self,
db: Session,
item_id: str,
new_quantity: Decimal,
new_amount: Decimal,
note: str = None
) -> Optional[BizOrderItem]:
"""标记为已减量"""
return self.update_item_adjustment(
db, item_id,
new_quantity=new_quantity,
new_amount=new_amount,
new_status="reduced",
note=note
)
def mark_as_deleted(
self,
db: Session,
item_id: str,
note: str = None
) -> Optional[BizOrderItem]:
"""标记为已删除"""
return self.update_item_adjustment(
db, item_id,
new_status="deleted",
note=note
)
def mark_as_substituted(
self,
db: Session,
item_id: str,
new_product_id: str,
new_quantity: Decimal,
new_amount: Decimal,
note: str = None
) -> Optional[BizOrderItem]:
"""标记为已替代"""
item = self.update_item_adjustment(
db, item_id,
new_status="substituted",
note=note
)
return item
class OrderStatusLogCRUD(CRUDBase[BizOrderStatusLog]):
"""订单状态日志CRUD操作"""
def get_by_order(self, db: Session, order_id: str) -> List[BizOrderStatusLog]:
"""获取订单的状态变更日志"""
return db.query(BizOrderStatusLog).filter(
BizOrderStatusLog.order_id == order_id
).order_by(BizOrderStatusLog.create_at.asc()).all()
class OrderAdjustCRUD(CRUDBase[BizOrderAdjust]):
"""订单调整记录CRUD操作"""
def get_by_order(self, db: Session, order_id: str) -> List[BizOrderAdjust]:
"""获取订单的所有调整记录"""
return db.query(BizOrderAdjust).filter(
and_(
BizOrderAdjust.order_id == order_id,
BizOrderAdjust.is_del == 0
)
).order_by(BizOrderAdjust.create_at.desc()).all()
def get_by_order_item(self, db: Session, order_item_id: str) -> List[BizOrderAdjust]:
"""获取订单项的调整记录"""
return db.query(BizOrderAdjust).filter(
and_(
BizOrderAdjust.order_item_id == order_item_id,
BizOrderAdjust.is_del == 0
)
).order_by(BizOrderAdjust.create_at.desc()).all()
def create_adjust_record(
self,
db: Session,
order_id: str,
adjust_type: str,
operator_id: str,
operator_name: str,
order_item_id: str = None,
before_quantity: Decimal = None,
after_quantity: Decimal = None,
before_amount: Decimal = None,
after_amount: Decimal = None,
difference_amount: Decimal = None,
reason: str = None,
substitute_product_id: str = None,
snapshot_items_json: Optional[str] = None,
) -> BizOrderAdjust:
"""创建调整记录"""
adjust_record = BizOrderAdjust(
id=generate_id(),
order_id=order_id,
order_item_id=order_item_id,
adjust_type=adjust_type,
before_quantity=before_quantity,
after_quantity=after_quantity,
before_amount=before_amount,
after_amount=after_amount,
difference_amount=difference_amount or Decimal("0"),
reason=reason,
substitute_product_id=substitute_product_id,
snapshot_items_json=snapshot_items_json,
operator_id=operator_id,
operator_name=operator_name,
create_by=operator_id,
create_name=operator_name
)
db.add(adjust_record)
db.commit()
db.refresh(adjust_record)
return adjust_record
order_crud = OrderCRUD(BizOrder)
order_item_crud = OrderItemCRUD(BizOrderItem)
order_status_log_crud = OrderStatusLogCRUD(BizOrderStatusLog)
order_adjust_crud = OrderAdjustCRUD(BizOrderAdjust)