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

590 lines
20 KiB
Python

"""车辆加油登记业务逻辑"""
from __future__ import annotations
from datetime import date, datetime
from decimal import Decimal, ROUND_HALF_UP
from typing import Optional, Sequence, Tuple
from fastapi import HTTPException
from sqlalchemy import and_, func, or_
from sqlalchemy.orm import Session
from app.core.db_auth import DbUserContext
from app.core.utils import generate_uuid
from app.models.models import SysUser
from app.models.pl_models import PlVehicle, PlVehicleFuelRegister
from app.schemas.pl.vehicle_fuel import (
VehicleFuelPlateMonthItem,
VehicleFuelPlateMonthSummaryResponse,
VehicleFuelRegisterCreate,
VehicleFuelRegisterRead,
VehicleFuelRegisterUpdate,
calc_fuel_tons,
)
from app.services.pl_data_scope import apply_pl_scope, assert_pl_row_in_scope
from app.services.pl_personnel_service import load_vehicle_personnel_summaries
def _generate_register_no(db: Session) -> str:
prefix = f"SXJY{date.today():%Y%m%d}"
last = (
db.query(PlVehicleFuelRegister)
.filter(PlVehicleFuelRegister.register_no.like(f"{prefix}%"))
.order_by(PlVehicleFuelRegister.register_no.desc())
.first()
)
seq = int(last.register_no[-6:]) + 1 if last else 1
return f"{prefix}{seq:06d}"
def _resolve_user_name(db: Session, user_id: Optional[str]) -> Optional[str]:
if not user_id:
return None
row = (
db.query(SysUser)
.filter(SysUser.id == user_id, SysUser.del_flag == 0)
.first()
)
return row.nick_name or row.user_no if row else None
def _assert_vehicle_exists(db: Session, tenant_no: str, license_plate: str) -> None:
exists = (
db.query(PlVehicle.id)
.filter(
PlVehicle.tenant_no == tenant_no,
PlVehicle.license_plate == license_plate,
PlVehicle.del_flag == 0,
)
.first()
)
if not exists:
raise HTTPException(status_code=400, detail="车牌号不存在")
def _resolve_registrant_id(
db: Session,
tenant_no: str,
registrant_id: Optional[str],
user: DbUserContext,
*,
force_self: bool = False,
) -> str:
target = user.id if force_self else ((registrant_id or "").strip() or user.id)
row = (
db.query(SysUser.id)
.filter(
SysUser.id == target,
SysUser.tenant_no == tenant_no,
SysUser.del_flag == 0,
SysUser.status == "1",
)
.first()
)
if not row:
raise HTTPException(status_code=400, detail="登记人不存在或已停用")
return target
def _get_row(
db: Session, tenant_no: str, register_id: str, user: DbUserContext
) -> PlVehicleFuelRegister:
row = (
db.query(PlVehicleFuelRegister)
.filter(
PlVehicleFuelRegister.id == register_id,
PlVehicleFuelRegister.tenant_no == tenant_no,
PlVehicleFuelRegister.del_flag == 0,
)
.first()
)
if not row:
raise HTTPException(status_code=404, detail="加油登记不存在")
assert_pl_row_in_scope(db, row, PlVehicleFuelRegister, user, tenant_no)
return row
def _compute_seq_no(db: Session, tenant_no: str, row: PlVehicleFuelRegister) -> int:
"""租户内含软删:按 create_time ASC, id ASC 的 1-based 序号。"""
count = (
db.query(func.count(PlVehicleFuelRegister.id))
.filter(
PlVehicleFuelRegister.tenant_no == tenant_no,
or_(
PlVehicleFuelRegister.create_time < row.create_time,
and_(
PlVehicleFuelRegister.create_time == row.create_time,
PlVehicleFuelRegister.id <= row.id,
),
),
)
.scalar()
)
return int(count or 0)
def _build_seq_no_map(db: Session, tenant_no: str) -> dict[str, int]:
"""一次拉取租户内全部 id(含软删)映射序号,供列表避免 N+1。"""
rows = (
db.query(PlVehicleFuelRegister.id)
.filter(PlVehicleFuelRegister.tenant_no == tenant_no)
.order_by(
PlVehicleFuelRegister.create_time.asc(),
PlVehicleFuelRegister.id.asc(),
)
.all()
)
return {row_id: idx + 1 for idx, (row_id,) in enumerate(rows)}
def to_read(
row: PlVehicleFuelRegister,
db: Session,
*,
seq_no: Optional[int] = None,
) -> VehicleFuelRegisterRead:
resolved = seq_no if seq_no is not None else _compute_seq_no(db, row.tenant_no, row)
return VehicleFuelRegisterRead(
id=row.id,
seqNo=resolved,
registerNo=row.register_no,
fuelCategory=row.fuel_category,
registerDate=row.register_date,
registrantId=row.registrant_id,
registrantName=_resolve_user_name(db, row.registrant_id),
licensePlate=row.license_plate,
odometerKm=row.odometer_km,
fuelLiters=row.fuel_liters,
fuelTons=row.fuel_tons if row.fuel_tons is not None else calc_fuel_tons(row.fuel_liters),
attachmentUrls=row.attachment_urls,
status=row.status,
cancelReason=row.cancel_reason,
cancelTime=row.cancel_time,
cancelBy=row.cancel_by,
remark=row.remark,
createTime=row.create_time,
updateTime=row.update_time,
)
def list_registers(
db: Session,
tenant_no: str,
user: DbUserContext,
*,
q: Optional[str] = None,
register_no: Optional[str] = None,
license_plate: Optional[str] = None,
fuel_category: Optional[str] = None,
fuel_category_in: Optional[str] = None,
status: Optional[str] = None,
status_in: Optional[str] = None,
register_date_from: Optional[date] = None,
register_date_to: Optional[date] = None,
registrant_id: Optional[str] = None,
registrant_name: Optional[str] = None,
odometer_km_op: Optional[str] = None,
odometer_km: Optional[str] = None,
odometer_km_min: Optional[str] = None,
odometer_km_max: Optional[str] = None,
fuel_liters_op: Optional[str] = None,
fuel_liters: Optional[str] = None,
fuel_liters_min: Optional[str] = None,
fuel_liters_max: Optional[str] = None,
fuel_tons_op: Optional[str] = None,
fuel_tons: Optional[str] = None,
fuel_tons_min: Optional[str] = None,
fuel_tons_max: Optional[str] = None,
create_time_from: Optional[date] = None,
create_time_to: Optional[date] = None,
mine_only: bool = False,
ids: Optional[list[str]] = None,
page: int = 1,
page_size: int = 20,
max_page_size: Optional[int] = None,
) -> tuple[list[VehicleFuelRegisterRead], int]:
query = db.query(PlVehicleFuelRegister).filter(
PlVehicleFuelRegister.tenant_no == tenant_no,
PlVehicleFuelRegister.del_flag == 0,
)
if mine_only:
query = query.filter(PlVehicleFuelRegister.registrant_id == user.id)
elif registrant_id:
query = query.filter(PlVehicleFuelRegister.registrant_id == registrant_id)
if q:
query = query.filter(
or_(
PlVehicleFuelRegister.register_no.contains(q),
PlVehicleFuelRegister.license_plate.contains(q),
)
)
from app.services.pl.vehicle_fuel_list_filters import (
build_fuel_register_column_filters,
)
column_filters = build_fuel_register_column_filters(
register_no=register_no,
license_plate=license_plate,
fuel_category=fuel_category,
fuel_category_in=fuel_category_in,
status=status,
status_in=status_in,
register_date_from=register_date_from,
register_date_to=register_date_to,
registrant_name=registrant_name,
odometer_km_op=odometer_km_op,
odometer_km=odometer_km,
odometer_km_min=odometer_km_min,
odometer_km_max=odometer_km_max,
fuel_liters_op=fuel_liters_op,
fuel_liters=fuel_liters,
fuel_liters_min=fuel_liters_min,
fuel_liters_max=fuel_liters_max,
fuel_tons_op=fuel_tons_op,
fuel_tons=fuel_tons,
fuel_tons_min=fuel_tons_min,
fuel_tons_max=fuel_tons_max,
create_time_from=create_time_from,
create_time_to=create_time_to,
)
if column_filters:
query = query.filter(*column_filters)
if ids:
query = query.filter(PlVehicleFuelRegister.id.in_(ids))
query = apply_pl_scope(query, PlVehicleFuelRegister, user, db, tenant_no)
total = query.count()
page = max(1, page)
cap = int(max_page_size) if max_page_size else 500
page_size = min(max(1, page_size), cap)
rows = (
# 与 seqNo 倒序一致:序号大的在前(create_time ASC,id ASC → seqNo;列表取反)
query.order_by(
PlVehicleFuelRegister.create_time.desc(),
PlVehicleFuelRegister.id.desc(),
)
.offset((page - 1) * page_size)
.limit(page_size)
.all()
)
seq_map = _build_seq_no_map(db, tenant_no)
return [to_read(row, db, seq_no=seq_map.get(row.id)) for row in rows], total
def get_register(
db: Session, tenant_no: str, user: DbUserContext, register_id: str
) -> VehicleFuelRegisterRead:
return to_read(_get_row(db, tenant_no, register_id, user), db)
def create_register(
db: Session,
tenant_no: str,
user: DbUserContext,
payload: VehicleFuelRegisterCreate,
*,
force_self: bool = False,
) -> VehicleFuelRegisterRead:
license_plate = payload.license_plate.strip()
_assert_vehicle_exists(db, tenant_no, license_plate)
registrant_id = _resolve_registrant_id(
db, tenant_no, payload.registrant_id, user, force_self=force_self
)
now = datetime.now()
row = PlVehicleFuelRegister(
id=generate_uuid(),
register_no=_generate_register_no(db),
fuel_category=payload.fuel_category,
register_date=payload.register_date,
registrant_id=registrant_id,
license_plate=license_plate,
odometer_km=payload.odometer_km,
fuel_liters=payload.fuel_liters,
fuel_tons=calc_fuel_tons(payload.fuel_liters),
attachment_urls=payload.attachment_urls,
status="normal",
tenant_no=tenant_no,
remark=payload.remark,
create_by=user.id,
create_dept_id=user.dept_id or "",
create_time=now,
update_by=user.id,
update_time=now,
del_flag=0,
)
db.add(row)
db.commit()
db.refresh(row)
return to_read(row, db)
def update_register(
db: Session,
tenant_no: str,
user: DbUserContext,
register_id: str,
payload: VehicleFuelRegisterUpdate,
*,
force_self: bool = False,
) -> VehicleFuelRegisterRead:
row = _get_row(db, tenant_no, register_id, user)
if row.status != "normal":
raise HTTPException(status_code=400, detail="仅正常状态的登记可编辑")
if force_self and row.registrant_id != user.id:
raise HTTPException(status_code=403, detail="只能编辑本人登记")
license_plate = payload.license_plate.strip()
_assert_vehicle_exists(db, tenant_no, license_plate)
row.fuel_category = payload.fuel_category
row.register_date = payload.register_date
row.registrant_id = _resolve_registrant_id(
db, tenant_no, payload.registrant_id, user, force_self=force_self
)
row.license_plate = license_plate
row.odometer_km = payload.odometer_km
row.fuel_liters = payload.fuel_liters
row.fuel_tons = calc_fuel_tons(payload.fuel_liters)
row.attachment_urls = payload.attachment_urls
row.remark = payload.remark
row.update_by = user.id
row.update_time = datetime.now()
db.commit()
db.refresh(row)
return to_read(row, db)
def cancel_register(
db: Session,
tenant_no: str,
user: DbUserContext,
register_id: str,
*,
force_self: bool = False,
cancel_reason: Optional[str] = None,
) -> VehicleFuelRegisterRead:
from app.schemas.pl.cancel_reason import normalize_optional_reason
row = _get_row(db, tenant_no, register_id, user)
if row.status != "normal":
raise HTTPException(status_code=400, detail="仅正常状态的登记可作废")
if force_self and row.registrant_id != user.id:
raise HTTPException(status_code=403, detail="只能作废本人登记")
now = datetime.now()
row.status = "cancelled"
row.cancel_reason = normalize_optional_reason(cancel_reason)
row.cancel_time = now
row.cancel_by = user.id
row.update_by = user.id
row.update_time = now
db.commit()
db.refresh(row)
return to_read(row, db)
def restore_register(
db: Session,
tenant_no: str,
user: DbUserContext,
register_id: str,
*,
force_self: bool = False,
) -> VehicleFuelRegisterRead:
row = _get_row(db, tenant_no, register_id, user)
if row.status != "cancelled":
raise HTTPException(status_code=400, detail="仅已作废的登记可恢复")
if force_self and row.registrant_id != user.id:
raise HTTPException(status_code=403, detail="只能恢复本人登记")
row.status = "normal"
row.cancel_reason = None
row.cancel_time = None
row.cancel_by = None
row.update_by = user.id
row.update_time = datetime.now()
db.commit()
db.refresh(row)
return to_read(row, db)
def ym_shift(ym: str, n: int) -> str:
y, m = [int(x) for x in ym.split("-")]
idx = y * 12 + (m - 1) + n
ny, nm = divmod(idx, 12)
return f"{ny:04d}-{nm + 1:02d}"
def period_run_km(
cur_rows: Sequence[Tuple[date, Optional[Decimal]]],
next_rows: Sequence[Tuple[date, Optional[Decimal]]],
) -> Tuple[Optional[Decimal], str]:
"""月/季度首笔到下一周期首笔;尚无终点时使用本周期末笔暂估。"""
current = sorted([(d, k) for d, k in cur_rows if k is not None], key=lambda x: x[0])
following = sorted([(d, k) for d, k in next_rows if k is not None], key=lambda x: x[0])
if not current:
return None, "insufficient"
readings = [k for _, k in current]
if following:
readings.append(following[0][1])
if any(k < 0 for k in readings) or any(b < a for a, b in zip(readings, readings[1:])):
return None, "abnormal"
if len(readings) < 2:
return None, "insufficient"
return readings[-1] - readings[0], "finalized" if following else "estimated"
def _ym_bounds(ym: str) -> tuple[date, date]:
"""返回 [start, end) 自然月边界。"""
y, m = [int(x) for x in ym.split("-")]
start = date(y, m, 1)
if m == 12:
end = date(y + 1, 1, 1)
else:
end = date(y, m + 1, 1)
return start, end
def _row_ym(d: date) -> str:
return f"{d:%Y-%m}"
def quarter_bounds(d: date) -> tuple[date, date]:
"""当前自然季 [start, end)。"""
q0 = (d.month - 1) // 3
start_month = q0 * 3 + 1
start = date(d.year, start_month, 1)
end_month = start_month + 3
if end_month > 12:
end = date(d.year + 1, end_month - 12, 1)
else:
end = date(d.year, end_month, 1)
return start, end
def quarter_label(d: date) -> str:
q = (d.month - 1) // 3 + 1
return f"{d.year}-Q{q}"
def rate_l100(liters: Decimal, run_km: Optional[Decimal]) -> Optional[Decimal]:
"""百公里油耗 L/100km;行驶公里不足时无法计算。"""
if run_km is None or run_km <= 0:
return None
return (Decimal(liters) / Decimal(run_km) * Decimal("100")).quantize(
Decimal("0.01"), rounding=ROUND_HALF_UP
)
def _odo_pairs(
rows: Sequence[PlVehicleFuelRegister],
) -> list[Tuple[date, Optional[Decimal]]]:
return [(r.register_date, r.odometer_km) for r in rows]
def _sum_liters(rows: Sequence[PlVehicleFuelRegister]) -> Decimal:
total = Decimal("0")
for r in rows:
total += r.fuel_liters or Decimal("0")
return total
def list_plate_month_summary(
db: Session, tenant_no: str, user: DbUserContext
) -> VehicleFuelPlateMonthSummaryResponse:
"""自有车月/季首笔到首笔里程与参考油耗,独立于列表过滤条件。"""
today = date.today()
ym = f"{today:%Y-%m}"
prev_ym = ym_shift(ym, -1)
next_ym = ym_shift(ym, 1)
cur_start, cur_end = _ym_bounds(ym)
prev_start, prev_end = _ym_bounds(prev_ym)
next_start, next_end = _ym_bounds(next_ym)
last3_start, _ = _ym_bounds(ym_shift(ym, -2))
q_start, q_end = quarter_bounds(today)
prev_q_start, _ = _ym_bounds(ym_shift(f"{q_start:%Y-%m}", -3))
_, next_q_end = quarter_bounds(q_end)
range_start = min(prev_q_start, last3_start, prev_start)
range_end = max(next_end, next_q_end)
vehicle_query = (
db.query(PlVehicle)
.filter(
PlVehicle.tenant_no == tenant_no,
PlVehicle.vehicle_type == "self",
PlVehicle.del_flag == 0,
# 历史档案将叉车、油桶也归为 self;车辆统计卡片不展示这两类用油对象。
func.trim(PlVehicle.license_plate).notin_(("叉车", "油桶")),
)
.order_by(
PlVehicle.order_num.is_(None),
PlVehicle.order_num.asc(),
PlVehicle.license_plate.asc(),
)
)
vehicles = apply_pl_scope(vehicle_query, PlVehicle, user, db, tenant_no).all()
personnel_summaries = load_vehicle_personnel_summaries(db, tenant_no, [v.id for v in vehicles])
query = db.query(PlVehicleFuelRegister).filter(
PlVehicleFuelRegister.tenant_no == tenant_no,
PlVehicleFuelRegister.del_flag == 0,
PlVehicleFuelRegister.status == "normal",
PlVehicleFuelRegister.register_date >= range_start,
PlVehicleFuelRegister.register_date < range_end,
)
query = apply_pl_scope(query, PlVehicleFuelRegister, user, db, tenant_no)
registers = query.order_by(
PlVehicleFuelRegister.register_date.asc(),
PlVehicleFuelRegister.create_time.asc(),
PlVehicleFuelRegister.id.asc(),
).all()
by_plate: dict[str, list[PlVehicleFuelRegister]] = {}
for row in registers:
by_plate.setdefault(row.license_plate, []).append(row)
items: list[VehicleFuelPlateMonthItem] = []
for v in vehicles:
rows = by_plate.get(v.license_plate, [])
cur_rows = [r for r in rows if cur_start <= r.register_date < cur_end]
prev_rows = [r for r in rows if prev_start <= r.register_date < prev_end]
next_rows = [r for r in rows if next_start <= r.register_date < next_end]
q_rows = [r for r in rows if q_start <= r.register_date < q_end]
next_q_rows = [r for r in rows if q_end <= r.register_date < next_q_end]
prev_q_rows = [r for r in rows if prev_q_start <= r.register_date < q_start]
last3_rows = [r for r in rows if last3_start <= r.register_date < cur_end]
month_km, month_status = period_run_km(_odo_pairs(cur_rows), _odo_pairs(next_rows))
prev_month_km, prev_month_status = period_run_km(_odo_pairs(prev_rows), _odo_pairs(cur_rows))
quarter_km, quarter_status = period_run_km(_odo_pairs(q_rows), _odo_pairs(next_q_rows))
prev_quarter_km, prev_quarter_status = period_run_km(_odo_pairs(prev_q_rows), _odo_pairs(q_rows))
last3_km, _ = period_run_km(_odo_pairs(last3_rows), _odo_pairs(next_rows))
month_rate = rate_l100(_sum_liters(cur_rows), month_km)
prev_month_rate = rate_l100(_sum_liters(prev_rows), prev_month_km)
quarter_rate = rate_l100(_sum_liters(q_rows), quarter_km)
prev_quarter_rate = rate_l100(_sum_liters(prev_q_rows), prev_quarter_km)
last3_rate = rate_l100(_sum_liters(last3_rows), last3_km)
items.append(
VehicleFuelPlateMonthItem(
licensePlate=v.license_plate,
trailerNo=v.trailer_no,
defaultDriverName=personnel_summaries.get(v.id, ("", None))[1],
vehicleStatus=v.vehicle_status,
liters=_sum_liters(cur_rows),
prevLiters=_sum_liters(prev_rows),
runKm=month_km,
prevRunKm=prev_month_km,
monthMileageStatus=month_status,
prevMonthMileageStatus=prev_month_status,
quarterMileageStatus=quarter_status,
prevQuarterMileageStatus=prev_quarter_status,
monthRateL100=month_rate,
quarterRateL100=quarter_rate,
prevQuarterRateL100=prev_quarter_rate,
prevMonthRateL100=prev_month_rate,
last3MonthsRateL100=last3_rate,
)
)
return VehicleFuelPlateMonthSummaryResponse(
month=ym, quarter=quarter_label(today), items=items
)