|
|
import random
|
|
|
from datetime import datetime, timedelta
|
|
|
|
|
|
from sqlalchemy import select
|
|
|
|
|
|
from app.core.base_schema import AuthSchema
|
|
|
from app.core.exceptions import CustomException
|
|
|
from app.core.logger import logger
|
|
|
from app.utils.payment import create_payment_gateway
|
|
|
|
|
|
from .crud import OrderCRUD, PaymentRecordCRUD, RefundCRUD
|
|
|
from .model import OrderModel
|
|
|
from .schema import (
|
|
|
OrderCreateInternalSchema,
|
|
|
OrderCreateSchema,
|
|
|
OrderOutSchema,
|
|
|
OrderQueryParam,
|
|
|
OrderStatusMessage,
|
|
|
OrderUpdateInternalSchema,
|
|
|
PaymentCreateOut,
|
|
|
PaymentRecordCreateSchema,
|
|
|
PaymentRecordOutSchema,
|
|
|
PaymentStatusOut,
|
|
|
RefundApplySchema,
|
|
|
RefundCreateSchema,
|
|
|
RefundOutSchema,
|
|
|
RefundReviewSchema,
|
|
|
RefundUpdateSchema,
|
|
|
)
|
|
|
|
|
|
|
|
|
def _generate_order_no() -> str:
|
|
|
"""生成订单号：YYYYMMDD + 6位随机数"""
|
|
|
today = datetime.now().strftime("%Y%m%d")
|
|
|
suffix = str(random.randint(100000, 999999))
|
|
|
return f"{today}{suffix}"
|
|
|
|
|
|
|
|
|
def _generate_refund_no() -> str:
|
|
|
"""生成退款单号"""
|
|
|
today = datetime.now().strftime("%Y%m%d")
|
|
|
suffix = str(random.randint(100000, 999999))
|
|
|
return f"RF{today}{suffix}"
|
|
|
|
|
|
|
|
|
class OrderService:
|
|
|
"""
|
|
|
订单管理服务
|
|
|
"""
|
|
|
|
|
|
@classmethod
|
|
|
async def create_order(cls, auth: AuthSchema, data: OrderCreateSchema, amount: int | None = None) -> OrderOutSchema:
|
|
|
"""
|
|
|
创建订单
|
|
|
|
|
|
套餐订单：amount 从套餐价格自动计算
|
|
|
插件订单：amount 从插件价格自动计算
|
|
|
免费订单（amount=0）：自动激活
|
|
|
|
|
|
参数:
|
|
|
- auth (AuthSchema): 认证信息模型
|
|
|
- data (OrderCreateSchema): 订单创建模型
|
|
|
- amount (int | None): 订单金额(分)，None 时自动计算
|
|
|
|
|
|
返回:
|
|
|
- OrderOutSchema: 新创建的订单详情
|
|
|
"""
|
|
|
if amount is None:
|
|
|
if data.order_type == "plugin":
|
|
|
from app.api.v1.module_platform.plugin.model import PluginModel
|
|
|
|
|
|
plugin = await auth.db.get(PluginModel, data.plugin_id)
|
|
|
amount = plugin.price if plugin else 0
|
|
|
else:
|
|
|
from app.api.v1.module_platform.package.model import PackageModel
|
|
|
|
|
|
pkg = await auth.db.get(PackageModel, data.package_id)
|
|
|
amount = pkg.price if pkg else 0
|
|
|
|
|
|
order = await OrderCRUD(auth).create(
|
|
|
OrderCreateInternalSchema(
|
|
|
order_no=_generate_order_no(),
|
|
|
tenant_id=data.tenant_id,
|
|
|
package_id=data.package_id,
|
|
|
plugin_id=data.plugin_id,
|
|
|
order_type=data.order_type,
|
|
|
amount=amount,
|
|
|
expire_time=datetime.now() + timedelta(minutes=15),
|
|
|
)
|
|
|
)
|
|
|
|
|
|
# 免费订单自动激活
|
|
|
if amount == 0:
|
|
|
await OrderCRUD(auth).update(
|
|
|
order.id,
|
|
|
OrderUpdateInternalSchema(status=1, pay_method="free", pay_time=datetime.now()),
|
|
|
)
|
|
|
await PaymentService._activate_tenant_package(auth, order)
|
|
|
await auth.db.refresh(order)
|
|
|
|
|
|
return OrderOutSchema.model_validate(order)
|
|
|
|
|
|
@classmethod
|
|
|
async def get_detail(cls, auth: AuthSchema, order_id: int) -> OrderOutSchema | None:
|
|
|
"""
|
|
|
订单详情
|
|
|
|
|
|
参数:
|
|
|
- auth (AuthSchema): 认证信息模型
|
|
|
- order_id (int): 订单ID
|
|
|
|
|
|
返回:
|
|
|
- OrderOutSchema | None: 订单详情，不存在时返回 None
|
|
|
"""
|
|
|
order = await OrderCRUD(auth).get_by_id(order_id)
|
|
|
return OrderOutSchema.model_validate(order) if order else None
|
|
|
|
|
|
@classmethod
|
|
|
async def get_list(
|
|
|
cls,
|
|
|
auth: AuthSchema,
|
|
|
page_no: int,
|
|
|
page_size: int,
|
|
|
search: OrderQueryParam,
|
|
|
order_by: list[dict[str, str]] | None = None,
|
|
|
) -> tuple[list, int]:
|
|
|
"""
|
|
|
订单列表
|
|
|
|
|
|
参数:
|
|
|
- auth (AuthSchema): 认证信息模型
|
|
|
- page_no (int): 当前页码
|
|
|
- page_size (int): 每页数量
|
|
|
- search (OrderQueryParam): 查询参数
|
|
|
- order_by (list[dict] | None): 排序字段
|
|
|
|
|
|
返回:
|
|
|
- tuple[list, int]: (订单列表, 总数)
|
|
|
"""
|
|
|
offset = (page_no - 1) * page_size
|
|
|
rows, total = await OrderCRUD(auth).query(
|
|
|
tenant_id=search.tenant_id,
|
|
|
status=search.status,
|
|
|
order_type=search.order_type,
|
|
|
offset=offset,
|
|
|
limit=page_size,
|
|
|
)
|
|
|
items = [OrderOutSchema.model_validate(r) for r in rows]
|
|
|
return items, total
|
|
|
|
|
|
@classmethod
|
|
|
async def cancel_order(cls, auth: AuthSchema, order_id: int) -> OrderStatusMessage:
|
|
|
"""
|
|
|
取消订单
|
|
|
|
|
|
参数:
|
|
|
- auth (AuthSchema): 认证信息模型
|
|
|
- order_id (int): 订单ID
|
|
|
|
|
|
返回:
|
|
|
- OrderStatusMessage: 取消结果
|
|
|
"""
|
|
|
crud = OrderCRUD(auth)
|
|
|
order = await crud.get_by_id(order_id)
|
|
|
if not order:
|
|
|
raise CustomException(msg="该数据不存在")
|
|
|
if order.status != 0:
|
|
|
raise CustomException(msg="仅待支付订单可取消")
|
|
|
await crud.update(order_id, OrderUpdateInternalSchema(status=2))
|
|
|
return OrderStatusMessage(id=order.id, status=2, message="已取消")
|
|
|
|
|
|
@classmethod
|
|
|
async def check_payment_status(cls, auth: AuthSchema, order_id: int) -> PaymentStatusOut:
|
|
|
"""
|
|
|
查询订单支付状态（供前端轮询用）
|
|
|
|
|
|
参数:
|
|
|
- auth (AuthSchema): 认证信息模型
|
|
|
- order_id (int): 订单ID
|
|
|
|
|
|
返回:
|
|
|
- PaymentStatusOut: 支付状态信息
|
|
|
"""
|
|
|
order = await OrderCRUD(auth).get_by_id(order_id)
|
|
|
if not order:
|
|
|
return PaymentStatusOut(exists=False)
|
|
|
return PaymentStatusOut(
|
|
|
exists=True,
|
|
|
order_id=order.id,
|
|
|
status=order.status,
|
|
|
paid=order.status == 1,
|
|
|
pay_method=order.pay_method,
|
|
|
pay_time=order.pay_time.isoformat() if order.pay_time else None,
|
|
|
)
|
|
|
|
|
|
@staticmethod
|
|
|
async def cancel_expired_orders() -> None:
|
|
|
from sqlalchemy import update as sa_update
|
|
|
|
|
|
from app.core.database import async_db_session
|
|
|
|
|
|
now = datetime.now()
|
|
|
async with async_db_session() as session:
|
|
|
async with session.begin():
|
|
|
result = await session.execute(
|
|
|
sa_update(OrderModel)
|
|
|
.where(OrderModel.status == 0)
|
|
|
.where(OrderModel.expire_time < now)
|
|
|
.where(OrderModel.is_deleted == False) # noqa: E712
|
|
|
.values(status=2)
|
|
|
)
|
|
|
logger.info(f"超时订单取消: 已取消 {result.rowcount} 条订单")
|
|
|
|
|
|
|
|
|
class PaymentService:
|
|
|
"""
|
|
|
支付管理服务
|
|
|
"""
|
|
|
|
|
|
@classmethod
|
|
|
async def create_payment(cls, auth: AuthSchema, order_id: int, method: str, notify_base_url: str) -> PaymentCreateOut:
|
|
|
"""
|
|
|
创建支付（调用支付网关）
|
|
|
|
|
|
参数:
|
|
|
- auth (AuthSchema): 认证信息模型
|
|
|
- order_id (int): 订单ID
|
|
|
- method (str): 支付方式(alipay/wxpay)
|
|
|
- notify_base_url (str): 回调基础URL
|
|
|
|
|
|
返回:
|
|
|
- PaymentCreateOut: 支付创建结果（支付URL/二维码）
|
|
|
"""
|
|
|
from app.api.v1.module_platform.package.model import PackageModel
|
|
|
|
|
|
order = await OrderCRUD(auth).get_by_id(order_id)
|
|
|
if not order:
|
|
|
raise CustomException(msg="该数据不存在")
|
|
|
if order.status != 0:
|
|
|
raise CustomException(msg="订单状态异常，无法支付")
|
|
|
if order.amount <= 0:
|
|
|
raise CustomException(msg="免费订单无需支付")
|
|
|
|
|
|
if order.order_type == "plugin":
|
|
|
from app.api.v1.module_platform.plugin.model import PluginModel
|
|
|
|
|
|
plugin = await auth.db.get(PluginModel, order.plugin_id)
|
|
|
subject = f"FastapiAdmin - 插件 {plugin.name}" if plugin else "FastapiAdmin 插件"
|
|
|
else:
|
|
|
pkg = await auth.db.get(PackageModel, order.package_id)
|
|
|
subject = f"FastapiAdmin - {pkg.name}" if pkg else "FastapiAdmin 套餐"
|
|
|
|
|
|
notify_url = f"{notify_base_url}/api/v1/platform/payment/callback/{method}" if method else ""
|
|
|
|
|
|
gateway = create_payment_gateway(method)
|
|
|
info = await gateway.create_payment(
|
|
|
order_no=order.order_no,
|
|
|
amount=order.amount,
|
|
|
subject=subject,
|
|
|
notify_url=notify_url,
|
|
|
)
|
|
|
return PaymentCreateOut(
|
|
|
pay_url=info.pay_url,
|
|
|
qr_code_url=info.qr_code_url,
|
|
|
trade_no=info.trade_no,
|
|
|
order_id=order.id,
|
|
|
order_no=order.order_no,
|
|
|
amount=order.amount,
|
|
|
)
|
|
|
|
|
|
@classmethod
|
|
|
async def handle_callback(cls, auth: AuthSchema, method: str, callback_data: dict) -> dict:
|
|
|
"""
|
|
|
处理支付回调
|
|
|
|
|
|
参数:
|
|
|
- auth (AuthSchema): 认证信息模型
|
|
|
- method (str): 支付方式
|
|
|
- callback_data (dict): 支付网关回调数据
|
|
|
|
|
|
返回:
|
|
|
- dict: 处理结果
|
|
|
"""
|
|
|
gateway = create_payment_gateway(method)
|
|
|
callback_result = await gateway.verify_callback(callback_data)
|
|
|
|
|
|
if not callback_result.verified:
|
|
|
logger.warning(f"支付回调验签失败: method={method} data={callback_data}")
|
|
|
raise CustomException(msg="支付回调验签失败")
|
|
|
|
|
|
order_no = callback_data.get("order_no") or callback_data.get("out_trade_no", "")
|
|
|
o_crud = OrderCRUD(auth)
|
|
|
order = None
|
|
|
if order_no:
|
|
|
order = await o_crud.get_by_order_no(order_no)
|
|
|
elif callback_result.order_id:
|
|
|
order = await o_crud.get_by_id(callback_result.order_id)
|
|
|
|
|
|
if not order:
|
|
|
raise CustomException(msg="该数据不存在")
|
|
|
if order.status != 0:
|
|
|
raise CustomException(msg="订单状态异常")
|
|
|
if order.amount != callback_result.amount and callback_result.amount > 0:
|
|
|
raise CustomException(msg="金额不一致")
|
|
|
|
|
|
pid = order.package_id
|
|
|
tid = order.tenant_id
|
|
|
otype = order.order_type
|
|
|
oid = order.id
|
|
|
|
|
|
await o_crud.update(
|
|
|
oid,
|
|
|
OrderUpdateInternalSchema(status=1, pay_method=method, pay_time=datetime.now()),
|
|
|
)
|
|
|
|
|
|
await PaymentRecordCRUD(auth).create(
|
|
|
PaymentRecordCreateSchema(
|
|
|
order_id=oid,
|
|
|
transaction_id=callback_result.transaction_id,
|
|
|
pay_method=method,
|
|
|
amount=callback_result.amount,
|
|
|
raw_response=str(callback_result.raw) if callback_result.raw else None,
|
|
|
pay_time=datetime.now(),
|
|
|
)
|
|
|
)
|
|
|
|
|
|
order.package_id = pid
|
|
|
order.tenant_id = tid
|
|
|
order.order_type = otype
|
|
|
await PaymentService._activate_tenant_package(auth, order)
|
|
|
|
|
|
logger.info(f"支付回调处理完成: order_id={oid} method={method} tenant_id={tid} type={otype}")
|
|
|
return {"order_id": oid, "status": 1, "message": "支付成功"}
|
|
|
|
|
|
@classmethod
|
|
|
async def _activate_tenant_package(cls, auth: AuthSchema, order: OrderModel) -> None:
|
|
|
"""
|
|
|
支付成功后激活套餐
|
|
|
|
|
|
参数:
|
|
|
- auth (AuthSchema): 认证信息模型
|
|
|
- order (OrderModel): 订单模型
|
|
|
|
|
|
返回:
|
|
|
- None
|
|
|
"""
|
|
|
from app.api.v1.module_platform.package.model import PackageModel
|
|
|
from app.api.v1.module_platform.tenant.model import TenantModel
|
|
|
|
|
|
if order.order_type == "plugin":
|
|
|
await PaymentService._activate_plugin(auth, order)
|
|
|
return
|
|
|
|
|
|
pkg = await auth.db.get(PackageModel, order.package_id)
|
|
|
if not pkg:
|
|
|
logger.warning(f"支付回调：套餐 {order.package_id} 不存在，跳过激活")
|
|
|
return
|
|
|
|
|
|
tenant = await auth.db.get(TenantModel, order.tenant_id)
|
|
|
if not tenant:
|
|
|
logger.warning(f"支付回调：租户 {order.tenant_id} 不存在，跳过激活")
|
|
|
return
|
|
|
|
|
|
now = datetime.now()
|
|
|
period_months = order.period_count or 1
|
|
|
duration = timedelta(days=30 * period_months)
|
|
|
|
|
|
if order.order_type == "new":
|
|
|
tenant.package_id = order.package_id
|
|
|
tenant.start_time = now
|
|
|
tenant.end_time = now + duration
|
|
|
tenant.status = 0
|
|
|
logger.info(f"租户[{tenant.name}]新开通 {pkg.name}，有效期至 {tenant.end_time}")
|
|
|
|
|
|
elif order.order_type == "renew":
|
|
|
base = tenant.end_time if tenant.end_time and tenant.end_time > now else now
|
|
|
tenant.end_time = base + duration
|
|
|
tenant.status = 0
|
|
|
logger.info(f"租户[{tenant.name}]续费 {pkg.name}，续至 {tenant.end_time}")
|
|
|
|
|
|
elif order.order_type in ("upgrade", "downgrade"):
|
|
|
if order.order_type == "downgrade":
|
|
|
await PaymentService._check_downgrade_quota(auth, order.tenant_id, pkg)
|
|
|
tenant.package_id = order.package_id
|
|
|
tenant.status = 0
|
|
|
logger.info(f"租户[{tenant.name}]套餐变更 {'升级' if order.order_type == 'upgrade' else '降级'} → {pkg.name}")
|
|
|
|
|
|
await auth.db.flush()
|
|
|
|
|
|
if tenant.contact_email:
|
|
|
await PaymentService._send_order_email(auth, order, pkg, tenant)
|
|
|
|
|
|
@classmethod
|
|
|
async def _activate_plugin(cls, auth: AuthSchema, order: OrderModel) -> None:
|
|
|
"""
|
|
|
支付成功后标记插件为已购买
|
|
|
|
|
|
参数:
|
|
|
- auth (AuthSchema): 认证信息模型
|
|
|
- order (OrderModel): 订单模型
|
|
|
|
|
|
返回:
|
|
|
- None
|
|
|
"""
|
|
|
from app.api.v1.module_platform.plugin.model import PluginModel, TenantPluginModel
|
|
|
|
|
|
plugin = await auth.db.get(PluginModel, order.plugin_id)
|
|
|
if not plugin:
|
|
|
logger.warning(f"支付回调：插件 {order.plugin_id} 不存在")
|
|
|
return
|
|
|
|
|
|
result = await auth.db.execute(
|
|
|
select(TenantPluginModel)
|
|
|
.where(
|
|
|
TenantPluginModel.tenant_id == order.tenant_id,
|
|
|
TenantPluginModel.plugin_id == order.plugin_id,
|
|
|
)
|
|
|
.limit(1)
|
|
|
)
|
|
|
existing = result.scalar_one_or_none()
|
|
|
if existing:
|
|
|
existing.purchased = "1"
|
|
|
else:
|
|
|
tp = TenantPluginModel(
|
|
|
tenant_id=order.tenant_id,
|
|
|
plugin_id=order.plugin_id,
|
|
|
purchased="1",
|
|
|
enabled="0",
|
|
|
installed_time=datetime.now(),
|
|
|
)
|
|
|
auth.db.add(tp)
|
|
|
|
|
|
await auth.db.flush()
|
|
|
logger.info(f"租户[{order.tenant_id}]已购买插件[{plugin.name}]")
|
|
|
|
|
|
from app.api.v1.module_platform.tenant.model import TenantModel
|
|
|
|
|
|
tenant = await auth.db.get(TenantModel, order.tenant_id)
|
|
|
if tenant and tenant.contact_email:
|
|
|
await PaymentService._send_order_email(auth, order, plugin, tenant, order_type_label="购买")
|
|
|
|
|
|
@classmethod
|
|
|
async def _check_downgrade_quota(cls, auth: AuthSchema, tenant_id: int, new_pkg: object) -> None:
|
|
|
"""
|
|
|
降级前检查：租户当前资源数是否超过新套餐限额
|
|
|
|
|
|
参数:
|
|
|
- auth (AuthSchema): 认证信息模型
|
|
|
- tenant_id (int): 租户ID
|
|
|
- new_pkg (object): 目标套餐
|
|
|
|
|
|
返回:
|
|
|
- None
|
|
|
"""
|
|
|
from sqlalchemy import func, select
|
|
|
|
|
|
from app.api.v1.module_system.dept.model import DeptModel
|
|
|
from app.api.v1.module_system.role.model import RoleModel
|
|
|
from app.api.v1.module_system.user.model import UserModel
|
|
|
|
|
|
checks = {
|
|
|
"用户": (UserModel, new_pkg.max_users),
|
|
|
"角色": (RoleModel, new_pkg.max_roles),
|
|
|
"部门": (DeptModel, new_pkg.max_depts),
|
|
|
}
|
|
|
|
|
|
for label, (model, limit) in checks.items():
|
|
|
if limit <= 0:
|
|
|
continue
|
|
|
count_stmt = (
|
|
|
select(func.count())
|
|
|
.select_from(model)
|
|
|
.where(
|
|
|
model.tenant_id == tenant_id,
|
|
|
model.is_deleted.is_(False),
|
|
|
)
|
|
|
)
|
|
|
result = await auth.db.execute(count_stmt)
|
|
|
current = result.scalar() or 0
|
|
|
if current > limit:
|
|
|
raise CustomException(msg=f"降级失败：当前租户已有 {current} 个{label}，超过目标套餐限额 {limit}")
|
|
|
|
|
|
@classmethod
|
|
|
async def _send_order_email(cls, auth: AuthSchema, order: OrderModel, product: object, tenant: object, order_type_label: str = "") -> None:
|
|
|
"""
|
|
|
发送购买确认邮件（失败静默降级）
|
|
|
|
|
|
参数:
|
|
|
- order (OrderModel): 订单模型
|
|
|
- product (object): 商品(套餐/插件)
|
|
|
- tenant (object): 租户模型
|
|
|
- order_type_label (str): 订单类型文案
|
|
|
|
|
|
返回:
|
|
|
- None
|
|
|
"""
|
|
|
try:
|
|
|
from app.api.v1.module_platform.email.service import EmailSendService
|
|
|
|
|
|
if not order_type_label:
|
|
|
order_type_labels = {
|
|
|
"new": "开通",
|
|
|
"renew": "续费",
|
|
|
"upgrade": "升级",
|
|
|
"downgrade": "降级",
|
|
|
"plugin": "购买",
|
|
|
}
|
|
|
order_type_label = order_type_labels.get(order.order_type, order.order_type)
|
|
|
|
|
|
product_name = getattr(product, "name", "") if product else ""
|
|
|
amount_str = f"{order.amount / 100:.2f}" if order.amount else "0.00"
|
|
|
|
|
|
await EmailSendService(auth).send_by_template(
|
|
|
to_email=tenant.contact_email,
|
|
|
to_name=tenant.contact_name or tenant.name,
|
|
|
template_code="order_confirmation",
|
|
|
variables={
|
|
|
"tenant_name": tenant.name,
|
|
|
"order_no": order.order_no,
|
|
|
"package_name": product_name,
|
|
|
"order_type": order_type_label,
|
|
|
"amount": amount_str,
|
|
|
},
|
|
|
biz_type="order",
|
|
|
tenant_id=tenant.id,
|
|
|
)
|
|
|
except Exception:
|
|
|
pass # 邮件发送失败不阻塞业务流程
|
|
|
|
|
|
@classmethod
|
|
|
async def get_records(cls, auth: AuthSchema, offset: int, limit: int) -> tuple[list, int]:
|
|
|
"""
|
|
|
支付记录列表
|
|
|
|
|
|
参数:
|
|
|
- auth (AuthSchema): 认证信息模型
|
|
|
- offset (int): 偏移量
|
|
|
- limit (int): 每页数量
|
|
|
|
|
|
返回:
|
|
|
- tuple[list, int]: (支付记录列表, 总数)
|
|
|
"""
|
|
|
rows, total = await PaymentRecordCRUD(auth).query(offset, limit)
|
|
|
items = [PaymentRecordOutSchema.model_validate(r) for r in rows]
|
|
|
return items, total
|
|
|
|
|
|
|
|
|
class RefundService:
|
|
|
"""
|
|
|
退款管理服务
|
|
|
"""
|
|
|
|
|
|
@classmethod
|
|
|
async def apply(cls, auth: AuthSchema, data: RefundApplySchema, order_id: int) -> RefundOutSchema:
|
|
|
"""
|
|
|
申请退款
|
|
|
|
|
|
参数:
|
|
|
- auth (AuthSchema): 认证信息模型
|
|
|
- data (RefundApplySchema): 退款申请模型
|
|
|
- order_id (int): 订单ID
|
|
|
|
|
|
返回:
|
|
|
- RefundOutSchema: 退款记录详情
|
|
|
"""
|
|
|
o_crud = OrderCRUD(auth)
|
|
|
order = await o_crud.get_by_id(order_id)
|
|
|
if not order:
|
|
|
raise CustomException(msg="该数据不存在")
|
|
|
if order.status != 1:
|
|
|
raise CustomException(msg="仅已支付订单可退款")
|
|
|
if order.amount == 0:
|
|
|
raise CustomException(msg="免费套餐不支持退款")
|
|
|
if order.pay_time and (datetime.now() - order.pay_time).days > 7:
|
|
|
raise CustomException(msg="已超过 7 天退款时限")
|
|
|
existing = await RefundCRUD(auth).get_by_order_id(order_id)
|
|
|
if existing:
|
|
|
raise CustomException(msg="已存在退款申请")
|
|
|
refund = await RefundCRUD(auth).create(
|
|
|
RefundCreateSchema(
|
|
|
order_id=order.id,
|
|
|
refund_no=_generate_refund_no(),
|
|
|
amount=order.amount,
|
|
|
reason=data.reason,
|
|
|
)
|
|
|
)
|
|
|
return RefundOutSchema.model_validate(refund)
|
|
|
|
|
|
@classmethod
|
|
|
async def get_list(cls, auth: AuthSchema, status: int | None, offset: int, limit: int) -> tuple[list, int]:
|
|
|
"""
|
|
|
退款列表
|
|
|
|
|
|
参数:
|
|
|
- auth (AuthSchema): 认证信息模型
|
|
|
- status (int | None): 退款状态筛选
|
|
|
- offset (int): 偏移量
|
|
|
- limit (int): 每页数量
|
|
|
|
|
|
返回:
|
|
|
- tuple[list, int]: (退款列表, 总数)
|
|
|
"""
|
|
|
rows, total = await RefundCRUD(auth).query(status, offset, limit)
|
|
|
items = [RefundOutSchema.model_validate(r) for r in rows]
|
|
|
return items, total
|
|
|
|
|
|
@classmethod
|
|
|
async def approve(cls, auth: AuthSchema, refund_id: int, reviewer_id: int, operator_name: str = "") -> OrderStatusMessage:
|
|
|
"""
|
|
|
批准退款
|
|
|
|
|
|
参数:
|
|
|
- auth (AuthSchema): 认证信息模型
|
|
|
- refund_id (int): 退款ID
|
|
|
- reviewer_id (int): 审核人ID
|
|
|
- operator_name (str): 操作人名称
|
|
|
|
|
|
返回:
|
|
|
- OrderStatusMessage: 审核结果
|
|
|
"""
|
|
|
crud = RefundCRUD(auth)
|
|
|
refund = await crud.get_by_id(refund_id)
|
|
|
if not refund:
|
|
|
raise CustomException(msg="该数据不存在")
|
|
|
if refund.status != 1:
|
|
|
raise CustomException(msg="仅申请中可审核")
|
|
|
await crud.update(
|
|
|
refund_id,
|
|
|
RefundUpdateSchema(status=2, reviewer_id=reviewer_id, review_time=datetime.now()),
|
|
|
)
|
|
|
await OrderCRUD(auth).mark_refunded(refund.order_id)
|
|
|
return OrderStatusMessage(id=refund.id, status=2, message="已批准退款")
|
|
|
|
|
|
@classmethod
|
|
|
async def reject(
|
|
|
cls,
|
|
|
auth: AuthSchema,
|
|
|
refund_id: int,
|
|
|
reviewer_id: int,
|
|
|
data: RefundReviewSchema,
|
|
|
operator_name: str = "",
|
|
|
) -> OrderStatusMessage:
|
|
|
"""
|
|
|
驳回退款
|
|
|
|
|
|
参数:
|
|
|
- auth (AuthSchema): 认证信息模型
|
|
|
- refund_id (int): 退款ID
|
|
|
- reviewer_id (int): 审核人ID
|
|
|
- data (RefundReviewSchema): 驳回原因
|
|
|
- operator_name (str): 操作人名称
|
|
|
|
|
|
返回:
|
|
|
- OrderStatusMessage: 审核结果
|
|
|
"""
|
|
|
crud = RefundCRUD(auth)
|
|
|
refund = await crud.get_by_id(refund_id)
|
|
|
if not refund:
|
|
|
raise CustomException(msg="该数据不存在")
|
|
|
if refund.status != 1:
|
|
|
raise CustomException(msg="仅申请中可审核")
|
|
|
await crud.update(
|
|
|
refund_id,
|
|
|
RefundUpdateSchema(
|
|
|
status=3,
|
|
|
reviewer_id=reviewer_id,
|
|
|
review_time=datetime.now(),
|
|
|
reject_reason=data.reject_reason,
|
|
|
),
|
|
|
)
|
|
|
return OrderStatusMessage(id=refund.id, status=3, message="已驳回")
|