1811 lines
68 KiB
Python
1811 lines
68 KiB
Python
"""运输计划安排时联动地磅计划与出入库单。"""
|
||
from __future__ import annotations
|
||
|
||
import calendar
|
||
import re
|
||
from dataclasses import dataclass
|
||
from datetime import date, datetime
|
||
from decimal import Decimal
|
||
from typing import Any, Literal, Optional
|
||
|
||
from sqlalchemy import func
|
||
from sqlalchemy.orm import Session
|
||
|
||
from app.core.utils import generate_uuid
|
||
from app.models.crm_models import CrmProduct
|
||
from app.models.db_models import DbInboundOutbound, DbPurchasePlan, DbWeighingSlip
|
||
from app.models.pl_models import (
|
||
PlPlan,
|
||
PlPlanDelivery,
|
||
PlPlanDeliveryProduct,
|
||
PlPlanLoad,
|
||
PlPlanLoadProduct,
|
||
PlPlanProduct,
|
||
PlTransport,
|
||
PlTransportDbLink,
|
||
)
|
||
from app.services.db.inventory_id import next_inbound_outbound_id
|
||
from app.services.db.mappers import parse_date_str
|
||
from app.services.db.plan_helpers import default_execution_status, generate_plan_no
|
||
from app.services.db.product_helpers import (
|
||
apply_product_snapshot_to_inventory,
|
||
apply_product_snapshot_to_plan,
|
||
resolve_crm_product,
|
||
)
|
||
from app.services.pl_plan_stop_rules import normalize_stop_dibang_fields
|
||
|
||
|
||
@dataclass
|
||
class DibangInventoryLinkResult:
|
||
plan_product_id: str
|
||
product_name: str
|
||
db_purchase_plan_id: str
|
||
db_inventory_id: str
|
||
batch_no: str
|
||
plan_no: str
|
||
|
||
|
||
@dataclass
|
||
class StopDibangOption:
|
||
stop_type: Literal["load", "delivery"]
|
||
stop_id: str
|
||
generate_dibang: bool
|
||
|
||
|
||
@dataclass
|
||
class _StopDibangProduct:
|
||
plan_product_id: str
|
||
product_id: str
|
||
product_name: str
|
||
model: Optional[str]
|
||
unit: str
|
||
quantity: float
|
||
|
||
|
||
def resolve_partner_company(plan: PlPlan, plan_type: str) -> str:
|
||
"""按运输计划单据类型解析地磅往来单位（不区分 CRM 合同类型）。
|
||
|
||
- 入库单 inbound：供方 → party_a，其次 supplier_name
|
||
- 出库单 outbound：需方 → party_b，其次 customer_name
|
||
"""
|
||
if plan_type == "inbound":
|
||
return (plan.party_a or plan.supplier_name or "").strip()
|
||
if plan_type == "outbound":
|
||
return (plan.party_b or plan.customer_name or "").strip()
|
||
return ""
|
||
|
||
|
||
def _normalize_to_date(value: date | datetime | str | None) -> Optional[date]:
|
||
if value is None:
|
||
return None
|
||
if isinstance(value, datetime):
|
||
return value.date()
|
||
if isinstance(value, date):
|
||
return value
|
||
if isinstance(value, str):
|
||
return parse_date_str(value)
|
||
return None
|
||
|
||
|
||
def _normalize_plan_date(plan: PlPlan) -> date:
|
||
plan_date = plan.plan_date
|
||
if isinstance(plan_date, datetime):
|
||
return plan_date.date()
|
||
if isinstance(plan_date, date):
|
||
return plan_date
|
||
if isinstance(plan_date, str):
|
||
parsed = parse_date_str(plan_date)
|
||
return parsed or date.today()
|
||
return date.today()
|
||
|
||
|
||
def _resolve_dibang_date(plan: PlPlan) -> date:
|
||
"""入库单用送达时间，出库单用取货时间；缺失时回退计划日期。"""
|
||
if plan.plan_type == "inbound":
|
||
resolved = _normalize_to_date(plan.delivery_time)
|
||
elif plan.plan_type == "outbound":
|
||
resolved = _normalize_to_date(plan.pickup_time)
|
||
else:
|
||
resolved = None
|
||
return resolved or _normalize_plan_date(plan)
|
||
|
||
|
||
def _month_range(plan_date: date) -> tuple[date, date]:
|
||
month_start = plan_date.replace(day=1)
|
||
last_day = calendar.monthrange(plan_date.year, plan_date.month)[1]
|
||
month_end = plan_date.replace(day=last_day)
|
||
return month_start, month_end
|
||
|
||
|
||
def _plan_type_to_business_type(plan_type: str) -> Optional[str]:
|
||
if plan_type == "inbound":
|
||
return "入库"
|
||
if plan_type == "outbound":
|
||
return "出库"
|
||
return None
|
||
|
||
|
||
def _direction_to_business_type(direction: Optional[str]) -> Optional[str]:
|
||
normalized = (direction or "").strip()
|
||
if normalized == "outbound":
|
||
return "出库"
|
||
if normalized == "inbound":
|
||
return "入库"
|
||
return None
|
||
|
||
|
||
def _resolve_stop_business_type(
|
||
stop: PlPlanLoad | PlPlanDelivery,
|
||
stop_type: Literal["load", "delivery"],
|
||
) -> Optional[str]:
|
||
_, direction = normalize_stop_dibang_fields(
|
||
stop.customer_name,
|
||
stop_type,
|
||
stop.generate_dibang,
|
||
stop.dibang_direction,
|
||
)
|
||
return _direction_to_business_type(direction)
|
||
|
||
|
||
def resolve_stop_dibang_partner(
|
||
stop_type: Literal["load", "delivery"],
|
||
load: Optional[PlPlanLoad],
|
||
deliveries: list[PlPlanDelivery],
|
||
) -> str:
|
||
"""装货段地磅往来单位取第一个送货客户；送货段取装货客户。"""
|
||
if stop_type == "load":
|
||
if deliveries:
|
||
return (deliveries[0].customer_name or "").strip()
|
||
return (load.customer_name or "").strip() if load else ""
|
||
return (load.customer_name or "").strip() if load else ""
|
||
|
||
|
||
def _stop_product_quantity(product: Any) -> float:
|
||
if getattr(product, "plan_qty", None) is not None:
|
||
return float(product.plan_qty)
|
||
return 0.0
|
||
|
||
|
||
def plan_has_load_stop(db: Session, tenant_no: str, plan_id: str) -> bool:
|
||
return (
|
||
db.query(PlPlanLoad.id)
|
||
.filter(
|
||
PlPlanLoad.plan_id == plan_id,
|
||
PlPlanLoad.tenant_no == tenant_no,
|
||
PlPlanLoad.del_flag == 0,
|
||
)
|
||
.first()
|
||
is not None
|
||
)
|
||
|
||
|
||
def apply_stop_dibang_options(
|
||
db: Session,
|
||
*,
|
||
tenant_no: str,
|
||
plan_id: str,
|
||
stop_options: list[StopDibangOption],
|
||
user_id: Optional[str],
|
||
) -> None:
|
||
for option in stop_options:
|
||
if option.stop_type == "load":
|
||
stop = (
|
||
db.query(PlPlanLoad)
|
||
.filter(
|
||
PlPlanLoad.id == option.stop_id,
|
||
PlPlanLoad.plan_id == plan_id,
|
||
PlPlanLoad.tenant_no == tenant_no,
|
||
PlPlanLoad.del_flag == 0,
|
||
)
|
||
.first()
|
||
)
|
||
else:
|
||
stop = (
|
||
db.query(PlPlanDelivery)
|
||
.filter(
|
||
PlPlanDelivery.id == option.stop_id,
|
||
PlPlanDelivery.plan_id == plan_id,
|
||
PlPlanDelivery.tenant_no == tenant_no,
|
||
PlPlanDelivery.del_flag == 0,
|
||
)
|
||
.first()
|
||
)
|
||
if stop:
|
||
gen, direction = normalize_stop_dibang_fields(
|
||
stop.customer_name,
|
||
"load" if option.stop_type == "load" else "delivery",
|
||
1 if option.generate_dibang else 0,
|
||
stop.dibang_direction,
|
||
)
|
||
stop.generate_dibang = gen
|
||
stop.dibang_direction = direction
|
||
stop.update_by = user_id
|
||
db.flush()
|
||
|
||
|
||
def _product_quantity(product: PlPlanProduct) -> float:
|
||
for value in (product.quantity, product.inbound_estimate_qty, product.outbound_estimate_qty):
|
||
if value is not None:
|
||
return float(value)
|
||
return 0.0
|
||
|
||
|
||
def _apply_plan_quantity_delta(
|
||
db_plan: DbPurchasePlan,
|
||
delta: float,
|
||
*,
|
||
user_id: Optional[str],
|
||
) -> None:
|
||
current = float(db_plan.planned_quantity or 0)
|
||
db_plan.planned_quantity = max(0.0, current + float(delta))
|
||
db_plan.update_by = user_id
|
||
|
||
|
||
def _resolve_link_contributed_qty(
|
||
link: PlTransportDbLink,
|
||
inventory: Optional[DbInboundOutbound],
|
||
) -> float:
|
||
if link.contributed_qty is not None:
|
||
return float(link.contributed_qty)
|
||
if inventory and inventory.quantity is not None:
|
||
return float(inventory.quantity)
|
||
return 0.0
|
||
|
||
|
||
def _subtract_plan_contribution(
|
||
db: Session,
|
||
*,
|
||
tenant_no: str,
|
||
link: PlTransportDbLink,
|
||
inventory: Optional[DbInboundOutbound],
|
||
user_id: Optional[str],
|
||
current_read: bool = False,
|
||
) -> None:
|
||
if not link.db_purchase_plan_id:
|
||
return
|
||
query = (
|
||
db.query(DbPurchasePlan)
|
||
.filter(
|
||
DbPurchasePlan.id == link.db_purchase_plan_id,
|
||
DbPurchasePlan.tenant_no == tenant_no,
|
||
DbPurchasePlan.del_flag == 0,
|
||
)
|
||
)
|
||
db_plan = (query.with_for_update() if current_read else query).first()
|
||
if not db_plan:
|
||
return
|
||
qty = _resolve_link_contributed_qty(link, inventory)
|
||
if qty:
|
||
_apply_plan_quantity_delta(db_plan, -qty, user_id=user_id)
|
||
|
||
|
||
def _generate_batch_no(db: Session, tenant_no: str) -> str:
|
||
rows = (
|
||
db.query(DbInboundOutbound.batch_no)
|
||
.filter(
|
||
DbInboundOutbound.tenant_no == tenant_no,
|
||
DbInboundOutbound.del_flag == 0,
|
||
DbInboundOutbound.batch_no.like("CRKDH%"),
|
||
)
|
||
.all()
|
||
)
|
||
max_seq = 0
|
||
pattern = re.compile(r"^CRKDH(\d+)$")
|
||
for (batch_no,) in rows:
|
||
if batch_no:
|
||
match = pattern.match(batch_no)
|
||
if match:
|
||
max_seq = max(max_seq, int(match.group(1)))
|
||
return f"CRKDH{max_seq + 1:07d}"
|
||
|
||
|
||
def find_monthly_db_plan(
|
||
db: Session,
|
||
tenant_no: str,
|
||
plan_date: date,
|
||
business_type: str,
|
||
customer_name: str,
|
||
product_id: str,
|
||
specification: Optional[str],
|
||
) -> Optional[DbPurchasePlan]:
|
||
month_start, month_end = _month_range(plan_date)
|
||
customer = (customer_name or "").strip()
|
||
spec = (specification or "").strip()
|
||
|
||
query = db.query(DbPurchasePlan).filter(
|
||
DbPurchasePlan.tenant_no == tenant_no,
|
||
DbPurchasePlan.del_flag == 0,
|
||
DbPurchasePlan.business_type == business_type,
|
||
DbPurchasePlan.product_id == product_id,
|
||
DbPurchasePlan.start_date <= month_end,
|
||
DbPurchasePlan.end_date >= month_start,
|
||
)
|
||
if customer:
|
||
query = query.filter(DbPurchasePlan.customer_name == customer)
|
||
if spec:
|
||
query = query.filter(DbPurchasePlan.specification == spec)
|
||
|
||
return query.order_by(DbPurchasePlan.create_time.desc()).first()
|
||
|
||
|
||
def _find_stop_monthly_plan(db: Session, tenant_no: str, plan_date: date, business_type: str,
|
||
customer_name: str, product_id: str, specification: Optional[str]):
|
||
"""锁定读保证等待共享产品锁后可见最新月计划，不从历史重复行中猜配。"""
|
||
start, end = _month_range(plan_date)
|
||
rows = db.query(DbPurchasePlan).filter(
|
||
DbPurchasePlan.tenant_no == tenant_no, DbPurchasePlan.del_flag == 0,
|
||
DbPurchasePlan.business_type == business_type, DbPurchasePlan.product_id == product_id,
|
||
func.trim(func.coalesce(DbPurchasePlan.customer_name, "")) == (customer_name or "").strip(),
|
||
func.trim(func.coalesce(DbPurchasePlan.specification, "")) == (specification or "").strip(),
|
||
DbPurchasePlan.start_date <= end, DbPurchasePlan.end_date >= start,
|
||
).with_for_update().limit(2).all()
|
||
if len(rows) > 1:
|
||
raise ValueError("存在重复地磅月计划，请先核对历史关联")
|
||
return rows[0] if rows else None
|
||
|
||
|
||
def _create_db_plan(
|
||
db: Session,
|
||
tenant_no: str,
|
||
plan: PlPlan,
|
||
product: PlPlanProduct,
|
||
business_type: str,
|
||
customer_name: str,
|
||
dibang_date: date,
|
||
month_start: date,
|
||
month_end: date,
|
||
user_id: Optional[str],
|
||
dept_id: str,
|
||
contributed_qty: float,
|
||
) -> DbPurchasePlan:
|
||
snapshot = resolve_crm_product(db, tenant_no, product.product_id, require_on_shelf=False)
|
||
db_plan = DbPurchasePlan(
|
||
id=generate_uuid(),
|
||
tenant_no=tenant_no,
|
||
plan_no=generate_plan_no(),
|
||
plan_date=dibang_date,
|
||
start_date=month_start,
|
||
end_date=month_end,
|
||
business_type=business_type,
|
||
planned_quantity=contributed_qty,
|
||
vehicle_no=(plan.license_plate or "").strip(),
|
||
customer_name=customer_name or None,
|
||
remark=f"来源运输计划 {plan.plan_no}",
|
||
execution_status=default_execution_status(business_type),
|
||
executed_at=None,
|
||
last_weighing_slip_id=None,
|
||
executed_quantity=0,
|
||
auto_generate_enabled=0,
|
||
auto_generate_end_month=None,
|
||
auto_generate_last_month=None,
|
||
create_by=user_id,
|
||
create_dept_id=dept_id,
|
||
)
|
||
apply_product_snapshot_to_plan(db_plan, snapshot)
|
||
db.add(db_plan)
|
||
db.flush()
|
||
return db_plan
|
||
|
||
|
||
def _create_db_inventory(
|
||
db: Session,
|
||
tenant_no: str,
|
||
plan: PlPlan,
|
||
product: PlPlanProduct,
|
||
db_plan: DbPurchasePlan,
|
||
business_type: str,
|
||
customer_name: str,
|
||
license_plate: str,
|
||
dibang_date: date,
|
||
user_id: Optional[str],
|
||
dept_id: str,
|
||
) -> DbInboundOutbound:
|
||
snapshot = resolve_crm_product(db, tenant_no, product.product_id, require_on_shelf=False)
|
||
status_value = "待入库" if business_type == "入库" else "待出库"
|
||
inventory_plan_no = ((db_plan.plan_no if db_plan else plan.plan_no) or "").strip() or None
|
||
remark = f"运输计划 {plan.plan_no}"
|
||
purchase_plan_id = db_plan.id if db_plan else None
|
||
inventory = DbInboundOutbound(
|
||
id=next_inbound_outbound_id(db, tenant_no),
|
||
tenant_no=tenant_no,
|
||
date=dibang_date,
|
||
partner_company=customer_name,
|
||
business_type=business_type,
|
||
quantity=Decimal(str(_product_quantity(product))),
|
||
plan_no=inventory_plan_no,
|
||
batch_no=_generate_batch_no(db, tenant_no),
|
||
vehicle_no=(license_plate or "").strip(),
|
||
status=status_value,
|
||
remark=remark,
|
||
purchase_plan_id=purchase_plan_id,
|
||
create_by=user_id,
|
||
create_dept_id=dept_id,
|
||
)
|
||
apply_product_snapshot_to_inventory(inventory, snapshot)
|
||
db.add(inventory)
|
||
db.flush()
|
||
return inventory
|
||
|
||
|
||
# 仅这些状态的出入库单可在「再次安排+勾地磅」时软删后重建
|
||
_REVOKABLE_INVENTORY_STATUSES = frozenset({"待入库", "待出库", "待三方填写", "待处理"})
|
||
|
||
|
||
def _inventory_has_weighing_slip(db: Session, inventory_id: str, *,
|
||
tenant_no: Optional[str] = None, current_read: bool = False) -> bool:
|
||
query = db.query(DbWeighingSlip.id).filter(
|
||
DbWeighingSlip.inbound_outbound_id == inventory_id,
|
||
DbWeighingSlip.del_flag == 0, DbWeighingSlip.is_voided == 0,
|
||
)
|
||
if tenant_no is not None:
|
||
query = query.filter(DbWeighingSlip.tenant_no == tenant_no)
|
||
if current_read:
|
||
query = query.with_for_update()
|
||
return query.first() is not None
|
||
|
||
|
||
def _sync_weighing_slip_business_fields(
|
||
db: Session,
|
||
*,
|
||
inventory: DbInboundOutbound,
|
||
user_id: Optional[str],
|
||
) -> None:
|
||
"""按出入库正文回写关联过磅单业务字段；称重数字一律不动。"""
|
||
slips = (
|
||
db.query(DbWeighingSlip)
|
||
.filter(
|
||
DbWeighingSlip.inbound_outbound_id == inventory.id,
|
||
DbWeighingSlip.tenant_no == inventory.tenant_no,
|
||
DbWeighingSlip.del_flag == 0,
|
||
DbWeighingSlip.is_voided == 0,
|
||
)
|
||
.with_for_update().all()
|
||
)
|
||
if not slips:
|
||
return
|
||
|
||
partner = (inventory.partner_company or "").strip()
|
||
business_type = (inventory.business_type or "").strip()
|
||
for slip in slips:
|
||
plate = (inventory.vehicle_no or "").strip()
|
||
if plate:
|
||
slip.vehicle_no = plate
|
||
if inventory.product_id:
|
||
slip.product_id = inventory.product_id
|
||
if inventory.product:
|
||
slip.cargo_name = inventory.product
|
||
slip.specification = inventory.specification
|
||
if business_type:
|
||
slip.business_type = business_type
|
||
if inventory.plan_no:
|
||
slip.plan_no = inventory.plan_no
|
||
if inventory.batch_no:
|
||
slip.batch_no = inventory.batch_no
|
||
if inventory.purchase_plan_id:
|
||
slip.purchase_plan_id = inventory.purchase_plan_id
|
||
if partner:
|
||
if business_type == "入库":
|
||
slip.supplier = partner
|
||
else:
|
||
slip.consignee = partner
|
||
slip.update_by = user_id
|
||
|
||
|
||
def revoke_regeneratable_dibang_for_transport(
|
||
db: Session,
|
||
*,
|
||
tenant_no: str,
|
||
transport_id: str,
|
||
user_id: Optional[str],
|
||
) -> None:
|
||
"""再次勾选地磅安排前：软删本运输单此前生成的、仍可作废的出入库单及关联。
|
||
|
||
- 不删除地磅月计划（可能被其他业务复用）
|
||
- 若出入库单已完成的/已有关联磅单 → 阻断并提示人工处理
|
||
"""
|
||
links = (
|
||
db.query(PlTransportDbLink)
|
||
.filter(
|
||
PlTransportDbLink.tenant_no == tenant_no,
|
||
PlTransportDbLink.transport_id == transport_id,
|
||
PlTransportDbLink.del_flag == 0,
|
||
)
|
||
.all()
|
||
)
|
||
if not links:
|
||
return
|
||
|
||
blocking: list[str] = []
|
||
for link in links:
|
||
inventory = (
|
||
db.query(DbInboundOutbound)
|
||
.filter(
|
||
DbInboundOutbound.id == link.db_inventory_id,
|
||
DbInboundOutbound.tenant_no == tenant_no,
|
||
DbInboundOutbound.del_flag == 0,
|
||
)
|
||
.first()
|
||
)
|
||
if not inventory:
|
||
link.del_flag = 1
|
||
link.update_by = user_id
|
||
continue
|
||
|
||
label = inventory.batch_no or inventory.id
|
||
status = (inventory.status or "").strip()
|
||
if status and status not in _REVOKABLE_INVENTORY_STATUSES:
|
||
blocking.append(f"{label}（状态：{status}）")
|
||
continue
|
||
if _inventory_has_weighing_slip(db, inventory.id):
|
||
blocking.append(f"{label}（已关联地磅单）")
|
||
|
||
if blocking:
|
||
raise ValueError(
|
||
"以下出入库单已执行或已关联地磅，无法随运输安排自动重建："
|
||
+ "；".join(blocking)
|
||
+ "。请在地磅管理中处理后再安排。"
|
||
)
|
||
|
||
for link in links:
|
||
inventory = (
|
||
db.query(DbInboundOutbound)
|
||
.filter(
|
||
DbInboundOutbound.id == link.db_inventory_id,
|
||
DbInboundOutbound.tenant_no == tenant_no,
|
||
DbInboundOutbound.del_flag == 0,
|
||
)
|
||
.first()
|
||
)
|
||
if inventory:
|
||
_subtract_plan_contribution(
|
||
db,
|
||
tenant_no=tenant_no,
|
||
link=link,
|
||
inventory=inventory,
|
||
user_id=user_id,
|
||
)
|
||
inventory.del_flag = 1
|
||
inventory.update_by = user_id
|
||
link.del_flag = 1
|
||
link.update_by = user_id
|
||
|
||
db.flush()
|
||
|
||
|
||
def _inventory_date_editable(db: Session, inventory: DbInboundOutbound) -> bool:
|
||
status = (inventory.status or "").strip()
|
||
if status and status not in _REVOKABLE_INVENTORY_STATUSES:
|
||
return False
|
||
if _inventory_has_weighing_slip(db, inventory.id):
|
||
return False
|
||
return True
|
||
|
||
|
||
def _find_active_stop_link(
|
||
db: Session,
|
||
*,
|
||
tenant_no: str,
|
||
transport_id: str,
|
||
plan_id: str,
|
||
stop_type: str,
|
||
stop_id: str,
|
||
plan_product_id: str,
|
||
) -> Optional[PlTransportDbLink]:
|
||
rows = db.query(PlTransportDbLink).filter(
|
||
PlTransportDbLink.tenant_no == tenant_no,
|
||
PlTransportDbLink.transport_id == transport_id,
|
||
PlTransportDbLink.plan_id == plan_id,
|
||
PlTransportDbLink.stop_type == stop_type,
|
||
PlTransportDbLink.stop_id == stop_id,
|
||
PlTransportDbLink.plan_product_id == plan_product_id,
|
||
PlTransportDbLink.del_flag == 0,
|
||
).with_for_update().all()
|
||
if len(rows) > 1:
|
||
raise ValueError("段产品存在重复地磅关联，请先核对历史数据")
|
||
return rows[0] if rows else None
|
||
|
||
|
||
def _soft_delete_link_and_inventory(
|
||
db: Session,
|
||
*,
|
||
tenant_no: str,
|
||
link: PlTransportDbLink,
|
||
user_id: Optional[str],
|
||
) -> None:
|
||
inventory = (
|
||
db.query(DbInboundOutbound)
|
||
.filter(
|
||
DbInboundOutbound.id == link.db_inventory_id,
|
||
DbInboundOutbound.tenant_no == tenant_no,
|
||
DbInboundOutbound.del_flag == 0,
|
||
)
|
||
.with_for_update().first()
|
||
)
|
||
if inventory:
|
||
_subtract_plan_contribution(
|
||
db,
|
||
tenant_no=tenant_no,
|
||
link=link,
|
||
inventory=inventory,
|
||
user_id=user_id, current_read=True,
|
||
)
|
||
inventory.del_flag = 1
|
||
inventory.update_by = user_id
|
||
link.del_flag = 1
|
||
link.update_by = user_id
|
||
|
||
|
||
def _cancel_stop_dibang_links(
|
||
db: Session,
|
||
*,
|
||
tenant_no: str,
|
||
transport_id: str,
|
||
plan_id: str,
|
||
stop_type: str,
|
||
stop_id: str,
|
||
user_id: Optional[str],
|
||
) -> None:
|
||
"""取消段 generate_dibang：已过磅阻断；否则软删 link+出入库并回减月计划。"""
|
||
links = (
|
||
db.query(PlTransportDbLink)
|
||
.filter(
|
||
PlTransportDbLink.tenant_no == tenant_no,
|
||
PlTransportDbLink.transport_id == transport_id,
|
||
PlTransportDbLink.plan_id == plan_id,
|
||
PlTransportDbLink.stop_type == stop_type,
|
||
PlTransportDbLink.stop_id == stop_id,
|
||
PlTransportDbLink.del_flag == 0,
|
||
)
|
||
.with_for_update().all()
|
||
)
|
||
if not links:
|
||
return
|
||
|
||
blocking: list[str] = []
|
||
for link in links:
|
||
inventory = (
|
||
db.query(DbInboundOutbound)
|
||
.filter(
|
||
DbInboundOutbound.id == link.db_inventory_id,
|
||
DbInboundOutbound.tenant_no == tenant_no,
|
||
DbInboundOutbound.del_flag == 0,
|
||
)
|
||
.with_for_update().first()
|
||
)
|
||
if not inventory:
|
||
continue
|
||
label = inventory.batch_no or inventory.id
|
||
status = (inventory.status or "").strip()
|
||
if status and status not in _REVOKABLE_INVENTORY_STATUSES:
|
||
blocking.append(f"{label}（状态：{status}）")
|
||
continue
|
||
if _inventory_has_weighing_slip(db, inventory.id, tenant_no=tenant_no, current_read=True):
|
||
blocking.append(label)
|
||
|
||
if blocking:
|
||
raise ValueError(
|
||
"以下出入库单已执行或已关联地磅，无法取消生成地磅："
|
||
+ "；".join(blocking)
|
||
+ "。请在地磅管理中处理后再操作。"
|
||
)
|
||
|
||
for link in links:
|
||
_soft_delete_link_and_inventory(
|
||
db,
|
||
tenant_no=tenant_no,
|
||
link=link,
|
||
user_id=user_id,
|
||
)
|
||
db.flush()
|
||
|
||
|
||
def _update_existing_stop_inventory(
|
||
db: Session,
|
||
*,
|
||
tenant_no: str,
|
||
plan: PlPlan,
|
||
link: PlTransportDbLink,
|
||
inventory: DbInboundOutbound,
|
||
product: _StopDibangProduct,
|
||
partner: str,
|
||
license_plate: str,
|
||
dibang_date: date,
|
||
user_id: Optional[str],
|
||
dept_id: str,
|
||
warnings: list[str],
|
||
) -> DibangInventoryLinkResult:
|
||
"""就地强制同步出入库正文（含已过磅），并回写关联过磅单业务字段。"""
|
||
label = inventory.batch_no or inventory.id
|
||
|
||
old_partner = (inventory.partner_company or "").strip()
|
||
old_product_id = (inventory.product_id or "").strip()
|
||
old_spec = (inventory.specification or "").strip()
|
||
old_plate = (inventory.vehicle_no or "").strip()
|
||
old_date = _normalize_to_date(inventory.date)
|
||
|
||
# —— 强制更新 partner / vehicle / 产品快照 / quantity ——
|
||
if partner and old_partner != partner:
|
||
inventory.partner_company = partner
|
||
|
||
plate = (license_plate or "").strip()
|
||
plate_changed = bool(plate and old_plate != plate)
|
||
if plate_changed:
|
||
inventory.vehicle_no = plate
|
||
|
||
incoming_product_id = (product.product_id or "").strip()
|
||
if incoming_product_id:
|
||
snapshot = resolve_crm_product(
|
||
db, tenant_no, incoming_product_id, require_on_shelf=False
|
||
)
|
||
apply_product_snapshot_to_inventory(inventory, snapshot)
|
||
|
||
# 数量差量先作用于当前挂靠月计划（改挂前）；改挂时会整额扣回旧计划
|
||
new_qty = float(product.quantity)
|
||
old_qty = _resolve_link_contributed_qty(link, inventory)
|
||
if abs(new_qty - old_qty) > 1e-9:
|
||
delta = new_qty - old_qty
|
||
if link.db_purchase_plan_id:
|
||
db_plan = (
|
||
db.query(DbPurchasePlan)
|
||
.filter(
|
||
DbPurchasePlan.id == link.db_purchase_plan_id,
|
||
DbPurchasePlan.tenant_no == tenant_no,
|
||
DbPurchasePlan.del_flag == 0,
|
||
)
|
||
.with_for_update().first()
|
||
)
|
||
if db_plan:
|
||
_apply_plan_quantity_delta(db_plan, delta, user_id=user_id)
|
||
inventory.quantity = Decimal(str(new_qty))
|
||
link.contributed_qty = Decimal(str(new_qty))
|
||
|
||
new_partner = (inventory.partner_company or "").strip()
|
||
new_product_id = (inventory.product_id or "").strip()
|
||
new_spec = (inventory.specification or "").strip()
|
||
need_remount = (
|
||
(partner and old_partner != new_partner)
|
||
or (old_product_id and new_product_id and old_product_id != new_product_id)
|
||
or (old_spec != new_spec and bool(new_product_id or old_product_id))
|
||
)
|
||
|
||
remounted = False
|
||
if need_remount:
|
||
qty = _resolve_link_contributed_qty(link, inventory)
|
||
_subtract_plan_contribution(
|
||
db,
|
||
tenant_no=tenant_no,
|
||
link=link,
|
||
inventory=inventory,
|
||
user_id=user_id, current_read=True,
|
||
)
|
||
try:
|
||
new_db_plan = _ensure_monthly_db_plan_for_inventory(
|
||
db,
|
||
tenant_no=tenant_no,
|
||
plan=plan,
|
||
inventory=inventory,
|
||
dibang_date=dibang_date,
|
||
contributed_qty=qty,
|
||
user_id=user_id,
|
||
dept_id=dept_id or "",
|
||
strict_monthly=True,
|
||
)
|
||
link.db_purchase_plan_id = new_db_plan.id
|
||
inventory.purchase_plan_id = new_db_plan.id
|
||
inventory.plan_no = (new_db_plan.plan_no or "").strip() or inventory.plan_no
|
||
remounted = True
|
||
except ValueError as exc:
|
||
warnings.append(f"出入库单 {label} 往来/产品改挂失败：{exc}")
|
||
elif plate_changed and link.db_purchase_plan_id:
|
||
db_plan = (
|
||
db.query(DbPurchasePlan)
|
||
.filter(
|
||
DbPurchasePlan.id == link.db_purchase_plan_id,
|
||
DbPurchasePlan.tenant_no == tenant_no,
|
||
DbPurchasePlan.del_flag == 0,
|
||
)
|
||
.with_for_update().first()
|
||
)
|
||
if db_plan:
|
||
db_plan.vehicle_no = plate
|
||
db_plan.update_by = user_id
|
||
|
||
# —— date：同月仅改日期；跨月改挂（本轮已因往来/产品改挂则不再二次扣量）——
|
||
if old_date != dibang_date:
|
||
same_month = (
|
||
old_date is not None
|
||
and old_date.year == dibang_date.year
|
||
and old_date.month == dibang_date.month
|
||
)
|
||
inventory.date = dibang_date
|
||
if not same_month and not remounted:
|
||
qty = _resolve_link_contributed_qty(link, inventory)
|
||
_subtract_plan_contribution(
|
||
db,
|
||
tenant_no=tenant_no,
|
||
link=link,
|
||
inventory=inventory,
|
||
user_id=user_id, current_read=True,
|
||
)
|
||
try:
|
||
new_db_plan = _ensure_monthly_db_plan_for_inventory(
|
||
db,
|
||
tenant_no=tenant_no,
|
||
plan=plan,
|
||
inventory=inventory,
|
||
dibang_date=dibang_date,
|
||
contributed_qty=qty,
|
||
user_id=user_id,
|
||
dept_id=dept_id or "",
|
||
strict_monthly=True,
|
||
)
|
||
link.db_purchase_plan_id = new_db_plan.id
|
||
inventory.purchase_plan_id = new_db_plan.id
|
||
inventory.plan_no = (new_db_plan.plan_no or "").strip() or inventory.plan_no
|
||
except ValueError as exc:
|
||
warnings.append(f"出入库单 {label} 跨月改挂失败：{exc}")
|
||
|
||
desired_remark = f"运输计划 {plan.plan_no}"
|
||
inventory.remark = desired_remark
|
||
link.remark = desired_remark
|
||
inventory.update_by = user_id
|
||
link.update_by = user_id
|
||
|
||
_sync_weighing_slip_business_fields(db, inventory=inventory, user_id=user_id)
|
||
|
||
return DibangInventoryLinkResult(
|
||
plan_product_id=product.plan_product_id,
|
||
product_name=product.product_name or "",
|
||
db_purchase_plan_id=link.db_purchase_plan_id or "",
|
||
db_inventory_id=inventory.id,
|
||
batch_no=inventory.batch_no or "",
|
||
plan_no=(inventory.plan_no or plan.plan_no) or "",
|
||
)
|
||
|
||
|
||
def _resolve_link_dibang_date(
|
||
plan: PlPlan,
|
||
link: PlTransportDbLink,
|
||
load: Optional[PlPlanLoad],
|
||
deliveries: list[PlPlanDelivery],
|
||
) -> date:
|
||
stop_type = (link.stop_type or "").strip()
|
||
if stop_type == "load":
|
||
return _resolve_stop_dibang_date(
|
||
plan,
|
||
stop_type="load",
|
||
load_time=load.load_time if load else None,
|
||
)
|
||
if stop_type == "delivery":
|
||
delivery = next((row for row in deliveries if row.id == link.stop_id), None)
|
||
if delivery is None and len(deliveries) == 1:
|
||
delivery = deliveries[0]
|
||
return _resolve_stop_dibang_date(
|
||
plan,
|
||
stop_type="delivery",
|
||
delivery_time=delivery.delivery_time if delivery else None,
|
||
)
|
||
return _resolve_dibang_date(plan)
|
||
|
||
|
||
def _ensure_monthly_db_plan_for_inventory(
|
||
db: Session,
|
||
*,
|
||
tenant_no: str,
|
||
plan: PlPlan,
|
||
inventory: DbInboundOutbound,
|
||
dibang_date: date,
|
||
contributed_qty: float,
|
||
user_id: Optional[str],
|
||
dept_id: str,
|
||
strict_monthly: bool = False,
|
||
) -> DbPurchasePlan:
|
||
business_type = (inventory.business_type or "").strip()
|
||
partner = (inventory.partner_company or "").strip()
|
||
product_id = (inventory.product_id or "").strip()
|
||
if not business_type or not product_id:
|
||
raise ValueError("出入库单缺少业务类型或产品，无法改挂地磅月计划")
|
||
|
||
find_target = _find_stop_monthly_plan if strict_monthly else find_monthly_db_plan
|
||
existing = find_target(
|
||
db,
|
||
tenant_no,
|
||
dibang_date,
|
||
business_type,
|
||
partner,
|
||
product_id,
|
||
inventory.specification,
|
||
)
|
||
if existing:
|
||
if contributed_qty:
|
||
_apply_plan_quantity_delta(existing, contributed_qty, user_id=user_id)
|
||
return existing
|
||
|
||
month_start, month_end = _month_range(dibang_date)
|
||
product = PlPlanProduct(
|
||
id=generate_uuid(),
|
||
product_id=product_id,
|
||
product_name=inventory.product or "",
|
||
model=inventory.specification,
|
||
unit="吨",
|
||
quantity=Decimal(str(contributed_qty or inventory.quantity or 0)),
|
||
)
|
||
return _create_db_plan(
|
||
db,
|
||
tenant_no,
|
||
plan,
|
||
product,
|
||
business_type,
|
||
partner,
|
||
dibang_date,
|
||
month_start,
|
||
month_end,
|
||
user_id,
|
||
dept_id,
|
||
contributed_qty or float(inventory.quantity or 0),
|
||
)
|
||
|
||
|
||
def sync_linked_dibang_dates_for_plan(
|
||
db: Session,
|
||
*,
|
||
tenant_no: str,
|
||
plan: PlPlan,
|
||
user_id: Optional[str],
|
||
dept_id: str = "",
|
||
) -> list[str]:
|
||
"""计划保存后按当前段次/计划日期回写可编辑出入库单日期；跨月则改挂月计划。
|
||
|
||
不可回写时不抛错，返回 warnings。
|
||
"""
|
||
links = (
|
||
db.query(PlTransportDbLink)
|
||
.filter(
|
||
PlTransportDbLink.tenant_no == tenant_no,
|
||
PlTransportDbLink.plan_id == plan.id,
|
||
PlTransportDbLink.del_flag == 0,
|
||
)
|
||
.all()
|
||
)
|
||
if not links:
|
||
return []
|
||
|
||
load = (
|
||
db.query(PlPlanLoad)
|
||
.filter(
|
||
PlPlanLoad.plan_id == plan.id,
|
||
PlPlanLoad.tenant_no == tenant_no,
|
||
PlPlanLoad.del_flag == 0,
|
||
)
|
||
.first()
|
||
)
|
||
deliveries = (
|
||
db.query(PlPlanDelivery)
|
||
.filter(
|
||
PlPlanDelivery.plan_id == plan.id,
|
||
PlPlanDelivery.tenant_no == tenant_no,
|
||
PlPlanDelivery.del_flag == 0,
|
||
)
|
||
.order_by(PlPlanDelivery.seq.asc(), PlPlanDelivery.create_time.asc())
|
||
.all()
|
||
)
|
||
|
||
warnings: list[str] = []
|
||
for link in links:
|
||
inventory = (
|
||
db.query(DbInboundOutbound)
|
||
.filter(
|
||
DbInboundOutbound.id == link.db_inventory_id,
|
||
DbInboundOutbound.tenant_no == tenant_no,
|
||
DbInboundOutbound.del_flag == 0,
|
||
)
|
||
.first()
|
||
)
|
||
if not inventory:
|
||
continue
|
||
|
||
new_date = _resolve_link_dibang_date(plan, link, load, deliveries)
|
||
old_date = _normalize_to_date(inventory.date)
|
||
if old_date == new_date:
|
||
continue
|
||
|
||
label = inventory.batch_no or inventory.id
|
||
if not _inventory_date_editable(db, inventory):
|
||
status = (inventory.status or "").strip() or "未知状态"
|
||
if _inventory_has_weighing_slip(db, inventory.id):
|
||
reason = "已关联地磅单"
|
||
else:
|
||
reason = f"状态：{status}"
|
||
warnings.append(
|
||
f"出入库单 {label}（{reason}）未同步日期至 {new_date.isoformat()}，请在地磅管理中手工处理"
|
||
)
|
||
continue
|
||
|
||
same_month = (
|
||
old_date is not None
|
||
and old_date.year == new_date.year
|
||
and old_date.month == new_date.month
|
||
)
|
||
inventory.date = new_date
|
||
inventory.update_by = user_id
|
||
|
||
if same_month:
|
||
continue
|
||
|
||
qty = _resolve_link_contributed_qty(link, inventory)
|
||
_subtract_plan_contribution(
|
||
db,
|
||
tenant_no=tenant_no,
|
||
link=link,
|
||
inventory=inventory,
|
||
user_id=user_id,
|
||
)
|
||
try:
|
||
new_db_plan = _ensure_monthly_db_plan_for_inventory(
|
||
db,
|
||
tenant_no=tenant_no,
|
||
plan=plan,
|
||
inventory=inventory,
|
||
dibang_date=new_date,
|
||
contributed_qty=qty,
|
||
user_id=user_id,
|
||
dept_id=dept_id or "",
|
||
)
|
||
except ValueError as exc:
|
||
warnings.append(f"出入库单 {label} 跨月改挂失败：{exc}")
|
||
continue
|
||
|
||
link.db_purchase_plan_id = new_db_plan.id
|
||
link.update_by = user_id
|
||
inventory.purchase_plan_id = new_db_plan.id
|
||
inventory.plan_no = (new_db_plan.plan_no or "").strip() or inventory.plan_no
|
||
|
||
db.flush()
|
||
return warnings
|
||
|
||
|
||
def _sync_stop_inventory_links(
|
||
db: Session,
|
||
*,
|
||
tenant_no: str,
|
||
plan: PlPlan,
|
||
transport: PlTransport,
|
||
stop_type: str,
|
||
stop_id: str,
|
||
partner: str,
|
||
business_type: str,
|
||
dibang_date: date,
|
||
stop_products: list[_StopDibangProduct],
|
||
user_id: Optional[str],
|
||
dept_id: str,
|
||
warnings: Optional[list[str]] = None,
|
||
) -> list[DibangInventoryLinkResult]:
|
||
"""按段产品 upsert 出入库+link：已有则就地更新，无则新建。"""
|
||
if not partner:
|
||
raise ValueError("无法解析往来单位，请检查段客户信息")
|
||
|
||
month_start, month_end = _month_range(dibang_date)
|
||
license_plate = (transport.license_plate or plan.license_plate or "").strip()
|
||
results: list[DibangInventoryLinkResult] = []
|
||
warn_buf = warnings if warnings is not None else []
|
||
|
||
for product in stop_products:
|
||
if not product.product_id:
|
||
raise ValueError(f"产品【{product.product_name}】未关联 CRM 产品，无法生成地磅出入库单")
|
||
|
||
contributed_qty = product.quantity
|
||
existing_link = _find_active_stop_link(
|
||
db,
|
||
tenant_no=tenant_no,
|
||
transport_id=transport.id,
|
||
plan_id=plan.id,
|
||
stop_type=stop_type,
|
||
stop_id=stop_id,
|
||
plan_product_id=product.plan_product_id,
|
||
)
|
||
if existing_link:
|
||
inventory = (
|
||
db.query(DbInboundOutbound)
|
||
.filter(
|
||
DbInboundOutbound.id == existing_link.db_inventory_id,
|
||
DbInboundOutbound.tenant_no == tenant_no,
|
||
DbInboundOutbound.del_flag == 0,
|
||
)
|
||
.with_for_update().first()
|
||
)
|
||
if inventory:
|
||
results.append(
|
||
_update_existing_stop_inventory(
|
||
db,
|
||
tenant_no=tenant_no,
|
||
plan=plan,
|
||
link=existing_link,
|
||
inventory=inventory,
|
||
product=product,
|
||
partner=partner,
|
||
license_plate=license_plate,
|
||
dibang_date=dibang_date,
|
||
user_id=user_id,
|
||
dept_id=dept_id,
|
||
warnings=warn_buf,
|
||
)
|
||
)
|
||
continue
|
||
raise ValueError("地磅关联的出入库单缺失或已删除，请先核对历史数据")
|
||
|
||
if contributed_qty == 0:
|
||
continue
|
||
plan_product = PlPlanProduct(
|
||
id=product.plan_product_id,
|
||
product_id=product.product_id,
|
||
product_name=product.product_name,
|
||
model=product.model,
|
||
unit=product.unit,
|
||
quantity=Decimal(str(contributed_qty)),
|
||
)
|
||
|
||
snapshot = resolve_crm_product(db, tenant_no, product.product_id, require_on_shelf=False)
|
||
db_plan = _find_stop_monthly_plan(
|
||
db,
|
||
tenant_no,
|
||
dibang_date,
|
||
business_type,
|
||
partner,
|
||
product.product_id,
|
||
snapshot.specification,
|
||
)
|
||
if not db_plan:
|
||
db_plan = _create_db_plan(
|
||
db,
|
||
tenant_no,
|
||
plan,
|
||
plan_product,
|
||
business_type,
|
||
partner,
|
||
dibang_date,
|
||
month_start,
|
||
month_end,
|
||
user_id,
|
||
dept_id,
|
||
contributed_qty,
|
||
)
|
||
else:
|
||
_apply_plan_quantity_delta(db_plan, contributed_qty, user_id=user_id)
|
||
|
||
inventory = _create_db_inventory(
|
||
db,
|
||
tenant_no,
|
||
plan,
|
||
plan_product,
|
||
db_plan,
|
||
business_type,
|
||
partner,
|
||
license_plate,
|
||
dibang_date,
|
||
user_id,
|
||
dept_id,
|
||
)
|
||
|
||
link = PlTransportDbLink(
|
||
id=generate_uuid(),
|
||
tenant_no=tenant_no,
|
||
transport_id=transport.id,
|
||
plan_id=plan.id,
|
||
plan_product_id=product.plan_product_id,
|
||
stop_type=stop_type,
|
||
stop_id=stop_id,
|
||
db_purchase_plan_id=db_plan.id if db_plan else "",
|
||
db_inventory_id=inventory.id,
|
||
contributed_qty=Decimal(str(contributed_qty)),
|
||
remark=f"运输计划 {plan.plan_no}",
|
||
create_by=user_id,
|
||
create_dept_id=dept_id,
|
||
)
|
||
db.add(link)
|
||
|
||
results.append(
|
||
DibangInventoryLinkResult(
|
||
plan_product_id=product.plan_product_id,
|
||
product_name=product.product_name or "",
|
||
db_purchase_plan_id=db_plan.id if db_plan else "",
|
||
db_inventory_id=inventory.id,
|
||
batch_no=inventory.batch_no or "",
|
||
plan_no=(db_plan.plan_no if db_plan else plan.plan_no) or "",
|
||
)
|
||
)
|
||
|
||
return results
|
||
|
||
|
||
def _resolve_stop_dibang_date(
|
||
plan: PlPlan,
|
||
*,
|
||
stop_type: str,
|
||
load_time: date | datetime | str | None = None,
|
||
delivery_time: date | datetime | str | None = None,
|
||
) -> date:
|
||
if stop_type == "load":
|
||
resolved = _normalize_to_date(load_time)
|
||
if resolved is None:
|
||
resolved = _normalize_to_date(plan.pickup_time)
|
||
else:
|
||
resolved = _normalize_to_date(delivery_time)
|
||
if resolved is None:
|
||
resolved = _normalize_to_date(plan.delivery_time)
|
||
return resolved or _normalize_plan_date(plan)
|
||
|
||
|
||
def _aggregate_stop_products(products: list[_StopDibangProduct]) -> list[_StopDibangProduct]:
|
||
"""桥接只有主产品关联键；同键多包装合并数量，不猜配冲突身份。"""
|
||
grouped = {}
|
||
quantities = {}
|
||
for product in products:
|
||
key = product.plan_product_id
|
||
qty = Decimal(str(product.quantity))
|
||
if not key or not product.product_id or not qty.is_finite() or qty < 0:
|
||
raise ValueError("段产品关联或计划数量无效，请先核对明细")
|
||
previous = grouped.get(key)
|
||
if previous and any((getattr(previous, field) or "").strip() !=
|
||
(getattr(product, field) or "").strip()
|
||
for field in ("product_id", "model", "unit")):
|
||
raise ValueError("同一计划产品的段明细产品、规格或单位不一致，不能合并地磅贡献量")
|
||
if previous is None:
|
||
grouped[key] = _StopDibangProduct(**vars(product))
|
||
quantities[key] = Decimal("0")
|
||
quantities[key] += qty
|
||
for key, product in grouped.items():
|
||
product.quantity = float(quantities[key])
|
||
return list(grouped.values())
|
||
|
||
|
||
def _refresh_clean_locked(db: Session, row) -> None:
|
||
# 计划保存调用前可能已改日期/反馈；只刷新未修改对象，不能吞掉 pending 字段。
|
||
if row not in db.new and not db.is_modified(row, include_collections=False):
|
||
db.refresh(row, with_for_update=True)
|
||
|
||
|
||
def _preflight_stop_dibang_request(db: Session, *, tenant_no: str, plan: PlPlan,
|
||
transport: PlTransport, stop_options: list[StopDibangOption]) -> None:
|
||
"""整批先锁定、验证；不修改勾选、月数量、关联或出入库单。"""
|
||
if plan.tenant_no != tenant_no or plan.del_flag == 1 or transport.tenant_no != tenant_no or transport.del_flag == 1:
|
||
raise ValueError("运输单或计划无效，无法同步地磅")
|
||
if plan.transport_id and plan.transport_id != transport.id:
|
||
raise ValueError("运输单不属于当前计划")
|
||
with db.no_autoflush:
|
||
if db.query(PlPlan.id).filter(PlPlan.id == plan.id, PlPlan.tenant_no == tenant_no,
|
||
PlPlan.del_flag == 0).with_for_update().first() is None:
|
||
raise ValueError("计划不存在或已删除")
|
||
_refresh_clean_locked(db, plan)
|
||
if plan.transport_id and plan.transport_id != transport.id:
|
||
raise ValueError("运输单不属于当前计划")
|
||
owner = db.query(PlTransport.id).filter(PlTransport.id == transport.id,
|
||
PlTransport.tenant_no == tenant_no, PlTransport.del_flag == 0).with_for_update().first()
|
||
if owner is None and transport not in db.new:
|
||
raise ValueError("运输单不存在或已删除")
|
||
if owner is not None:
|
||
_refresh_clean_locked(db, transport)
|
||
# 新运输尚未 INSERT 时由上述计划锁保护；通过验证后才 flush。
|
||
stops = {}
|
||
for kind, model in (("load", PlPlanLoad), ("delivery", PlPlanDelivery)):
|
||
rows = db.query(model).filter(model.tenant_no == tenant_no, model.plan_id == plan.id,
|
||
model.del_flag == 0).with_for_update().all()
|
||
rows.extend(row for row in db.new if isinstance(row, model) and row.tenant_no == tenant_no
|
||
and row.plan_id == plan.id)
|
||
for row in rows:
|
||
_refresh_clean_locked(db, row)
|
||
if row.del_flag != 1:
|
||
stops[(kind, row.id)] = row
|
||
seen, requested = set(), []
|
||
for option in stop_options:
|
||
key = option.stop_type, option.stop_id
|
||
if key in seen or key not in stops:
|
||
raise ValueError("停靠段重复、不存在或不属于当前计划")
|
||
seen.add(key)
|
||
stop = stops[key]
|
||
generate, direction = normalize_stop_dibang_fields(stop.customer_name, option.stop_type,
|
||
int(option.generate_dibang), stop.dibang_direction)
|
||
requested.append((option, stop, generate, direction))
|
||
|
||
plan_products = {row.id: row for row in db.query(PlPlanProduct).filter(
|
||
PlPlanProduct.tenant_no == tenant_no, PlPlanProduct.plan_id == plan.id,
|
||
PlPlanProduct.del_flag == 0).with_for_update().all()}
|
||
plan_products.update({row.id: row for row in db.new if isinstance(row, PlPlanProduct)
|
||
and row.tenant_no == tenant_no and row.plan_id == plan.id})
|
||
for row in plan_products.values():
|
||
_refresh_clean_locked(db, row)
|
||
source_products = {}
|
||
for option, stop, generate, direction in requested:
|
||
model = PlPlanLoadProduct if option.stop_type == "load" else PlPlanDeliveryProduct
|
||
parent_field = "load_id" if option.stop_type == "load" else "delivery_id"
|
||
rows = db.query(model).filter(model.tenant_no == tenant_no,
|
||
getattr(model, parent_field) == stop.id, model.del_flag == 0).with_for_update().all()
|
||
rows.extend(row for row in db.new if isinstance(row, model) and row.tenant_no == tenant_no
|
||
and getattr(row, parent_field) == stop.id)
|
||
rows = [row for row in rows if row.del_flag != 1]
|
||
products = []
|
||
for row in rows:
|
||
_refresh_clean_locked(db, row)
|
||
pp = plan_products.get(row.plan_product_id)
|
||
if row.plan_id != plan.id or pp is None or pp.del_flag == 1 or pp.product_id != row.product_id:
|
||
raise ValueError("段产品不属于当前计划有效主产品")
|
||
products.append(_StopDibangProduct(row.plan_product_id, row.product_id,
|
||
row.product_name or "", row.model, row.unit or "吨", _stop_product_quantity(row)))
|
||
source_products[(option.stop_type, stop.id)] = _aggregate_stop_products(products)
|
||
if generate and not products:
|
||
raise ValueError("停靠段无产品明细，无法生成地磅单")
|
||
product_ids = sorted({p.product_id for products in source_products.values() for p in products})
|
||
masters = db.query(CrmProduct).filter(CrmProduct.tenant_no == tenant_no,
|
||
CrmProduct.id.in_(product_ids)).order_by(CrmProduct.id).with_for_update().all()
|
||
for row in masters:
|
||
_refresh_clean_locked(db, row)
|
||
if {row.id for row in masters if row.del_flag == 0} != set(product_ids):
|
||
raise ValueError("段产品关联的 CRM 产品不存在或已删除")
|
||
|
||
load = next((stop for (kind, _), stop in stops.items() if kind == "load"), None)
|
||
deliveries = sorted([stop for (kind, _), stop in stops.items() if kind == "delivery"],
|
||
key=lambda row: (row.seq or 0, row.id))
|
||
contributions = {}
|
||
for option, stop, generate, direction in requested:
|
||
links = db.query(PlTransportDbLink).filter(PlTransportDbLink.tenant_no == tenant_no,
|
||
PlTransportDbLink.transport_id == transport.id,
|
||
PlTransportDbLink.stop_id == stop.id, PlTransportDbLink.del_flag == 0).with_for_update().all()
|
||
keys, existing_directions = set(), {}
|
||
for link in links:
|
||
_refresh_clean_locked(db, link)
|
||
if link.plan_id != plan.id or link.stop_type != option.stop_type or link.plan_product_id in keys:
|
||
raise ValueError("段产品地磅关联归属异常或重复，请先核对历史数据")
|
||
keys.add(link.plan_product_id)
|
||
if link.plan_product_id not in plan_products or plan_products[link.plan_product_id].del_flag == 1:
|
||
raise ValueError("地磅关联主产品无效，请先核对历史数据")
|
||
inventory = db.query(DbInboundOutbound).filter(DbInboundOutbound.id == link.db_inventory_id,
|
||
DbInboundOutbound.tenant_no == tenant_no, DbInboundOutbound.del_flag == 0).with_for_update().first()
|
||
month = db.query(DbPurchasePlan).filter(DbPurchasePlan.id == link.db_purchase_plan_id,
|
||
DbPurchasePlan.tenant_no == tenant_no, DbPurchasePlan.del_flag == 0).with_for_update().first()
|
||
if inventory is None or month is None:
|
||
raise ValueError("地磅关联的出入库单或月计划缺失、已删除，请先核对历史数据")
|
||
_refresh_clean_locked(db, inventory)
|
||
_refresh_clean_locked(db, month)
|
||
if inventory.purchase_plan_id != month.id or any(
|
||
(getattr(month, key) or "").strip() != (getattr(inventory, other) or "").strip()
|
||
for key, other in (("business_type", "business_type"), ("product_id", "product_id"),
|
||
("customer_name", "partner_company"), ("specification", "specification"))
|
||
):
|
||
raise ValueError("地磅关联的出入库单与月计划不一致")
|
||
existing_directions[link.plan_product_id] = inventory.business_type
|
||
users = db.query(PlTransportDbLink.id).filter(PlTransportDbLink.tenant_no == tenant_no,
|
||
PlTransportDbLink.db_inventory_id == inventory.id, PlTransportDbLink.del_flag == 0).with_for_update().all()
|
||
if len(users) != 1:
|
||
raise ValueError("出入库单存在多个有效地磅关联，请先核对历史数据")
|
||
old_qty = Decimal(str(_resolve_link_contributed_qty(link, inventory)))
|
||
contributions[month.id] = contributions.get(month.id, Decimal("0")) + old_qty
|
||
if not old_qty.is_finite() or old_qty < 0 or contributions[month.id] > Decimal(str(month.planned_quantity or 0)):
|
||
raise ValueError("地磅月计划贡献量异常，请先核对历史数据")
|
||
if not generate and ((inventory.status or "").strip() not in _REVOKABLE_INVENTORY_STATUSES
|
||
or _inventory_has_weighing_slip(db, inventory.id, tenant_no=tenant_no, current_read=True)):
|
||
raise ValueError(f"出入库单 {inventory.batch_no or inventory.id} 已执行或已关联地磅，无法取消生成地磅")
|
||
if generate:
|
||
partner = resolve_stop_dibang_partner(option.stop_type, load, deliveries)
|
||
if not partner:
|
||
raise ValueError("无法解析地磅往来单位，请先配置停靠段客户")
|
||
# 提前解析所有产品快照和目标月计划；后段错误不得先写前段。
|
||
when = _resolve_stop_dibang_date(plan, stop_type=option.stop_type,
|
||
load_time=getattr(stop, "load_time", None), delivery_time=getattr(stop, "delivery_time", None))
|
||
for product in source_products[(option.stop_type, stop.id)]:
|
||
snapshot = resolve_crm_product(db, tenant_no, product.product_id, require_on_shelf=False)
|
||
target = _find_stop_monthly_plan(db, tenant_no, when,
|
||
existing_directions.get(product.plan_product_id) or _direction_to_business_type(direction),
|
||
partner, snapshot.product_id, snapshot.specification)
|
||
if target is not None:
|
||
_refresh_clean_locked(db, target)
|
||
|
||
|
||
def _load_stop_products(
|
||
db: Session,
|
||
tenant_no: str,
|
||
load_id: str,
|
||
) -> list[_StopDibangProduct]:
|
||
rows = (
|
||
db.query(PlPlanLoadProduct)
|
||
.filter(
|
||
PlPlanLoadProduct.load_id == load_id,
|
||
PlPlanLoadProduct.tenant_no == tenant_no,
|
||
PlPlanLoadProduct.del_flag == 0,
|
||
)
|
||
.order_by(PlPlanLoadProduct.order_num.asc(), PlPlanLoadProduct.create_time.asc())
|
||
.with_for_update().all()
|
||
)
|
||
return _aggregate_stop_products([
|
||
_StopDibangProduct(
|
||
plan_product_id=row.plan_product_id,
|
||
product_id=row.product_id,
|
||
product_name=row.product_name or "",
|
||
model=row.model,
|
||
unit=row.unit or "吨",
|
||
quantity=_stop_product_quantity(row),
|
||
)
|
||
for row in rows
|
||
])
|
||
|
||
|
||
def _delivery_stop_products(
|
||
db: Session,
|
||
tenant_no: str,
|
||
delivery_id: str,
|
||
) -> list[_StopDibangProduct]:
|
||
rows = (
|
||
db.query(PlPlanDeliveryProduct)
|
||
.filter(
|
||
PlPlanDeliveryProduct.delivery_id == delivery_id,
|
||
PlPlanDeliveryProduct.tenant_no == tenant_no,
|
||
PlPlanDeliveryProduct.del_flag == 0,
|
||
)
|
||
.order_by(PlPlanDeliveryProduct.order_num.asc(), PlPlanDeliveryProduct.create_time.asc())
|
||
.with_for_update().all()
|
||
)
|
||
return _aggregate_stop_products([
|
||
_StopDibangProduct(
|
||
plan_product_id=row.plan_product_id,
|
||
product_id=row.product_id,
|
||
product_name=row.product_name or "",
|
||
model=row.model,
|
||
unit=row.unit or "吨",
|
||
quantity=_stop_product_quantity(row),
|
||
)
|
||
for row in rows
|
||
])
|
||
|
||
|
||
def upsert_stop_dibang_links(
|
||
db: Session,
|
||
*,
|
||
tenant_no: str,
|
||
plan: PlPlan,
|
||
transport: PlTransport,
|
||
stop_options: list[StopDibangOption],
|
||
user_id: Optional[str],
|
||
dept_id: str,
|
||
) -> tuple[list[DibangInventoryLinkResult], list[str]]:
|
||
"""按段 upsert 地磅出入库与 link：新建 / 就地更新 / 取消勾选软删。
|
||
|
||
返回 (link_results, warnings)。产品/往来变更就地同步（跨月改挂完整逻辑见 Task 3）；
|
||
已过磅取消勾选时抛 ValueError。
|
||
"""
|
||
_preflight_stop_dibang_request(db, tenant_no=tenant_no, plan=plan,
|
||
transport=transport, stop_options=stop_options)
|
||
# 验证全部通过后才保存调用方 pending 的新段/新运输，供后续查询使用。
|
||
db.flush()
|
||
apply_stop_dibang_options(
|
||
db,
|
||
tenant_no=tenant_no,
|
||
plan_id=plan.id,
|
||
stop_options=stop_options,
|
||
user_id=user_id,
|
||
)
|
||
|
||
option_map = {(item.stop_type, item.stop_id): item for item in stop_options}
|
||
results: list[DibangInventoryLinkResult] = []
|
||
warnings: list[str] = []
|
||
|
||
deliveries = (
|
||
db.query(PlPlanDelivery)
|
||
.filter(
|
||
PlPlanDelivery.plan_id == plan.id,
|
||
PlPlanDelivery.tenant_no == tenant_no,
|
||
PlPlanDelivery.del_flag == 0,
|
||
)
|
||
.order_by(PlPlanDelivery.seq.asc(), PlPlanDelivery.create_time.asc())
|
||
.with_for_update().all()
|
||
)
|
||
|
||
load = (
|
||
db.query(PlPlanLoad)
|
||
.filter(
|
||
PlPlanLoad.plan_id == plan.id,
|
||
PlPlanLoad.tenant_no == tenant_no,
|
||
PlPlanLoad.del_flag == 0,
|
||
)
|
||
.with_for_update().first()
|
||
)
|
||
|
||
def _handle_stop(
|
||
*,
|
||
stop_type: Literal["load", "delivery"],
|
||
stop: PlPlanLoad | PlPlanDelivery,
|
||
partner: str,
|
||
dibang_date: date,
|
||
) -> None:
|
||
option = option_map.get((stop_type, stop.id))
|
||
if option is None:
|
||
return
|
||
# 以 apply_stop_dibang_options 归一化后的段字段为准（外部客户会被强制清勾选）
|
||
if not int(getattr(stop, "generate_dibang", 0) or 0):
|
||
_cancel_stop_dibang_links(
|
||
db,
|
||
tenant_no=tenant_no,
|
||
transport_id=transport.id,
|
||
plan_id=plan.id,
|
||
stop_type=stop_type,
|
||
stop_id=stop.id,
|
||
user_id=user_id,
|
||
)
|
||
return
|
||
|
||
if stop_type == "load":
|
||
stop_products = _load_stop_products(db, tenant_no, stop.id)
|
||
else:
|
||
stop_products = _delivery_stop_products(db, tenant_no, stop.id)
|
||
|
||
business_type = _resolve_stop_business_type(stop, stop_type)
|
||
if not business_type:
|
||
stop_label = getattr(stop, "customer_name", None) or stop.id
|
||
raise ValueError(f"{'装货' if stop_type == 'load' else '送货'}段【{stop_label}】未配置地磅方向，无法生成地磅单")
|
||
if not stop_products:
|
||
stop_label = getattr(stop, "customer_name", None) or stop.id
|
||
raise ValueError(f"{'装货' if stop_type == 'load' else '送货'}段【{stop_label}】无产品明细，无法生成地磅单")
|
||
if not partner:
|
||
raise ValueError(
|
||
"无法解析装货段地磅往来单位，请先配置送货客户"
|
||
if stop_type == "load"
|
||
else "无法解析送货段地磅往来单位，请先配置装货客户"
|
||
)
|
||
results.extend(
|
||
_sync_stop_inventory_links(
|
||
db,
|
||
tenant_no=tenant_no,
|
||
plan=plan,
|
||
transport=transport,
|
||
stop_type=stop_type,
|
||
stop_id=stop.id,
|
||
partner=partner,
|
||
business_type=business_type,
|
||
dibang_date=dibang_date,
|
||
stop_products=stop_products,
|
||
user_id=user_id,
|
||
dept_id=dept_id,
|
||
warnings=warnings,
|
||
)
|
||
)
|
||
|
||
if load:
|
||
_handle_stop(
|
||
stop_type="load",
|
||
stop=load,
|
||
partner=resolve_stop_dibang_partner("load", load, deliveries),
|
||
dibang_date=_resolve_stop_dibang_date(
|
||
plan,
|
||
stop_type="load",
|
||
load_time=load.load_time,
|
||
),
|
||
)
|
||
|
||
for delivery in deliveries:
|
||
_handle_stop(
|
||
stop_type="delivery",
|
||
stop=delivery,
|
||
partner=resolve_stop_dibang_partner("delivery", load, deliveries),
|
||
dibang_date=_resolve_stop_dibang_date(
|
||
plan,
|
||
stop_type="delivery",
|
||
delivery_time=delivery.delivery_time,
|
||
),
|
||
)
|
||
|
||
db.flush()
|
||
return results, warnings
|
||
|
||
|
||
def sync_dibang_for_plan_stops(
|
||
db: Session,
|
||
*,
|
||
tenant_no: str,
|
||
plan: PlPlan,
|
||
transport: PlTransport,
|
||
stop_options: list[StopDibangOption],
|
||
user_id: Optional[str],
|
||
dept_id: str,
|
||
) -> list[DibangInventoryLinkResult]:
|
||
"""按装货/送货段勾选 upsert 地磅计划与出入库单（兼容旧调用方，忽略 warnings）。"""
|
||
results, _warnings = upsert_stop_dibang_links(
|
||
db,
|
||
tenant_no=tenant_no,
|
||
plan=plan,
|
||
transport=transport,
|
||
stop_options=stop_options,
|
||
user_id=user_id,
|
||
dept_id=dept_id,
|
||
)
|
||
return results
|
||
|
||
|
||
def _legacy_monthly_plan(db, tenant_no, dibang_date, business_type, partner, snapshot):
|
||
"""The legacy bridge must not guess between overlapping monthly plans."""
|
||
start, end = _month_range(dibang_date)
|
||
rows = db.query(DbPurchasePlan).filter(
|
||
DbPurchasePlan.tenant_no == tenant_no, DbPurchasePlan.del_flag == 0,
|
||
DbPurchasePlan.business_type == business_type,
|
||
DbPurchasePlan.product_id == snapshot.product_id,
|
||
func.trim(func.coalesce(DbPurchasePlan.customer_name, "")) == partner,
|
||
func.trim(func.coalesce(DbPurchasePlan.specification, "")) == (snapshot.specification or ""),
|
||
DbPurchasePlan.start_date <= end, DbPurchasePlan.end_date >= start,
|
||
).populate_existing().with_for_update().limit(2).all()
|
||
if len(rows) > 1:
|
||
raise ValueError("存在重复地磅月计划，请先核对历史关联")
|
||
return rows[0] if rows else None
|
||
|
||
|
||
def _sync_transport_inventory_links(
|
||
db: Session,
|
||
*,
|
||
tenant_no: str,
|
||
plan: PlPlan,
|
||
products: list[PlPlanProduct],
|
||
transport: PlTransport,
|
||
user_id: Optional[str],
|
||
dept_id: str,
|
||
) -> list[DibangInventoryLinkResult]:
|
||
business_type = _plan_type_to_business_type(plan.plan_type)
|
||
if not business_type:
|
||
return []
|
||
partner = resolve_partner_company(plan, plan.plan_type)
|
||
if not partner:
|
||
raise ValueError("无法解析往来单位，请检查合同供方/需方信息")
|
||
dibang_date = _resolve_dibang_date(plan)
|
||
month_start, month_end = _month_range(dibang_date)
|
||
license_plate = (transport.license_plate or plan.license_plate or "").strip()
|
||
jobs, targets, seen, old_totals = [], {}, set(), {}
|
||
|
||
# Serialize retries for one transport, including the first call with no link yet.
|
||
# No child/quantity mutation occurs until every requested product is validated.
|
||
# Persist this request's pending fields in the same transaction before refreshing
|
||
# locked identities; never discard an unflushed feedback/header edit. No commit.
|
||
db.flush()
|
||
with db.no_autoflush:
|
||
owner = db.query(PlTransport).filter(
|
||
PlTransport.id == transport.id, PlTransport.tenant_no == tenant_no,
|
||
PlTransport.del_flag == 0,
|
||
).populate_existing().with_for_update().first()
|
||
if owner is None or plan.tenant_no != tenant_no or plan.del_flag != 0:
|
||
raise ValueError("运输单或计划无效，无法同步地磅")
|
||
# Different transports may create the same monthly bucket concurrently.
|
||
# Stable sorted product locks also protect the initially absent bucket.
|
||
product_ids = sorted({product.product_id for product in products if product.product_id})
|
||
db.query(CrmProduct).filter(
|
||
CrmProduct.tenant_no == tenant_no, CrmProduct.id.in_(product_ids),
|
||
).order_by(CrmProduct.id).populate_existing().with_for_update().all()
|
||
for product in products:
|
||
if (not product.id or product.id in seen or product.tenant_no != tenant_no
|
||
or product.plan_id != plan.id or product.del_flag != 0):
|
||
raise ValueError("计划产品重复、无效或不属于当前计划")
|
||
seen.add(product.id)
|
||
if not product.product_id:
|
||
raise ValueError(f"产品【{product.product_name}】未关联 CRM 产品，无法生成地磅出入库单")
|
||
snapshot = resolve_crm_product(db, tenant_no, product.product_id, require_on_shelf=False)
|
||
quantity = Decimal(str(_product_quantity(product)))
|
||
if not quantity.is_finite() or quantity < 0:
|
||
raise ValueError("地磅计划数量须为非负有限数")
|
||
links = db.query(PlTransportDbLink).filter(
|
||
PlTransportDbLink.tenant_no == tenant_no,
|
||
PlTransportDbLink.transport_id == transport.id,
|
||
PlTransportDbLink.plan_product_id == product.id,
|
||
).populate_existing().with_for_update().all()
|
||
if len(links) > 1:
|
||
raise ValueError("运输产品存在重复地磅关联，请先核对历史数据")
|
||
link = links[0] if links else None
|
||
inventory, old_plan, protected = None, None, False
|
||
old_quantity = Decimal("0")
|
||
desired = dict(date=dibang_date, partner_company=partner, business_type=business_type,
|
||
vehicle_no=license_plate, product_id=snapshot.product_id,
|
||
product=snapshot.product_name, specification=snapshot.specification)
|
||
if link is not None:
|
||
if link.del_flag != 0 or link.plan_id != plan.id or link.stop_type or link.stop_id:
|
||
raise ValueError("地磅关联已删除或不属于当前旧版计划，请先核对历史数据")
|
||
inventory = db.query(DbInboundOutbound).filter(
|
||
DbInboundOutbound.id == link.db_inventory_id,
|
||
DbInboundOutbound.tenant_no == tenant_no,
|
||
DbInboundOutbound.del_flag == 0,
|
||
).populate_existing().with_for_update().first()
|
||
old_plan = db.query(DbPurchasePlan).filter(
|
||
DbPurchasePlan.id == link.db_purchase_plan_id,
|
||
DbPurchasePlan.tenant_no == tenant_no, DbPurchasePlan.del_flag == 0,
|
||
).populate_existing().with_for_update().first()
|
||
if inventory is None or old_plan is None or inventory.purchase_plan_id != old_plan.id:
|
||
raise ValueError("地磅关联的出入库单或月计划缺失、已删除或不一致")
|
||
users = db.query(PlTransportDbLink.id).filter(
|
||
PlTransportDbLink.tenant_no == tenant_no,
|
||
PlTransportDbLink.db_inventory_id == inventory.id,
|
||
PlTransportDbLink.del_flag == 0,
|
||
).all()
|
||
if len(users) != 1:
|
||
raise ValueError("出入库单存在多个有效运输关联，请先核对历史数据")
|
||
if any((getattr(old_plan, key) or "").strip() != (getattr(inventory, other) or "").strip()
|
||
for key, other in (("business_type", "business_type"), ("product_id", "product_id"),
|
||
("customer_name", "partner_company"), ("specification", "specification"))):
|
||
raise ValueError("地磅月计划与出入库业务信息不一致，请先核对历史数据")
|
||
protected = (_inventory_has_weighing_slip(db, inventory.id)
|
||
or (inventory.status or "").strip() not in _REVOKABLE_INVENTORY_STATUSES)
|
||
if protected and link.contributed_qty is None:
|
||
raise ValueError("已有称重或执行记录但缺少原计划贡献量，不能自动同步")
|
||
old_quantity = Decimal(str(_resolve_link_contributed_qty(link, inventory)))
|
||
if (not old_quantity.is_finite() or old_quantity < 0
|
||
or float(old_plan.planned_quantity or 0) + 1e-9 < float(old_quantity)):
|
||
raise ValueError("地磅月计划贡献量异常，请先核对历史数据")
|
||
old_totals[old_plan.id] = old_totals.get(old_plan.id, Decimal("0")) + old_quantity
|
||
if float(old_totals[old_plan.id]) > float(old_plan.planned_quantity or 0) + 1e-9:
|
||
raise ValueError("地磅月计划关联贡献量合计异常，请先核对历史数据")
|
||
changed = any((getattr(inventory, key) or "") != (value or "")
|
||
for key, value in desired.items()) or quantity != old_quantity
|
||
if protected and changed:
|
||
raise ValueError(f"出入库单 {inventory.batch_no or inventory.id} 已过磅或已执行，不能修改关联业务信息")
|
||
target_key = (dibang_date.year, dibang_date.month, business_type, partner,
|
||
snapshot.product_id, snapshot.specification or "")
|
||
if target_key not in targets:
|
||
targets[target_key] = _legacy_monthly_plan(
|
||
db, tenant_no, dibang_date, business_type, partner, snapshot)
|
||
jobs.append((product, link, inventory, old_plan, quantity, old_quantity,
|
||
desired, protected, target_key))
|
||
|
||
results: list[DibangInventoryLinkResult] = []
|
||
for product, link, inventory, old_plan, quantity, old_quantity, desired, protected, key in jobs:
|
||
if not protected:
|
||
db_plan = targets[key]
|
||
if db_plan is None:
|
||
db_plan = _create_db_plan(db, tenant_no, plan, product, business_type, partner,
|
||
dibang_date, month_start, month_end, user_id, dept_id, 0)
|
||
targets[key] = db_plan
|
||
if old_plan is not None and old_plan.id != db_plan.id:
|
||
_apply_plan_quantity_delta(old_plan, -float(old_quantity), user_id=user_id)
|
||
delta = quantity - old_quantity if old_plan is not None and old_plan.id == db_plan.id else quantity
|
||
if delta:
|
||
_apply_plan_quantity_delta(db_plan, float(delta), user_id=user_id)
|
||
if inventory is None:
|
||
inventory = _create_db_inventory(db, tenant_no, plan, product, db_plan, business_type,
|
||
partner, license_plate, dibang_date, user_id, dept_id)
|
||
link = PlTransportDbLink(id=generate_uuid(), tenant_no=tenant_no,
|
||
transport_id=transport.id, plan_id=plan.id, plan_product_id=product.id,
|
||
db_purchase_plan_id=db_plan.id, db_inventory_id=inventory.id,
|
||
contributed_qty=quantity, remark=f"运输计划 {plan.plan_no}",
|
||
create_by=user_id, create_dept_id=dept_id)
|
||
db.add(link)
|
||
else:
|
||
old_direction = inventory.business_type
|
||
for field, value in desired.items():
|
||
setattr(inventory, field, value)
|
||
if old_direction != business_type:
|
||
inventory.status = "待入库" if business_type == "入库" else "待出库"
|
||
if quantity != old_quantity:
|
||
inventory.quantity = quantity
|
||
inventory.purchase_plan_id = db_plan.id
|
||
inventory.plan_no = db_plan.plan_no
|
||
inventory.update_by = user_id
|
||
link.db_purchase_plan_id = db_plan.id
|
||
link.contributed_qty = quantity
|
||
link.update_by = user_id
|
||
results.append(DibangInventoryLinkResult(
|
||
plan_product_id=product.id, product_name=product.product_name or "",
|
||
db_purchase_plan_id=link.db_purchase_plan_id, db_inventory_id=inventory.id,
|
||
batch_no=inventory.batch_no or "", plan_no=inventory.plan_no or plan.plan_no or ""))
|
||
db.flush()
|
||
return results
|
||
|
||
|
||
def sync_dibang_for_transport(
|
||
db: Session,
|
||
*,
|
||
tenant_no: str,
|
||
plan: PlPlan,
|
||
products: list[PlPlanProduct],
|
||
transport: PlTransport,
|
||
user_id: Optional[str],
|
||
dept_id: str,
|
||
) -> list[DibangInventoryLinkResult]:
|
||
"""勾选「生成地磅单」：按产品生成/复用地磅计划，并创建关联出入库单。"""
|
||
return _sync_transport_inventory_links(
|
||
db,
|
||
tenant_no=tenant_no,
|
||
plan=plan,
|
||
products=products,
|
||
transport=transport,
|
||
user_id=user_id,
|
||
dept_id=dept_id,
|
||
)
|