706 lines
24 KiB
Python
706 lines
24 KiB
Python
"""Сравнение: по рецепту / на сегодня / сделали."""
|
||
|
||
from __future__ import annotations
|
||
|
||
from datetime import date
|
||
from typing import Any, Dict, List, Optional, Tuple
|
||
|
||
from sqlalchemy import select
|
||
|
||
from app import db
|
||
from app.models import (
|
||
Component,
|
||
Ingredient,
|
||
LoadingReport,
|
||
LoadingReportComponent,
|
||
Recipe,
|
||
UnloadingGroup,
|
||
UnloadingReport,
|
||
UnloadingReportGroup,
|
||
)
|
||
from app.services.analytics.date_range import resolve_date_bounds
|
||
from app.services.analytics.recipe_filter import parse_recipe_ids
|
||
from app.services.daily_plan.builder import ALL_DISPENSERS_ID, build_daily_plan
|
||
from app.services.daily_plan.skips import get_skipped_ingredient_ids
|
||
from app.services.recipe_calculator import calculate_recipe
|
||
|
||
_EXEC_TOLERANCE_KG = 20.0
|
||
_MIN_PLAN_KG = 0.05
|
||
|
||
|
||
def _base_kg(recipe: Recipe, ing: Ingredient) -> float:
|
||
heads = int(recipe.heads_per_trip or 0)
|
||
tp = float(recipe.trip_percent or 100) / 100.0
|
||
return round(float(ing.weight_per_head or 0) * heads * tp, 2)
|
||
|
||
|
||
def _find_trip_in_plan(plan: Dict[str, Any], recipe_id: str) -> Optional[Dict[str, Any]]:
|
||
for period in plan.get("periods") or []:
|
||
for trip in period.get("trips") or []:
|
||
if trip.get("recipeId") == recipe_id:
|
||
return trip
|
||
return None
|
||
|
||
|
||
def _plan_cache() -> Dict[str, Dict[str, Any]]:
|
||
return {}
|
||
|
||
|
||
def _get_plan_for_date(iso_date: str, cache: Dict[str, Dict[str, Any]]) -> Dict[str, Any]:
|
||
if iso_date not in cache:
|
||
cache[iso_date] = build_daily_plan(dispenser_id=ALL_DISPENSERS_ID, plan_date=iso_date)
|
||
return cache[iso_date]
|
||
|
||
|
||
def _match_plan_ingredient(
|
||
trip: Optional[Dict[str, Any]],
|
||
*,
|
||
component_id: Optional[str],
|
||
component_name: str,
|
||
) -> Optional[Dict[str, Any]]:
|
||
if not trip:
|
||
return None
|
||
name_lo = (component_name or "").strip().lower()
|
||
for ing in trip.get("ingredients") or []:
|
||
if component_id and ing.get("componentId") == component_id:
|
||
return ing
|
||
if ing.get("replacementComponentId") == component_id:
|
||
return ing
|
||
orig = str(ing.get("originalName") or ing.get("name") or "").lower()
|
||
if name_lo and orig == name_lo:
|
||
return ing
|
||
return None
|
||
|
||
|
||
def _build_deviation_notes(
|
||
*,
|
||
base_kg: float,
|
||
plan_today_kg: float,
|
||
actual_kg: float,
|
||
report_date: date,
|
||
skipped_today: bool = False,
|
||
phase: str = "loading",
|
||
) -> Tuple[List[Dict[str, str]], str]:
|
||
"""notes[].kind: zootech | execution.
|
||
|
||
fault:
|
||
execution — механизатор отклонился от плана на сегодня;
|
||
excluded — зоотехник исключил компонент, загрузка совпала с планом (0);
|
||
adjusted — зоотехник скорректировал план, загрузка совпала с новым планом;
|
||
none — без отклонений.
|
||
"""
|
||
notes: List[Dict[str, str]] = []
|
||
ds = report_date.strftime("%d.%m")
|
||
is_unloading = phase == "unloading"
|
||
overload_label = "перегруз при выгрузке" if is_unloading else "перегруз при загрузке"
|
||
underload_label = "недогруз при выгрузке" if is_unloading else "недогруз при загрузке"
|
||
loaded_despite_label = (
|
||
"выгрузили несмотря на исключение" if is_unloading else "загрузили несмотря на исключение"
|
||
)
|
||
plan_ok_label = (
|
||
"выгрузка по новому плану" if is_unloading else "загрузка по новому плану"
|
||
)
|
||
zootech_changed = base_kg > plan_today_kg + _EXEC_TOLERANCE_KG
|
||
execution_ok = abs(actual_kg - plan_today_kg) <= _EXEC_TOLERANCE_KG
|
||
fully_excluded = skipped_today and plan_today_kg <= _MIN_PLAN_KG
|
||
|
||
if fully_excluded:
|
||
notes.append(
|
||
{
|
||
"text": f"исключено из плана на сегодня ({ds})",
|
||
"kind": "zootech",
|
||
}
|
||
)
|
||
elif zootech_changed:
|
||
diff = round(base_kg - plan_today_kg, 1)
|
||
if execution_ok:
|
||
text = f"план скорректирован −{diff} кг ({ds}) — {plan_ok_label}"
|
||
else:
|
||
text = f"план скорректирован −{diff} кг ({ds})"
|
||
notes.append({"text": text, "kind": "zootech"})
|
||
|
||
if plan_today_kg > _MIN_PLAN_KG and actual_kg > plan_today_kg + _EXEC_TOLERANCE_KG:
|
||
diff = round(actual_kg - plan_today_kg, 1)
|
||
notes.append(
|
||
{
|
||
"text": f"{overload_label} +{diff} кг ({ds})",
|
||
"kind": "execution",
|
||
}
|
||
)
|
||
elif plan_today_kg > _MIN_PLAN_KG and actual_kg < plan_today_kg - _EXEC_TOLERANCE_KG:
|
||
diff = round(plan_today_kg - actual_kg, 1)
|
||
notes.append(
|
||
{
|
||
"text": f"{underload_label} −{diff} кг ({ds})",
|
||
"kind": "execution",
|
||
}
|
||
)
|
||
elif fully_excluded and actual_kg > _MIN_PLAN_KG:
|
||
diff = round(actual_kg, 1)
|
||
notes.append(
|
||
{
|
||
"text": f"{loaded_despite_label} +{diff} кг ({ds})",
|
||
"kind": "execution",
|
||
}
|
||
)
|
||
|
||
has_execution = any(n["kind"] == "execution" for n in notes)
|
||
if has_execution:
|
||
fault = "execution"
|
||
elif fully_excluded and execution_ok:
|
||
fault = "excluded"
|
||
elif zootech_changed and execution_ok:
|
||
fault = "adjusted"
|
||
elif zootech_changed:
|
||
fault = "adjusted"
|
||
else:
|
||
fault = "none"
|
||
|
||
return notes, fault
|
||
|
||
|
||
def _plan_ing_matches_report_comp(
|
||
plan_ing: Dict[str, Any],
|
||
comp: LoadingReportComponent,
|
||
) -> bool:
|
||
cid = comp.component_id
|
||
cname = (comp.component_name or "").strip().lower()
|
||
pcid = plan_ing.get("componentId")
|
||
repl = plan_ing.get("replacementComponentId")
|
||
if cid:
|
||
sc = str(cid)
|
||
if pcid and sc == str(pcid):
|
||
return True
|
||
if repl and sc == str(repl):
|
||
return True
|
||
for key in ("originalName", "name"):
|
||
plan_name = str(plan_ing.get(key) or "").strip().lower()
|
||
if cname and plan_name and cname == plan_name:
|
||
return True
|
||
return False
|
||
|
||
|
||
def _component_row(
|
||
*,
|
||
recipe: Recipe,
|
||
ing: Optional[Ingredient],
|
||
plan_ing: Optional[Dict[str, Any]],
|
||
comp: Optional[LoadingReportComponent],
|
||
report_date: date,
|
||
skipped_ingredients: set,
|
||
) -> Dict[str, Any]:
|
||
cid = comp.component_id if comp else None
|
||
if plan_ing and not cid:
|
||
cid = plan_ing.get("replacementComponentId") or plan_ing.get("componentId")
|
||
cname = str(
|
||
(comp.component_name if comp else None)
|
||
or (plan_ing or {}).get("name")
|
||
or (plan_ing or {}).get("originalName")
|
||
or (ing.name if ing else None)
|
||
or "—"
|
||
)
|
||
|
||
base_kg = _base_kg(recipe, ing) if ing else float((comp.target_weight if comp else 0) or 0)
|
||
skipped_today = False
|
||
if plan_ing:
|
||
skipped_today = bool(plan_ing.get("skippedToday"))
|
||
if skipped_today:
|
||
plan_today_kg = 0.0
|
||
base_kg = float(plan_ing.get("baselineTotalKg") or base_kg)
|
||
else:
|
||
plan_today_kg = float(plan_ing.get("totalKg") or 0)
|
||
elif ing and ing.id in skipped_ingredients:
|
||
skipped_today = True
|
||
plan_today_kg = 0.0
|
||
elif comp is not None:
|
||
plan_today_kg = float(comp.target_weight or base_kg)
|
||
else:
|
||
plan_today_kg = 0.0
|
||
|
||
actual_kg = float(comp.actual_weight or 0) if comp is not None else 0.0
|
||
notes, fault = _build_deviation_notes(
|
||
base_kg=base_kg,
|
||
plan_today_kg=plan_today_kg,
|
||
actual_kg=actual_kg,
|
||
report_date=report_date,
|
||
skipped_today=skipped_today,
|
||
)
|
||
ingredient_id = None
|
||
if plan_ing:
|
||
ingredient_id = plan_ing.get("id")
|
||
elif ing:
|
||
ingredient_id = ing.id
|
||
|
||
return {
|
||
"componentId": cid,
|
||
"ingredientId": ingredient_id,
|
||
"name": cname,
|
||
"baseKg": round(base_kg, 2),
|
||
"planTodayKg": round(plan_today_kg, 2),
|
||
"actualKg": round(actual_kg, 2),
|
||
"skippedToday": skipped_today,
|
||
"loadingOrder": int(comp.loading_order or 0) if comp is not None else None,
|
||
"notes": notes,
|
||
"fault": fault,
|
||
}
|
||
|
||
|
||
def _match_plan_unloading_group(
|
||
trip: Optional[Dict[str, Any]],
|
||
*,
|
||
group_id: Optional[str],
|
||
group_name: str,
|
||
) -> Optional[Dict[str, Any]]:
|
||
if not trip:
|
||
return None
|
||
name_lo = (group_name or "").strip().lower()
|
||
for grp in trip.get("unloadingGroups") or []:
|
||
if group_id and grp.get("id") == group_id:
|
||
return grp
|
||
grp_name = str(grp.get("name") or "").strip().lower()
|
||
if name_lo and grp_name == name_lo:
|
||
return grp
|
||
return None
|
||
|
||
|
||
def _baseline_unloading_weights(
|
||
recipe: Recipe,
|
||
*,
|
||
cache: Dict[str, Dict[str, float]],
|
||
) -> Dict[str, float]:
|
||
rid = recipe.id
|
||
if rid in cache:
|
||
return cache[rid]
|
||
|
||
groups = list(
|
||
db.session.execute(
|
||
select(UnloadingGroup)
|
||
.where(UnloadingGroup.recipe_id == rid, UnloadingGroup.is_deleted.is_(False))
|
||
.order_by(UnloadingGroup.order.asc())
|
||
).scalars().all()
|
||
)
|
||
if not groups:
|
||
cache[rid] = {}
|
||
return cache[rid]
|
||
|
||
ingredients = list(
|
||
db.session.execute(
|
||
select(Ingredient)
|
||
.where(Ingredient.recipe_id == rid, Ingredient.is_deleted.is_(False))
|
||
.order_by(Ingredient.order.asc())
|
||
).scalars().all()
|
||
)
|
||
comp_ids = [str(i.component_id) for i in ingredients if i.component_id]
|
||
components = (
|
||
db.session.execute(
|
||
select(Component).where(
|
||
Component.id.in_(set(comp_ids)),
|
||
Component.is_deleted.is_(False),
|
||
)
|
||
).scalars().all()
|
||
if comp_ids
|
||
else []
|
||
)
|
||
dm_map = {str(c.id): float(c.dry_matter or 0) for c in components}
|
||
calc_inputs = [
|
||
{
|
||
"weightPerHead": float(ing.weight_per_head or 0),
|
||
"dryMatter": float(ing.dry_matter or dm_map.get(str(ing.component_id or ""), 0) or 0),
|
||
"component_id": ing.component_id,
|
||
}
|
||
for ing in ingredients
|
||
]
|
||
calc_groups = [
|
||
{
|
||
"distributionType": g.distribution_type or "percent",
|
||
"value": float(g.value or 0),
|
||
}
|
||
for g in groups
|
||
]
|
||
result = calculate_recipe(
|
||
calc_inputs,
|
||
heads_count=int(recipe.heads_per_trip or 0),
|
||
trip_percent=float(recipe.trip_percent or 100),
|
||
unloading_groups=calc_groups,
|
||
component_dry_matter_map=dm_map,
|
||
)
|
||
calc_unloading = result.get("unloadingGroups") or []
|
||
out: Dict[str, float] = {}
|
||
for idx, grp in enumerate(groups):
|
||
if idx < len(calc_unloading):
|
||
out[grp.id] = float(calc_unloading[idx].get("calculatedWeight") or 0)
|
||
cache[rid] = out
|
||
return out
|
||
|
||
|
||
def _unloading_group_row(
|
||
*,
|
||
plan_grp: Optional[Dict[str, Any]],
|
||
report_grp: Optional[UnloadingReportGroup],
|
||
base_kg: float,
|
||
report_date: date,
|
||
) -> Dict[str, Any]:
|
||
gid = plan_grp.get("id") if plan_grp else None
|
||
|
||
name = str(
|
||
(report_grp.name if report_grp is not None else None)
|
||
or (plan_grp or {}).get("name")
|
||
or "—"
|
||
)
|
||
skipped_today = bool((plan_grp or {}).get("skippedToday"))
|
||
if plan_grp is not None:
|
||
plan_today_kg = 0.0 if skipped_today else float(plan_grp.get("weightKg") or 0)
|
||
elif report_grp is not None:
|
||
plan_today_kg = float(report_grp.target_weight or base_kg)
|
||
else:
|
||
plan_today_kg = 0.0
|
||
|
||
actual_kg = float(report_grp.unloaded_weight or 0) if report_grp is not None else 0.0
|
||
notes, fault = _build_deviation_notes(
|
||
base_kg=base_kg,
|
||
plan_today_kg=plan_today_kg,
|
||
actual_kg=actual_kg,
|
||
report_date=report_date,
|
||
skipped_today=skipped_today,
|
||
phase="unloading",
|
||
)
|
||
return {
|
||
"groupId": gid,
|
||
"name": name,
|
||
"baseKg": round(base_kg, 2),
|
||
"planTodayKg": round(plan_today_kg, 2),
|
||
"actualKg": round(actual_kg, 2),
|
||
"skippedToday": skipped_today,
|
||
"unloadingOrder": int(report_grp.order or 0) if report_grp is not None else None,
|
||
"notes": notes,
|
||
"fault": fault,
|
||
}
|
||
|
||
|
||
def _mixer_remainder_row(
|
||
*,
|
||
remaining_kg: float,
|
||
report_date: date,
|
||
) -> Dict[str, Any]:
|
||
base_kg = 0.0
|
||
plan_today_kg = 0.0
|
||
actual_kg = float(remaining_kg or 0)
|
||
notes: List[Dict[str, str]] = []
|
||
fault = "none"
|
||
if abs(actual_kg) > _EXEC_TOLERANCE_KG:
|
||
ds = report_date.strftime("%d.%m")
|
||
notes.append(
|
||
{
|
||
"text": f"остаток в миксере {round(actual_kg, 1):+g} кг ({ds})",
|
||
"kind": "execution",
|
||
}
|
||
)
|
||
fault = "execution"
|
||
return {
|
||
"name": "Остаток в миксере",
|
||
"baseKg": round(base_kg, 2),
|
||
"planTodayKg": round(plan_today_kg, 2),
|
||
"actualKg": round(actual_kg, 2),
|
||
"notes": notes,
|
||
"fault": fault,
|
||
}
|
||
|
||
|
||
def _build_unloading_section(
|
||
*,
|
||
trip: Optional[Dict[str, Any]],
|
||
unloading_report: Optional[UnloadingReport],
|
||
report_groups: List[UnloadingReportGroup],
|
||
baseline_by_group: Dict[str, float],
|
||
report_date: date,
|
||
) -> Tuple[List[Dict[str, Any]], Optional[Dict[str, Any]]]:
|
||
matched_plan_ids: set = set()
|
||
groups_out: List[Dict[str, Any]] = []
|
||
|
||
for report_grp in report_groups:
|
||
plan_grp = _match_plan_unloading_group(
|
||
trip,
|
||
group_id=None,
|
||
group_name=str(report_grp.name or ""),
|
||
)
|
||
if plan_grp and plan_grp.get("id"):
|
||
matched_plan_ids.add(plan_grp["id"])
|
||
base_kg = float(baseline_by_group.get(plan_grp.get("id") if plan_grp else "", 0) or 0)
|
||
if base_kg <= 0 and report_grp is not None:
|
||
base_kg = float(report_grp.target_weight or 0)
|
||
groups_out.append(
|
||
_unloading_group_row(
|
||
plan_grp=plan_grp,
|
||
report_grp=report_grp,
|
||
base_kg=base_kg,
|
||
report_date=report_date,
|
||
)
|
||
)
|
||
|
||
if trip:
|
||
report_names_lo = {str(g.name or "").strip().lower() for g in report_groups}
|
||
for plan_grp in trip.get("unloadingGroups") or []:
|
||
if not plan_grp.get("skippedToday"):
|
||
continue
|
||
pid = plan_grp.get("id")
|
||
if pid and pid in matched_plan_ids:
|
||
continue
|
||
pname = str(plan_grp.get("name") or "").strip().lower()
|
||
if pname and pname in report_names_lo:
|
||
continue
|
||
if pid:
|
||
matched_plan_ids.add(pid)
|
||
base_kg = float(baseline_by_group.get(pid or "", 0) or 0)
|
||
groups_out.append(
|
||
_unloading_group_row(
|
||
plan_grp=plan_grp,
|
||
report_grp=None,
|
||
base_kg=base_kg,
|
||
report_date=report_date,
|
||
)
|
||
)
|
||
if not report_groups:
|
||
for plan_grp in trip.get("unloadingGroups") or []:
|
||
pid = plan_grp.get("id")
|
||
if pid and pid in matched_plan_ids:
|
||
continue
|
||
if pid:
|
||
matched_plan_ids.add(pid)
|
||
base_kg = float(baseline_by_group.get(pid or "", 0) or 0)
|
||
groups_out.append(
|
||
_unloading_group_row(
|
||
plan_grp=plan_grp,
|
||
report_grp=None,
|
||
base_kg=base_kg,
|
||
report_date=report_date,
|
||
)
|
||
)
|
||
|
||
def _sort_key(row: Dict[str, Any]) -> tuple:
|
||
order = row.get("unloadingOrder")
|
||
if order is not None:
|
||
return (order, row.get("name") or "")
|
||
return (10_000, row.get("name") or "")
|
||
|
||
groups_out.sort(key=_sort_key)
|
||
|
||
mixer = None
|
||
if unloading_report is not None:
|
||
mixer = _mixer_remainder_row(
|
||
remaining_kg=float(unloading_report.remaining_weight or 0),
|
||
report_date=report_date,
|
||
)
|
||
return groups_out, mixer
|
||
|
||
|
||
def build_plan_fact_rows(
|
||
*,
|
||
date_from: Optional[str] = None,
|
||
date_to: Optional[str] = None,
|
||
recipe_id: Optional[str] = None,
|
||
recipe_ids: Optional[str] = None,
|
||
client_id: Optional[str] = None,
|
||
) -> Dict[str, Any]:
|
||
start_dt, end_dt = resolve_date_bounds(date_from, date_to)
|
||
q = select(LoadingReport).where(
|
||
LoadingReport.is_deleted.is_(False),
|
||
LoadingReport.start_time >= start_dt,
|
||
LoadingReport.start_time <= end_dt,
|
||
)
|
||
ids = parse_recipe_ids(recipe_id=recipe_id, recipe_ids=recipe_ids)
|
||
if ids:
|
||
q = q.where(LoadingReport.recipe_id.in_(ids) if len(ids) > 1 else LoadingReport.recipe_id == ids[0])
|
||
if client_id:
|
||
q = q.where(LoadingReport.client_id == client_id)
|
||
reports = db.session.execute(q.order_by(LoadingReport.start_time.desc())).scalars().all()
|
||
if not reports:
|
||
return {"items": [], "reportCount": 0}
|
||
|
||
report_ids = [r.id for r in reports]
|
||
comp_rows = db.session.execute(
|
||
select(LoadingReportComponent).where(
|
||
LoadingReportComponent.report_id.in_(report_ids),
|
||
LoadingReportComponent.is_deleted.is_(False),
|
||
).order_by(LoadingReportComponent.loading_order.asc())
|
||
).scalars().all()
|
||
comps_by_report: Dict[str, List[LoadingReportComponent]] = {}
|
||
for c in comp_rows:
|
||
comps_by_report.setdefault(c.report_id, []).append(c)
|
||
|
||
recipe_ids = {r.recipe_id for r in reports}
|
||
recipes = {
|
||
r.id: r
|
||
for r in db.session.execute(
|
||
select(Recipe).where(Recipe.id.in_(recipe_ids), Recipe.is_deleted.is_(False))
|
||
).scalars().all()
|
||
}
|
||
ingredients_by_recipe: Dict[str, List[Ingredient]] = {}
|
||
for rid in recipe_ids:
|
||
ingredients_by_recipe[rid] = list(
|
||
db.session.execute(
|
||
select(Ingredient)
|
||
.where(Ingredient.recipe_id == rid, Ingredient.is_deleted.is_(False))
|
||
.order_by(Ingredient.order.asc())
|
||
).scalars().all()
|
||
)
|
||
|
||
unloading_reports = db.session.execute(
|
||
select(UnloadingReport).where(
|
||
UnloadingReport.loading_report_id.in_(report_ids),
|
||
UnloadingReport.is_deleted.is_(False),
|
||
)
|
||
).scalars().all()
|
||
unloading_by_loading: Dict[str, UnloadingReport] = {
|
||
ur.loading_report_id: ur for ur in unloading_reports
|
||
}
|
||
unloading_report_ids = [ur.id for ur in unloading_reports]
|
||
unloading_groups_rows: List[UnloadingReportGroup] = []
|
||
if unloading_report_ids:
|
||
unloading_groups_rows = list(
|
||
db.session.execute(
|
||
select(UnloadingReportGroup)
|
||
.where(
|
||
UnloadingReportGroup.report_id.in_(unloading_report_ids),
|
||
UnloadingReportGroup.is_deleted.is_(False),
|
||
)
|
||
.order_by(UnloadingReportGroup.order.asc())
|
||
).scalars().all()
|
||
)
|
||
groups_by_unloading: Dict[str, List[UnloadingReportGroup]] = {}
|
||
for grp in unloading_groups_rows:
|
||
groups_by_unloading.setdefault(grp.report_id, []).append(grp)
|
||
|
||
plan_cache: Dict[str, Dict[str, Any]] = {}
|
||
skip_cache: Dict[str, Dict[str, set]] = {}
|
||
baseline_unloading_cache: Dict[str, Dict[str, float]] = {}
|
||
items: List[Dict[str, Any]] = []
|
||
|
||
for report in reports:
|
||
recipe = recipes.get(report.recipe_id)
|
||
if recipe is None:
|
||
continue
|
||
report_date = report.start_time.date() if report.start_time else date.today()
|
||
iso = report_date.isoformat()
|
||
plan = _get_plan_for_date(iso, plan_cache)
|
||
if iso not in skip_cache:
|
||
skip_cache[iso] = get_skipped_ingredient_ids(iso)
|
||
skipped_ingredients = skip_cache[iso].get(report.recipe_id, set())
|
||
trip = _find_trip_in_plan(plan, report.recipe_id)
|
||
|
||
ing_by_cid: Dict[str, Ingredient] = {}
|
||
ing_by_name: Dict[str, Ingredient] = {}
|
||
ing_by_id: Dict[str, Ingredient] = {}
|
||
for ing in ingredients_by_recipe.get(report.recipe_id, []):
|
||
ing_by_id[ing.id] = ing
|
||
if ing.component_id:
|
||
ing_by_cid[str(ing.component_id)] = ing
|
||
ing_by_name[(ing.name or "").strip().lower()] = ing
|
||
|
||
report_comps = comps_by_report.get(report.id, [])
|
||
matched_plan_ing_ids: set = set()
|
||
components_out: List[Dict[str, Any]] = []
|
||
|
||
for comp in report_comps:
|
||
cid = comp.component_id
|
||
cname = str(comp.component_name or "—")
|
||
ing = None
|
||
if cid and str(cid) in ing_by_cid:
|
||
ing = ing_by_cid[str(cid)]
|
||
elif cname.lower() in ing_by_name:
|
||
ing = ing_by_name[cname.lower()]
|
||
|
||
plan_ing = _match_plan_ingredient(trip, component_id=cid, component_name=cname)
|
||
if plan_ing and plan_ing.get("id"):
|
||
matched_plan_ing_ids.add(plan_ing["id"])
|
||
|
||
components_out.append(
|
||
_component_row(
|
||
recipe=recipe,
|
||
ing=ing,
|
||
plan_ing=plan_ing,
|
||
comp=comp,
|
||
report_date=report_date,
|
||
skipped_ingredients=skipped_ingredients,
|
||
)
|
||
)
|
||
|
||
if trip:
|
||
for plan_ing in trip.get("ingredients") or []:
|
||
if not plan_ing.get("skippedToday"):
|
||
continue
|
||
pid = plan_ing.get("id")
|
||
if pid and pid in matched_plan_ing_ids:
|
||
continue
|
||
if any(_plan_ing_matches_report_comp(plan_ing, c) for c in report_comps):
|
||
continue
|
||
|
||
ing = ing_by_id.get(pid) if pid else None
|
||
if ing is None:
|
||
pcid = plan_ing.get("componentId")
|
||
if pcid and str(pcid) in ing_by_cid:
|
||
ing = ing_by_cid[str(pcid)]
|
||
else:
|
||
name_lo = str(
|
||
plan_ing.get("originalName") or plan_ing.get("name") or ""
|
||
).strip().lower()
|
||
ing = ing_by_name.get(name_lo)
|
||
|
||
if pid:
|
||
matched_plan_ing_ids.add(pid)
|
||
components_out.append(
|
||
_component_row(
|
||
recipe=recipe,
|
||
ing=ing,
|
||
plan_ing=plan_ing,
|
||
comp=None,
|
||
report_date=report_date,
|
||
skipped_ingredients=skipped_ingredients,
|
||
)
|
||
)
|
||
|
||
recipe_ings = ingredients_by_recipe.get(report.recipe_id, [])
|
||
ing_order = {ing.id: idx for idx, ing in enumerate(recipe_ings)}
|
||
|
||
def _sort_key(row: Dict[str, Any]) -> tuple:
|
||
iid = row.get("ingredientId")
|
||
if iid and iid in ing_order:
|
||
return (ing_order[iid], 0)
|
||
lor = row.get("loadingOrder")
|
||
if lor is not None:
|
||
return (10_000, lor)
|
||
return (20_000, row.get("name") or "")
|
||
|
||
components_out.sort(key=_sort_key)
|
||
|
||
unloading_report = unloading_by_loading.get(report.id)
|
||
report_unloading_groups = (
|
||
groups_by_unloading.get(unloading_report.id, []) if unloading_report else []
|
||
)
|
||
baseline_by_group = _baseline_unloading_weights(
|
||
recipe,
|
||
cache=baseline_unloading_cache,
|
||
)
|
||
unloading_out, mixer_out = _build_unloading_section(
|
||
trip=trip,
|
||
unloading_report=unloading_report,
|
||
report_groups=report_unloading_groups,
|
||
baseline_by_group=baseline_by_group,
|
||
report_date=report_date,
|
||
)
|
||
|
||
items.append(
|
||
{
|
||
"loadingReportId": report.id,
|
||
"recipeId": report.recipe_id,
|
||
"recipeName": report.recipe_name,
|
||
"date": iso,
|
||
"startTime": report.start_time.isoformat() if report.start_time else None,
|
||
"clientId": report.client_id,
|
||
"components": components_out,
|
||
"unloadingGroups": unloading_out,
|
||
"mixerRemainder": mixer_out,
|
||
}
|
||
)
|
||
|
||
return {"items": items, "reportCount": len(items)}
|