liuwenxin
1e53792ad6
打通 T+ 快照、业务、发货、回款和核算准备链路，保留来源差异并提供待补状态。 新增业务自动接入任务、跨平台读取服务托管、权限复核、来源关联和前端核对页面。 补充迁移、隔离集成测试、浏览器模拟验收及角色授权边界修复。
325 行
13 KiB
Python
325 行
13 KiB
Python
"""业务数据仓储：业务单、明细、状态留痕与归属留痕。
|
||
|
||
只读写数据并 flush；commit/rollback 与业务异常一律在 service 层。
|
||
归属留痕复用 ownership_change_logs（owner_type=2 为业务维度，常量在
|
||
models/customer.py 定义）。
|
||
"""
|
||
|
||
from sqlalchemy import Row, Select, delete, exists, func, or_, select, update
|
||
from sqlalchemy.orm import Session, aliased
|
||
|
||
from app.models import (
|
||
Business,
|
||
BusinessItem,
|
||
BusinessStatusLog,
|
||
Customer,
|
||
OwnershipChangeLog,
|
||
Personnel,
|
||
Product,
|
||
Receipt,
|
||
SecondaryAllocation,
|
||
Shipment,
|
||
TPlusBusinessDocument,
|
||
)
|
||
from app.models.customer import OWNER_TYPE_BUSINESS
|
||
from app.repositories import ownership_log_repository
|
||
from app.repositories.ownership_log_repository import OwnershipLogRef
|
||
from app.schemas.business import BusinessQuery
|
||
|
||
READINESS_SQL_REASONS = frozenset({
|
||
"CUSTOMER_CATEGORY_PENDING", "PRODUCT_CATEGORY_PENDING", "NO_ACTUAL_SHIPMENT", "SOURCE_CONFLICT",
|
||
})
|
||
|
||
|
||
def get_by_id(session: Session, business_id: int, *, for_update: bool = False) -> Business | None:
|
||
"""按主键取业务行；for_update 供删除保护、编辑门槛与状态机使用。"""
|
||
stmt = select(Business).where(Business.id == business_id)
|
||
if for_update:
|
||
stmt = stmt.with_for_update()
|
||
return session.execute(stmt).scalars().first()
|
||
|
||
|
||
def has_docs(session: Session, business_id: int) -> bool:
|
||
"""业务名下是否已有发货单或回款（换客户/删除保护的引用检查）。
|
||
|
||
单条 OR exists 一次往返；新增挂靠业务的单据类型时在此补充条件，
|
||
编辑与删除两处共用同一判定，防「delete 补了检查、update 漏补」的分叉。
|
||
"""
|
||
stmt = select(
|
||
or_(
|
||
exists().where(Shipment.business_id == business_id),
|
||
exists().where(Receipt.business_id == business_id),
|
||
)
|
||
)
|
||
return bool(session.execute(stmt).scalar())
|
||
|
||
|
||
def create(session: Session, business: Business) -> None:
|
||
"""新增业务行（不 commit，flush 让自增 id 就位）。"""
|
||
session.add(business)
|
||
session.flush()
|
||
|
||
|
||
def get_with_names(
|
||
session: Session, business_id: int, *, for_update: bool = False
|
||
) -> tuple[Business, str, str | None, str | None] | None:
|
||
"""业务行 + 客户名 + 负责人名 + 协助人名（DTO 与审计摘要共用）。
|
||
|
||
for_update 供编辑/状态流转/归属变更使用：与发货/回款写路径的
|
||
get_by_id(for_update=True) 同一锁口径，编辑事务与单据写事务互斥，
|
||
「有发货禁换客户」的快照读校验不再被并发新增旁路。
|
||
"""
|
||
owner = aliased(Personnel)
|
||
assistant = aliased(Personnel)
|
||
stmt = (
|
||
select(Business, Customer.company_name, owner.personnel_name, assistant.personnel_name)
|
||
.join(Customer, Customer.id == Business.customer_id)
|
||
.outerjoin(owner, owner.id == Business.owner_personnel_id)
|
||
.outerjoin(assistant, assistant.id == Business.assistant_personnel_id)
|
||
.where(Business.id == business_id)
|
||
)
|
||
if for_update:
|
||
stmt = stmt.with_for_update()
|
||
return session.execute(stmt).first()
|
||
|
||
|
||
def _apply_filters(stmt: Select, query: BusinessQuery) -> Select:
|
||
"""业务列表的筛选条件（调用方须已 join Customer）。"""
|
||
if query.keyword:
|
||
# 业务编号/公司名称双列 OR 模糊；contains(autoescape) 同 query_utils.fuzzy
|
||
# 的转义口径（fuzzy 为单列 where 语义，双列 OR 在此直接组合）
|
||
stmt = stmt.where(
|
||
or_(
|
||
Business.business_no.contains(query.keyword, autoescape=True),
|
||
Customer.company_name.contains(query.keyword, autoescape=True),
|
||
)
|
||
)
|
||
if query.status is not None:
|
||
stmt = stmt.where(Business.status == query.status)
|
||
if query.customer_id is not None:
|
||
stmt = stmt.where(Business.customer_id == query.customer_id)
|
||
if query.owner_personnel_id is not None:
|
||
stmt = stmt.where(Business.owner_personnel_id == query.owner_personnel_id)
|
||
if query.date_from is not None:
|
||
stmt = stmt.where(Business.business_date >= query.date_from)
|
||
if query.date_to is not None:
|
||
stmt = stmt.where(Business.business_date <= query.date_to)
|
||
if query.source_type == "TPLUS":
|
||
stmt = stmt.where(Business.t_plus_id.is_not(None))
|
||
elif query.source_type == "MANUAL":
|
||
stmt = stmt.where(Business.t_plus_id.is_(None))
|
||
if query.source_personnel:
|
||
stmt = stmt.where(Business.integration_json["personnel_names"].as_string().contains(query.source_personnel, autoescape=True))
|
||
if query.readiness_reason in READINESS_SQL_REASONS:
|
||
stmt = stmt.where(Business.integration_json["source_database"].as_string().is_not(None))
|
||
if query.readiness_reason == "CUSTOMER_CATEGORY_PENDING":
|
||
stmt = stmt.where(Customer.customer_type.is_(None))
|
||
elif query.readiness_reason == "PRODUCT_CATEGORY_PENDING":
|
||
stmt = stmt.where(exists(select(BusinessItem.id).join(Product, Product.id == BusinessItem.product_id).where(
|
||
BusinessItem.business_id == Business.id, Product.product_category.is_(None))))
|
||
elif query.readiness_reason == "NO_ACTUAL_SHIPMENT":
|
||
stmt = stmt.where(~exists().where(Shipment.business_id == Business.id))
|
||
elif query.readiness_reason == "SOURCE_CONFLICT":
|
||
stmt = stmt.where(exists().where(TPlusBusinessDocument.business_id == Business.id,
|
||
TPlusBusinessDocument.status.in_(("CONFLICT", "PENDING"))))
|
||
return stmt
|
||
|
||
|
||
def scan_businesses(session: Session, query: BusinessQuery, before_id: int | None, limit: int = 100):
|
||
"""按主键倒序分批读取，供需要计算准备状态的筛选使用。"""
|
||
owner = aliased(Personnel)
|
||
assistant = aliased(Personnel)
|
||
stmt = select(Business, Customer.company_name, owner.personnel_name, assistant.personnel_name).join(
|
||
Customer, Customer.id == Business.customer_id)
|
||
stmt = _apply_filters(stmt, query).outerjoin(owner, owner.id == Business.owner_personnel_id).outerjoin(
|
||
assistant, assistant.id == Business.assistant_personnel_id)
|
||
if before_id is not None:
|
||
stmt = stmt.where(Business.id < before_id)
|
||
return list(session.execute(stmt.order_by(Business.id.desc()).limit(limit)).all())
|
||
|
||
|
||
def list_businesses(
|
||
session: Session, query: BusinessQuery
|
||
) -> list[tuple[Business, str, str | None, str | None]]:
|
||
"""分页查询业务（附客户名/负责人名/协助人名），按 id 倒序。"""
|
||
owner = aliased(Personnel)
|
||
assistant = aliased(Personnel)
|
||
stmt = select(
|
||
Business, Customer.company_name, owner.personnel_name, assistant.personnel_name
|
||
).join(Customer, Customer.id == Business.customer_id)
|
||
stmt = _apply_filters(stmt, query)
|
||
stmt = (
|
||
stmt.outerjoin(owner, owner.id == Business.owner_personnel_id)
|
||
.outerjoin(assistant, assistant.id == Business.assistant_personnel_id)
|
||
.order_by(Business.id.desc())
|
||
.offset(query.offset)
|
||
.limit(query.page_size)
|
||
)
|
||
return list(session.execute(stmt).all())
|
||
|
||
|
||
def count_businesses(session: Session, query: BusinessQuery) -> int:
|
||
stmt = (
|
||
select(func.count())
|
||
.select_from(Business)
|
||
.join(Customer, Customer.id == Business.customer_id)
|
||
)
|
||
stmt = _apply_filters(stmt, query)
|
||
return int(session.execute(stmt).scalar_one())
|
||
|
||
|
||
def list_items(session: Session, business_id: int) -> list[BusinessItem]:
|
||
"""业务明细行（编辑回显与汇总重算共用）。"""
|
||
return list(
|
||
session.execute(
|
||
select(BusinessItem)
|
||
.where(BusinessItem.business_id == business_id)
|
||
.order_by(BusinessItem.id)
|
||
).scalars()
|
||
)
|
||
|
||
|
||
def replace_items(session: Session, business_id: int, rows: list[BusinessItem]) -> None:
|
||
"""全量替换明细：先删、立即 flush、再插入（replace_roles 先例的防御写法）。
|
||
|
||
同一 flush 中 SQLAlchemy 先处理 INSERT 后处理 DELETE，先删后插不落库
|
||
会在有唯一键的表上撞键；business_items 虽无唯一键，统一按此写法防御。
|
||
"""
|
||
session.execute(delete(BusinessItem).where(BusinessItem.business_id == business_id))
|
||
session.flush()
|
||
for row in rows:
|
||
row.business_id = business_id
|
||
session.add(row)
|
||
session.flush()
|
||
|
||
|
||
def list_allocations(
|
||
session: Session, business_id: int, *, active_only: bool = True
|
||
) -> list[SecondaryAllocation]:
|
||
"""二次分配方案（详情回显与核算取数；默认仅当前生效版本）。"""
|
||
stmt = select(SecondaryAllocation).where(SecondaryAllocation.business_id == business_id)
|
||
if active_only:
|
||
stmt = stmt.where(SecondaryAllocation.is_active == 1)
|
||
return list(
|
||
session.execute(
|
||
stmt.order_by(SecondaryAllocation.version_no, SecondaryAllocation.id)
|
||
).scalars()
|
||
)
|
||
|
||
|
||
def list_allocation_versions(session: Session, business_id: int) -> list[SecondaryAllocation]:
|
||
"""方案全部版本行（含历史；业务详情「方案历史」用，按版本正序）。"""
|
||
return list_allocations(session, business_id, active_only=False)
|
||
|
||
|
||
def replace_allocations(
|
||
session: Session, business_id: int, rows: list[SecondaryAllocation]
|
||
) -> None:
|
||
"""全量替换二次分配方案：旧生效行置历史，新行按下一版本号插入。
|
||
|
||
不 commit（事务边界在服务层）。版本行 append-only——编辑与清空都不
|
||
物理删除，驳回后仍可回溯被否决方案的参与人与比例。空 ``rows`` 表示
|
||
只清空生效态（不产生新版本）。
|
||
"""
|
||
deactivate_allocations(session, business_id)
|
||
if not rows:
|
||
return
|
||
next_version = (
|
||
session.execute(
|
||
select(func.coalesce(func.max(SecondaryAllocation.version_no), 0)).where(
|
||
SecondaryAllocation.business_id == business_id
|
||
)
|
||
).scalar_one()
|
||
+ 1
|
||
)
|
||
for row in rows:
|
||
row.business_id = business_id
|
||
row.version_no = next_version
|
||
row.is_active = 1
|
||
session.add(row)
|
||
session.flush()
|
||
|
||
|
||
def deactivate_allocations(session: Session, business_id: int) -> None:
|
||
"""把业务的当前生效方案置为历史（审批驳回/编辑替换时调用；行保留）。
|
||
|
||
被否决的方案不得以「当前生效行」身份继续被核算取到；``is_active=0``
|
||
后核算侧自然读不到，而历史版本仍可在业务详情回溯。不 commit。
|
||
|
||
显式声明 ``synchronize_session="fetch"``：Core UPDATE 默认走 auto 策略
|
||
（优先 evaluate，本例的条件恰好能在 Python 侧求值，故实测也会刷新在途
|
||
对象）。显式写 fetch 是为了不把「在途对象被刷新」这件事押在 evaluate
|
||
能否解析条件上——条件一旦复杂化，auto 会退化为不刷新，同一会话里已
|
||
加载的方案行就会停留在 ``is_active=1`` 的过期内存值（查询虽有
|
||
is_active 过滤，但行对象本身仍是「生效态」，被序列化或参与判断就是
|
||
错的）。
|
||
"""
|
||
session.execute(
|
||
update(SecondaryAllocation)
|
||
.where(
|
||
SecondaryAllocation.business_id == business_id,
|
||
SecondaryAllocation.is_active == 1,
|
||
)
|
||
.values(is_active=0)
|
||
.execution_options(synchronize_session="fetch")
|
||
)
|
||
session.flush()
|
||
|
||
|
||
def add_status_log(session: Session, log: BusinessStatusLog) -> None:
|
||
"""追加状态留痕（不 commit）。"""
|
||
session.add(log)
|
||
session.flush()
|
||
|
||
|
||
def list_status_logs(
|
||
session: Session, business_id: int, *, offset: int, limit: int
|
||
) -> list[BusinessStatusLog]:
|
||
"""状态流转时间线（详情页），按时间正序（时间线从创建起展示）。"""
|
||
return list(
|
||
session.execute(
|
||
select(BusinessStatusLog)
|
||
.where(BusinessStatusLog.business_id == business_id)
|
||
.order_by(BusinessStatusLog.create_time, BusinessStatusLog.id)
|
||
.offset(offset)
|
||
.limit(limit)
|
||
).scalars()
|
||
)
|
||
|
||
|
||
def count_status_logs(session: Session, business_id: int) -> int:
|
||
return int(
|
||
session.execute(
|
||
select(func.count())
|
||
.select_from(BusinessStatusLog)
|
||
.where(BusinessStatusLog.business_id == business_id)
|
||
).scalar_one()
|
||
)
|
||
|
||
|
||
def add_ownership_log(session: Session, log: OwnershipChangeLog) -> None:
|
||
"""追加归属变更留痕（共享实现，不 commit）。"""
|
||
ownership_log_repository.add(session, log)
|
||
|
||
|
||
def list_ownership_logs(
|
||
session: Session, business_id: int, *, offset: int, limit: int
|
||
) -> list[Row]:
|
||
"""某业务的归属变更留痕（共享实现，owner_type/business_id 参数化）。"""
|
||
return ownership_log_repository.list_by_ref(
|
||
session, _business_log_ref(business_id), offset=offset, limit=limit
|
||
)
|
||
|
||
|
||
def count_ownership_logs(session: Session, business_id: int) -> int:
|
||
return ownership_log_repository.count_by_ref(session, _business_log_ref(business_id))
|
||
|
||
|
||
def _business_log_ref(business_id: int) -> OwnershipLogRef:
|
||
"""业务维度的归属留痕锚点。"""
|
||
return OwnershipLogRef(
|
||
owner_type=OWNER_TYPE_BUSINESS,
|
||
ref_column=OwnershipChangeLog.business_id,
|
||
ref_id=business_id,
|
||
)
|