Files
shanxia2.0/backend/app/services/pl_plan_contract_gap.py
T

196 lines
6.2 KiB
Python

from __future__ import annotations
from datetime import date
from typing import List, Optional, TYPE_CHECKING
from sqlalchemy import and_, exists, func, or_, select
from sqlalchemy.orm import Session
from app.models.pl_models import PlPlan, PlPlanContract
from app.schemas.pl.plan import PlanContractGapRead, PlanContractLink
from app.services.pl_data_scope import apply_pl_scope
from app.services.pl_internal_customer import INTERNAL_CUSTOMER_NAMES, is_internal_customer_name
from app.services.pl_plan_service import (
PLAN_CONTRACT_SIDE_DEMANDER,
PLAN_CONTRACT_SIDE_SUPPLIER,
load_plan_contracts_grouped,
)
if TYPE_CHECKING:
from app.core.db_auth import DbUserContext
def compute_contract_gap_sides(
*,
supplier_name: Optional[str],
customer_name: Optional[str],
supplier_contract_count: int,
demander_contract_count: int,
) -> List[str]:
gaps: List[str] = []
if not is_internal_customer_name(supplier_name) and supplier_contract_count <= 0:
gaps.append("supplier")
if not is_internal_customer_name(customer_name) and demander_contract_count <= 0:
gaps.append("demander")
return gaps
def side_is_exempt(name: Optional[str]) -> bool:
return is_internal_customer_name(name)
def _side_contract_exists(tenant_no: str, side: str):
return exists(
select(PlPlanContract.id).where(
PlPlanContract.plan_id == PlPlan.id,
PlPlanContract.tenant_no == tenant_no,
PlPlanContract.del_flag == 0,
PlPlanContract.side == side,
)
)
def _supplier_gap_expr(tenant_no: str):
internal_names = tuple(INTERNAL_CUSTOMER_NAMES)
supplier_not_internal = or_(
PlPlan.supplier_name.is_(None),
PlPlan.supplier_name == "",
~PlPlan.supplier_name.in_(internal_names),
)
return and_(
supplier_not_internal,
~_side_contract_exists(tenant_no, PLAN_CONTRACT_SIDE_SUPPLIER),
)
def _demander_gap_expr(tenant_no: str):
internal_names = tuple(INTERNAL_CUSTOMER_NAMES)
customer_not_internal = or_(
PlPlan.customer_name.is_(None),
PlPlan.customer_name == "",
~PlPlan.customer_name.in_(internal_names),
)
return and_(
customer_not_internal,
~_side_contract_exists(tenant_no, PLAN_CONTRACT_SIDE_DEMANDER),
)
def plan_has_contract_gap_exists(tenant_no: str):
"""列表筛选:计划存在合同缺口(非内置侧缺少有效 pl_plan_contract 关联)。"""
return or_(_supplier_gap_expr(tenant_no), _demander_gap_expr(tenant_no))
def build_plan_contract_gap_read(
plan: PlPlan,
*,
supplier_contracts: list[PlanContractLink],
demander_contracts: list[PlanContractLink],
) -> PlanContractGapRead:
gap_sides = compute_contract_gap_sides(
supplier_name=plan.supplier_name,
customer_name=plan.customer_name,
supplier_contract_count=len(supplier_contracts),
demander_contract_count=len(demander_contracts),
)
return PlanContractGapRead(
id=plan.id,
planNo=plan.plan_no,
planDate=plan.plan_date,
followStatus=plan.follow_status,
supplierId=plan.supplier_id,
supplierName=plan.supplier_name,
customerId=plan.customer_id,
customerName=plan.customer_name,
gapSides=gap_sides,
supplierContractExempt=side_is_exempt(plan.supplier_name),
demanderContractExempt=side_is_exempt(plan.customer_name),
supplierContracts=supplier_contracts,
demanderContracts=demander_contracts,
)
def list_plan_contract_gaps(
db: Session,
*,
tenant_no: str,
user: "DbUserContext",
page: int = 1,
page_size: int = 20,
plan_no: Optional[str] = None,
gap_type: Optional[str] = None,
customer_keyword: Optional[str] = None,
plan_date_from: Optional[date] = None,
plan_date_to: Optional[date] = None,
q: Optional[str] = None,
) -> tuple[int, list[PlanContractGapRead]]:
query = db.query(PlPlan).filter(
PlPlan.tenant_no == tenant_no,
PlPlan.del_flag == 0,
PlPlan.follow_status != "cancelled",
plan_has_contract_gap_exists(tenant_no),
)
query = apply_pl_scope(query, PlPlan, user, db, tenant_no)
if plan_no:
query = query.filter(PlPlan.plan_no.contains(plan_no))
gap_type_norm = (gap_type or "").strip().lower()
if gap_type_norm == "supplier":
query = query.filter(_supplier_gap_expr(tenant_no))
elif gap_type_norm == "demander":
query = query.filter(_demander_gap_expr(tenant_no))
elif gap_type_norm == "both":
query = query.filter(
and_(_supplier_gap_expr(tenant_no), _demander_gap_expr(tenant_no))
)
if customer_keyword:
kw = customer_keyword.strip()
if kw:
kw_lower = kw.lower()
query = query.filter(
or_(
func.lower(PlPlan.supplier_name).contains(kw_lower),
func.lower(PlPlan.customer_name).contains(kw_lower),
)
)
if plan_date_from:
query = query.filter(PlPlan.plan_date >= plan_date_from)
if plan_date_to:
query = query.filter(PlPlan.plan_date <= plan_date_to)
if q:
q_kw = q.strip()
if q_kw:
q_lower = q_kw.lower()
query = query.filter(
or_(
PlPlan.plan_no.contains(q_kw),
func.lower(PlPlan.supplier_name).contains(q_lower),
func.lower(PlPlan.customer_name).contains(q_lower),
)
)
query = query.order_by(PlPlan.plan_date.desc(), PlPlan.create_time.desc())
total = query.count()
offset = (page - 1) * page_size
plans = query.offset(offset).limit(page_size).all()
plan_ids = [plan.id for plan in plans]
contracts_by_plan = load_plan_contracts_grouped(db, tenant_no, plan_ids)
items: list[PlanContractGapRead] = []
for plan in plans:
supplier_contracts, demander_contracts = contracts_by_plan.get(plan.id, ([], []))
items.append(
build_plan_contract_gap_read(
plan,
supplier_contracts=supplier_contracts,
demander_contracts=demander_contracts,
)
)
return total, items