516 lines
19 KiB
Python
516 lines
19 KiB
Python
"""运输计划 · 入库/出库单现场免登录公共 API"""
|
|
from __future__ import annotations
|
|
|
|
import os
|
|
from datetime import date, datetime
|
|
from decimal import Decimal
|
|
from typing import Optional
|
|
|
|
from fastapi import APIRouter, Depends, File, Form, HTTPException, Query, UploadFile
|
|
from sqlalchemy import and_, or_
|
|
from sqlalchemy.orm import Session
|
|
|
|
from app.core.attachment_biz import resolve_upload_folder
|
|
from app.core.config import settings
|
|
from app.core.database import get_db
|
|
from app.core.response import error_response, success_response
|
|
from app.core.storage import storage
|
|
from app.crud import oss as oss_svc
|
|
from app.models.pl_models import (
|
|
PlInboundOrder,
|
|
PlInboundOrderItem,
|
|
PlOutboundOrder,
|
|
PlOutboundOrderItem,
|
|
PlPlan,
|
|
PlPlanProduct,
|
|
)
|
|
from app.schemas.pl.io_order import (
|
|
PublicIoOrderFeedback,
|
|
PublicIoOrderHistoryPageRead,
|
|
PublicIoOrderHistoryProductRead,
|
|
PublicIoOrderHistoryRecordRead,
|
|
)
|
|
from app.services.pl_dibang_bridge_service import plan_has_load_stop
|
|
from app.services.pl_io_order_service import (
|
|
apply_io_order_stop_site_feedbacks,
|
|
apply_site_feedback,
|
|
build_io_order_site_url,
|
|
order_header_to_dict,
|
|
parse_feedback_images,
|
|
)
|
|
from app.services.pl_transport_stop_feedback_service import (
|
|
build_public_stop_reads_for_segments,
|
|
load_io_order_site_stop_segments,
|
|
)
|
|
from app.services.pl_product_display import (
|
|
load_crm_product_alias_maps,
|
|
resolve_product_display_names,
|
|
)
|
|
from app.utils.excel_export import load_dict_label_maps
|
|
|
|
inbound_public_router = APIRouter(prefix="/public/pl/inbound", tags=["运输计划-入库单公共"])
|
|
outbound_public_router = APIRouter(prefix="/public/pl/outbound", tags=["运输计划-出库单公共"])
|
|
|
|
CRM_PRODUCT_UNIT = "crm_product_unit"
|
|
|
|
|
|
def _resolve_unit_label(unit_map: dict[str, str], unit_code: Optional[str]) -> str:
|
|
code = (unit_code or "").strip()
|
|
if not code:
|
|
return "吨"
|
|
return unit_map.get(code, code)
|
|
|
|
|
|
def _models(kind: str):
|
|
if kind == "inbound":
|
|
return PlInboundOrder, PlInboundOrderItem
|
|
return PlOutboundOrder, PlOutboundOrderItem
|
|
|
|
|
|
def _get_by_token(db: Session, kind: str, token: str):
|
|
header_m, item_m = _models(kind)
|
|
header = (
|
|
db.query(header_m)
|
|
.filter(header_m.site_access_token == token, header_m.del_flag == 0)
|
|
.first()
|
|
)
|
|
if not header:
|
|
raise HTTPException(status_code=404, detail="链接无效或已失效")
|
|
items = (
|
|
db.query(item_m)
|
|
.filter(item_m.order_id == header.id, item_m.del_flag == 0)
|
|
.order_by(item_m.order_num.asc())
|
|
.all()
|
|
)
|
|
return header, items
|
|
|
|
|
|
def _resolve_io_order_link_flags(plan: Optional[PlPlan], header) -> tuple[bool, bool]:
|
|
"""返回 (作废, 归档)。现场链接实际走入库/出库单公共页。"""
|
|
voided = header.status == "voided" or bool(plan and plan.follow_status == "cancelled")
|
|
archived = bool(plan and plan.archive_status == "archived")
|
|
return voided, archived
|
|
|
|
|
|
def _parse_history_date(raw: Optional[str]) -> Optional[date]:
|
|
text = (raw or "").strip()
|
|
if not text:
|
|
return None
|
|
try:
|
|
return date.fromisoformat(text)
|
|
except ValueError:
|
|
return None
|
|
|
|
|
|
def _history_status_label(voided: bool, archived: bool, status: Optional[str]) -> str:
|
|
if voided or status == "voided":
|
|
return "已作废"
|
|
if archived:
|
|
return "已归档"
|
|
if status == "completed":
|
|
return "已完成"
|
|
return "进行中"
|
|
|
|
|
|
def _query_kind_history(
|
|
db: Session,
|
|
*,
|
|
kind: str,
|
|
tenant_no: str,
|
|
day: date,
|
|
keyword: str,
|
|
) -> list[tuple]:
|
|
"""返回 [(create_time, PublicIoOrderHistoryRecordRead), ...]。"""
|
|
header_m, item_m = _models(kind)
|
|
query = (
|
|
db.query(header_m, PlPlan)
|
|
.outerjoin(
|
|
PlPlan,
|
|
and_(PlPlan.id == header_m.plan_id, PlPlan.del_flag == 0),
|
|
)
|
|
.filter(
|
|
header_m.tenant_no == tenant_no,
|
|
header_m.del_flag == 0,
|
|
header_m.plan_date == day,
|
|
)
|
|
)
|
|
kw = (keyword or "").strip()
|
|
if kw:
|
|
like = f"%{kw}%"
|
|
product_match = (
|
|
db.query(item_m.id)
|
|
.filter(
|
|
item_m.order_id == header_m.id,
|
|
item_m.del_flag == 0,
|
|
item_m.product_name.like(like),
|
|
)
|
|
.exists()
|
|
)
|
|
query = query.filter(
|
|
or_(
|
|
header_m.vehicle_no.like(like),
|
|
product_match,
|
|
)
|
|
)
|
|
rows = query.order_by(header_m.create_time.desc()).all()
|
|
out: list[tuple] = []
|
|
for header, plan in rows:
|
|
voided, archived = _resolve_io_order_link_flags(plan, header)
|
|
tok = (header.site_access_token or "").strip()
|
|
out.append(
|
|
(
|
|
header.create_time,
|
|
PublicIoOrderHistoryRecordRead(
|
|
kind=kind,
|
|
order_id=header.id,
|
|
order_no=header.order_no or "",
|
|
plan_id=header.plan_id,
|
|
plan_no=header.plan_no or (plan.plan_no if plan else None),
|
|
plan_date=header.plan_date,
|
|
partner_company=header.partner_company,
|
|
supplier_name=plan.supplier_name if plan else None,
|
|
customer_name=plan.customer_name if plan else None,
|
|
vehicle_no=header.vehicle_no,
|
|
pickup_time=plan.pickup_time if plan else None,
|
|
delivery_time=plan.delivery_time if plan else None,
|
|
pickup_address=plan.pickup_address if plan else None,
|
|
destination_address=(
|
|
(plan.destination_address or plan.destination_name) if plan else None
|
|
),
|
|
site_access_token=tok or None,
|
|
site_url=build_io_order_site_url(kind, tok) if tok else None,
|
|
status=header.status,
|
|
order_voided=voided,
|
|
plan_archived=archived,
|
|
status_label=_history_status_label(voided, archived, header.status),
|
|
),
|
|
)
|
|
)
|
|
return out
|
|
|
|
|
|
def _build_history_page(
|
|
db: Session,
|
|
*,
|
|
entry_kind: str,
|
|
token: str,
|
|
date_raw: str,
|
|
keyword: Optional[str],
|
|
page: int = 1,
|
|
page_size: int = 20,
|
|
) -> PublicIoOrderHistoryPageRead:
|
|
header, _items = _get_by_token(db, entry_kind, token)
|
|
day = _parse_history_date(date_raw)
|
|
if day is None:
|
|
raise HTTPException(status_code=400, detail="日期格式无效，请使用 YYYY-MM-DD")
|
|
kw = (keyword or "").strip()
|
|
merged = _query_kind_history(
|
|
db, kind="inbound", tenant_no=header.tenant_no, day=day, keyword=kw
|
|
) + _query_kind_history(
|
|
db, kind="outbound", tenant_no=header.tenant_no, day=day, keyword=kw
|
|
)
|
|
merged.sort(key=lambda x: x[0] or datetime.min, reverse=True)
|
|
total = len(merged)
|
|
page = max(1, int(page or 1))
|
|
page_size = min(max(1, int(page_size or 20)), 500)
|
|
start = (page - 1) * page_size
|
|
page_rows = merged[start : start + page_size]
|
|
records = [r for _, r in page_rows]
|
|
_attach_history_products(db, tenant_no=header.tenant_no, records=records)
|
|
return PublicIoOrderHistoryPageRead(
|
|
date=day.isoformat(),
|
|
keyword=kw or None,
|
|
page=page,
|
|
page_size=page_size,
|
|
total=total,
|
|
records=records,
|
|
)
|
|
|
|
|
|
def _attach_history_products(
|
|
db: Session,
|
|
*,
|
|
tenant_no: str,
|
|
records: list[PublicIoOrderHistoryRecordRead],
|
|
) -> None:
|
|
if not records:
|
|
return
|
|
|
|
inbound_ids = [r.order_id for r in records if r.kind == "inbound"]
|
|
outbound_ids = [r.order_id for r in records if r.kind == "outbound"]
|
|
items_by_order: dict[str, list] = {}
|
|
|
|
if inbound_ids:
|
|
for item in (
|
|
db.query(PlInboundOrderItem)
|
|
.filter(
|
|
PlInboundOrderItem.order_id.in_(inbound_ids),
|
|
PlInboundOrderItem.del_flag == 0,
|
|
)
|
|
.order_by(PlInboundOrderItem.order_num.asc(), PlInboundOrderItem.create_time.asc())
|
|
.all()
|
|
):
|
|
items_by_order.setdefault(item.order_id, []).append(item)
|
|
|
|
if outbound_ids:
|
|
for item in (
|
|
db.query(PlOutboundOrderItem)
|
|
.filter(
|
|
PlOutboundOrderItem.order_id.in_(outbound_ids),
|
|
PlOutboundOrderItem.del_flag == 0,
|
|
)
|
|
.order_by(PlOutboundOrderItem.order_num.asc(), PlOutboundOrderItem.create_time.asc())
|
|
.all()
|
|
):
|
|
items_by_order.setdefault(item.order_id, []).append(item)
|
|
|
|
all_items = [it for items in items_by_order.values() for it in items]
|
|
plan_product_ids = {
|
|
(it.plan_product_id or "").strip() for it in all_items if (it.plan_product_id or "").strip()
|
|
}
|
|
plan_product_by_id: dict[str, PlPlanProduct] = {}
|
|
if plan_product_ids:
|
|
for prod in (
|
|
db.query(PlPlanProduct)
|
|
.filter(PlPlanProduct.id.in_(list(plan_product_ids)), PlPlanProduct.del_flag == 0)
|
|
.all()
|
|
):
|
|
plan_product_by_id[prod.id] = prod
|
|
|
|
crm_product_ids = {
|
|
(it.product_id or "").strip() for it in all_items if (it.product_id or "").strip()
|
|
}
|
|
standard_by_id, alias_options_by_id = load_crm_product_alias_maps(
|
|
db, tenant_no=tenant_no, product_ids=crm_product_ids
|
|
)
|
|
unit_map = load_dict_label_maps(db, [CRM_PRODUCT_UNIT], tenant_no=tenant_no).get(
|
|
CRM_PRODUCT_UNIT, {}
|
|
)
|
|
|
|
for record in records:
|
|
products: list[PublicIoOrderHistoryProductRead] = []
|
|
for item in items_by_order.get(record.order_id) or []:
|
|
product_id = (item.product_id or "").strip()
|
|
plan_product = plan_product_by_id.get((item.plan_product_id or "").strip())
|
|
display_name, _alias = resolve_product_display_names(
|
|
saved_product_name=item.product_name,
|
|
product_id=product_id,
|
|
standard_by_id=standard_by_id,
|
|
alias_options_by_id=alias_options_by_id,
|
|
)
|
|
model = (item.specification or "").strip() or (
|
|
(plan_product.model or "").strip() if plan_product else ""
|
|
) or None
|
|
package_spec = (
|
|
(plan_product.package_spec or "").strip() if plan_product else ""
|
|
) or None
|
|
qty = item.actual_qty if item.actual_qty is not None else item.plan_qty
|
|
products.append(
|
|
PublicIoOrderHistoryProductRead(
|
|
product_name=display_name or item.product_name or "—",
|
|
model=model,
|
|
package_spec=package_spec,
|
|
quantity=qty,
|
|
unit=_resolve_unit_label(unit_map, item.unit),
|
|
)
|
|
)
|
|
record.products = products
|
|
|
|
|
|
def _build_page(db: Session, kind: str, header, items) -> dict:
|
|
plan = db.query(PlPlan).filter(PlPlan.id == header.plan_id, PlPlan.del_flag == 0).first()
|
|
voided, archived = _resolve_io_order_link_flags(plan, header)
|
|
data = order_header_to_dict(
|
|
kind, header, items, db=db, public_unit_as_label=True
|
|
)
|
|
data["voided"] = voided
|
|
data["archived"] = archived
|
|
data["title"] = "入库单" if kind == "inbound" else "出库单"
|
|
data["stops"] = []
|
|
if plan and plan_has_load_stop(db, header.tenant_no, plan.id):
|
|
segments = load_io_order_site_stop_segments(
|
|
db,
|
|
tenant_no=header.tenant_no,
|
|
plan_id=plan.id,
|
|
transport_id=header.transport_id,
|
|
)
|
|
data["stops"] = build_public_stop_reads_for_segments(
|
|
db,
|
|
tenant_no=header.tenant_no,
|
|
plan_id=plan.id,
|
|
segments=segments,
|
|
)
|
|
return data
|
|
|
|
|
|
def _format_file_size(size_bytes: int) -> str:
|
|
if size_bytes < 1024:
|
|
return f"{size_bytes} B"
|
|
if size_bytes < 1024 * 1024:
|
|
return f"{size_bytes / 1024:.1f} KB"
|
|
return f"{size_bytes / (1024 * 1024):.1f} MB"
|
|
|
|
|
|
def _make_handlers(kind: str):
|
|
def get_page(token: str, db: Session = Depends(get_db)):
|
|
header, items = _get_by_token(db, kind, token)
|
|
return success_response(_build_page(db, kind, header, items))
|
|
|
|
def get_history(
|
|
token: str,
|
|
date: str = Query(..., description="筛选日 YYYY-MM-DD"),
|
|
q: Optional[str] = Query(None, description="车牌号/产品名称模糊"),
|
|
page: int = Query(1, ge=1, description="页码，从 1 开始"),
|
|
page_size: int = Query(20, ge=1, le=500, alias="pageSize", description="每页条数"),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
try:
|
|
history_page = _build_history_page(
|
|
db,
|
|
entry_kind=kind,
|
|
token=token,
|
|
date_raw=date,
|
|
keyword=q,
|
|
page=page,
|
|
page_size=page_size,
|
|
)
|
|
except HTTPException as exc:
|
|
if exc.status_code == 400:
|
|
return error_response(400, str(exc.detail))
|
|
raise
|
|
return success_response(history_page.model_dump(by_alias=True))
|
|
|
|
def save_feedback(token: str, payload: PublicIoOrderFeedback, db: Session = Depends(get_db)):
|
|
header, items = _get_by_token(db, kind, token)
|
|
page = _build_page(db, kind, header, items)
|
|
if page["voided"]:
|
|
return error_response(400, "单据已作废，无法提交")
|
|
if page["archived"]:
|
|
return error_response(400, "运输计划已归档，无法提交")
|
|
|
|
use_multi_stop = bool(payload.stops)
|
|
qty_map: dict[str, Decimal] = {}
|
|
brand_qty_map: dict[str, list[dict]] | None = None
|
|
images = payload.images
|
|
|
|
try:
|
|
if use_multi_stop:
|
|
qty_map, brand_qty_map, merged_images = apply_io_order_stop_site_feedbacks(
|
|
db,
|
|
kind=kind,
|
|
header=header,
|
|
items=items,
|
|
stops=[stop.model_dump(by_alias=True) for stop in payload.stops],
|
|
enforce_brand=(payload.status == "completed"),
|
|
)
|
|
images = merged_images
|
|
if payload.items:
|
|
for x in payload.items:
|
|
qty_map[x.id] = Decimal(str(x.actual_qty))
|
|
if any(x.brand_qtys is not None for x in payload.items):
|
|
brand_qty_map = brand_qty_map or {}
|
|
for x in payload.items:
|
|
if x.brand_qtys is not None:
|
|
brand_qty_map[x.id] = [
|
|
b.model_dump(by_alias=True) for b in x.brand_qtys
|
|
]
|
|
else:
|
|
qty_map = {x.id: Decimal(str(x.actual_qty)) for x in payload.items}
|
|
if any(x.brand_qtys is not None for x in payload.items):
|
|
brand_qty_map = {}
|
|
for x in payload.items:
|
|
if x.brand_qtys is not None:
|
|
brand_qty_map[x.id] = [
|
|
b.model_dump(by_alias=True) for b in x.brand_qtys
|
|
]
|
|
if not images:
|
|
images = parse_feedback_images(header.site_feedback_images)
|
|
|
|
apply_site_feedback(
|
|
db,
|
|
kind=kind,
|
|
header=header,
|
|
items=items,
|
|
item_qty=qty_map,
|
|
remark=payload.remark,
|
|
images=images,
|
|
status=payload.status,
|
|
item_brand_qtys=brand_qty_map,
|
|
enforce_brand=(payload.status == "completed")
|
|
and (not use_multi_stop or bool(payload.items)),
|
|
)
|
|
except ValueError as exc:
|
|
return error_response(400, str(exc))
|
|
db.commit()
|
|
return success_response({"success": True, "message": "保存成功"})
|
|
|
|
def upload_attachment(
|
|
token: str,
|
|
file: UploadFile = File(...),
|
|
folder: Optional[str] = Form(""),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
header, _items = _get_by_token(db, kind, token)
|
|
page = _build_page(db, kind, header, _items)
|
|
if page["voided"]:
|
|
return error_response(400, "单据已作废，无法上传附件")
|
|
if page["archived"]:
|
|
return error_response(400, "运输计划已归档，无法上传附件")
|
|
if not file or not file.filename:
|
|
return error_response(400, "请选择文件")
|
|
try:
|
|
effective_folder = resolve_upload_folder(
|
|
folder=folder or "", biz_type="pl_io_order_site_feedback"
|
|
)
|
|
file_content = file.file.read()
|
|
full_url = storage.upload_file(file_content, file.filename, effective_folder)
|
|
base_url = settings.MINIO_BASE_URL.rstrip("/") if settings.MINIO_BASE_URL else ""
|
|
if base_url and full_url.startswith(base_url + "/"):
|
|
file_url = full_url[len(base_url) + 1 :]
|
|
else:
|
|
file_url = full_url
|
|
record = oss_svc.create_oss(
|
|
db,
|
|
tenant_no=header.tenant_no,
|
|
url=file_url,
|
|
original_name=file.filename,
|
|
file_suffix=os.path.splitext(file.filename)[1].lstrip(".") if file.filename else "",
|
|
file_size=len(file_content),
|
|
file_type=file.content_type or "",
|
|
biz_type="pl_io_order_site_feedback",
|
|
user_id=None,
|
|
ext1=effective_folder or None,
|
|
)
|
|
db.commit()
|
|
return success_response(
|
|
{
|
|
"id": record.id,
|
|
"fileName": record.original_name,
|
|
"fileUrl": record.url,
|
|
"fileSize": record.file_size,
|
|
"fileSizeDisplay": _format_file_size(record.file_size or 0),
|
|
"fileType": record.file_type,
|
|
}
|
|
)
|
|
except Exception as exc:
|
|
db.rollback()
|
|
return error_response(500, f"上传失败: {str(exc)}")
|
|
|
|
get_page.__name__ = f"get_public_{kind}_order"
|
|
get_history.__name__ = f"get_public_{kind}_history"
|
|
save_feedback.__name__ = f"save_public_{kind}_feedback"
|
|
upload_attachment.__name__ = f"upload_public_{kind}_attachment"
|
|
return get_page, get_history, save_feedback, upload_attachment
|
|
|
|
|
|
_in_get, _in_hist, _in_fb, _in_up = _make_handlers("inbound")
|
|
_out_get, _out_hist, _out_fb, _out_up = _make_handlers("outbound")
|
|
inbound_public_router.get("/{token}/history")(_in_hist)
|
|
inbound_public_router.get("/{token}")(_in_get)
|
|
inbound_public_router.post("/{token}/feedback")(_in_fb)
|
|
inbound_public_router.post("/{token}/attachments")(_in_up)
|
|
outbound_public_router.get("/{token}/history")(_out_hist)
|
|
outbound_public_router.get("/{token}")(_out_get)
|
|
outbound_public_router.post("/{token}/feedback")(_out_fb)
|
|
outbound_public_router.post("/{token}/attachments")(_out_up)
|