590 lines
20 KiB
Python
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
|
|
)
|