641 lines
25 KiB
Python
641 lines
25 KiB
Python
from collections import defaultdict
|
||
from dataclasses import dataclass, replace
|
||
from datetime import date, datetime, timedelta
|
||
from decimal import Decimal, InvalidOperation, ROUND_HALF_UP
|
||
from typing import Any
|
||
|
||
from sqlalchemy import delete, select
|
||
from sqlalchemy.orm import Session
|
||
|
||
from app.models import ProductionReport, ProductionReportAllocation
|
||
from app.services.common import as_float, round2
|
||
from app.services.metrics import (
|
||
SHIFT_BUCKETS,
|
||
SHIFT_LABELS,
|
||
_blank_overtime_intervals,
|
||
_device_item_time_ranges,
|
||
_device_segment_ranges,
|
||
_iter_shift_base_dates,
|
||
_mold_key,
|
||
_overlap_minutes,
|
||
_schedule_interval,
|
||
calculate_report_metrics,
|
||
format_hours,
|
||
item_time_ranges,
|
||
minutes_between,
|
||
)
|
||
from app.services.work_schedule import DEFAULT_WORK_SCHEDULE_CONFIG, WorkScheduleConfig
|
||
|
||
SPLIT_QUANT = Decimal("0.01")
|
||
|
||
|
||
@dataclass(frozen=True)
|
||
class ReportAllocationDraft:
|
||
report_id: int | None
|
||
report_item_id: int | None
|
||
attendance_point_name: str
|
||
employee_phone: str
|
||
allocation_date: date
|
||
day_minutes: float = 0
|
||
overtime_minutes: float = 0
|
||
night_minutes: float = 0
|
||
effective_minutes: float = 0
|
||
good_qty: float = 0
|
||
defect_qty: float = 0
|
||
scrap_qty: float = 0
|
||
changeover_count: float = 0
|
||
reference_wage: float = 0
|
||
|
||
|
||
def _add_minutes(
|
||
rows: dict[date, dict[str, float]],
|
||
allocation_date: date,
|
||
bucket: str,
|
||
minutes: float,
|
||
) -> None:
|
||
if minutes <= 0:
|
||
return
|
||
rows[allocation_date][bucket] += minutes
|
||
|
||
|
||
def _range_allocation_minutes(
|
||
start_at: datetime,
|
||
end_at: datetime,
|
||
schedule: WorkScheduleConfig | None = None,
|
||
) -> dict[date, dict[str, float]]:
|
||
active_schedule = schedule or DEFAULT_WORK_SCHEDULE_CONFIG
|
||
rows: dict[date, dict[str, float]] = defaultdict(lambda: {key: 0.0 for key in SHIFT_BUCKETS})
|
||
if end_at <= start_at:
|
||
return rows
|
||
|
||
for current_date in _iter_shift_base_dates(start_at, end_at):
|
||
meal_intervals = [
|
||
_schedule_interval(current_date, active_schedule.lunch_start, active_schedule.lunch_end),
|
||
_schedule_interval(current_date, active_schedule.dinner_start, active_schedule.dinner_end),
|
||
]
|
||
shift_intervals = {
|
||
"day": [_schedule_interval(current_date, active_schedule.day_start, active_schedule.day_end)],
|
||
"overtime": [
|
||
_schedule_interval(current_date, active_schedule.overtime_start, active_schedule.overtime_end)
|
||
],
|
||
"night": [_schedule_interval(current_date, active_schedule.night_start, active_schedule.night_end)],
|
||
}
|
||
|
||
for bucket, intervals in shift_intervals.items():
|
||
for interval_start, interval_end in intervals:
|
||
overlap_start = max(start_at, interval_start)
|
||
overlap_end = min(end_at, interval_end)
|
||
if overlap_end <= overlap_start:
|
||
continue
|
||
meal_minutes = sum(
|
||
_overlap_minutes(overlap_start, overlap_end, meal_start, meal_end)
|
||
for meal_start, meal_end in meal_intervals
|
||
if (
|
||
start_at <= meal_start
|
||
and end_at >= meal_end
|
||
and end_at > meal_end + timedelta(minutes=5)
|
||
)
|
||
)
|
||
minutes = max(0.0, minutes_between(overlap_start, overlap_end) - meal_minutes)
|
||
if bucket == "night":
|
||
_add_minutes(rows, current_date, "night", minutes)
|
||
else:
|
||
_add_minutes(rows, overlap_start.date(), bucket, minutes)
|
||
|
||
for blank_start, blank_end in _blank_overtime_intervals(current_date, active_schedule):
|
||
overlap_start = max(start_at, blank_start)
|
||
overlap_end = min(end_at, blank_end)
|
||
if overlap_end <= overlap_start:
|
||
continue
|
||
meal_minutes = sum(
|
||
_overlap_minutes(overlap_start, overlap_end, meal_start, meal_end)
|
||
for meal_start, meal_end in meal_intervals
|
||
if (
|
||
start_at <= meal_start
|
||
and end_at >= meal_end
|
||
and end_at > meal_end + timedelta(minutes=5)
|
||
)
|
||
)
|
||
minutes = max(0.0, minutes_between(overlap_start, overlap_end) - meal_minutes)
|
||
_add_minutes(rows, overlap_start.date(), "overtime", minutes)
|
||
return rows
|
||
|
||
|
||
def _report_devices(report) -> list | None:
|
||
session = getattr(report, "session", None)
|
||
devices = getattr(session, "devices", None)
|
||
if devices is not None:
|
||
return list(devices)
|
||
devices = getattr(report, "devices", None)
|
||
return list(devices) if devices is not None else None
|
||
|
||
|
||
def _decimal_value(value: Any) -> Decimal:
|
||
if value is None:
|
||
return Decimal("0")
|
||
if isinstance(value, Decimal):
|
||
return value
|
||
try:
|
||
return Decimal(str(value))
|
||
except (InvalidOperation, TypeError, ValueError):
|
||
return Decimal("0")
|
||
|
||
|
||
def _round_split_value(value: Any) -> float:
|
||
return float(_decimal_value(value).quantize(SPLIT_QUANT, rounding=ROUND_HALF_UP))
|
||
|
||
|
||
def _split_cents(value: Any) -> int:
|
||
rounded = _decimal_value(value).quantize(SPLIT_QUANT, rounding=ROUND_HALF_UP)
|
||
return int(rounded * 100)
|
||
|
||
|
||
def _scaled_split_value(value: Any, ratio: float) -> float:
|
||
return _round_split_value(_decimal_value(value) * _decimal_value(ratio))
|
||
|
||
|
||
def _item_reference_wage(item) -> Decimal:
|
||
return _decimal_value(getattr(item, "good_qty", 0)) * _decimal_value(
|
||
getattr(item, "process_unit_price_yuan", 0)
|
||
)
|
||
|
||
|
||
def _allocation_targets(report, items: list, schedule: WorkScheduleConfig | None = None):
|
||
metrics = calculate_report_metrics(
|
||
getattr(report, "start_at"),
|
||
getattr(report, "end_at"),
|
||
items,
|
||
break_minutes=as_float(getattr(report, "break_minutes", 0)),
|
||
devices=_report_devices(report),
|
||
schedule=schedule,
|
||
)
|
||
return (
|
||
{id(item): as_float(getattr(item, "allocated_minutes", 0)) for item in items},
|
||
{
|
||
"day": as_float(metrics.get("shift_day_minutes", 0)),
|
||
"overtime": as_float(metrics.get("shift_overtime_minutes", 0)),
|
||
"night": as_float(metrics.get("shift_night_minutes", 0)),
|
||
},
|
||
)
|
||
|
||
|
||
def _minutes_total(rows: dict[date, dict[str, float]]) -> float:
|
||
return sum(sum(minutes.get(key, 0.0) for key in SHIFT_BUCKETS) for minutes in rows.values())
|
||
|
||
|
||
def _empty_shift_minutes() -> dict[str, float]:
|
||
return {key: 0.0 for key in SHIFT_BUCKETS}
|
||
|
||
|
||
def _add_date_bucket_minutes(
|
||
target: dict[date, dict[str, float]],
|
||
source: dict[date, dict[str, float]],
|
||
*,
|
||
scale: float = 1.0,
|
||
) -> None:
|
||
for allocation_date, minutes in source.items():
|
||
row = target.setdefault(allocation_date, _empty_shift_minutes())
|
||
for key in SHIFT_BUCKETS:
|
||
row[key] += minutes.get(key, 0.0) * scale
|
||
|
||
|
||
def _bucket_totals(rows_by_date: dict[date, dict[str, float]]) -> dict[str, float]:
|
||
return {
|
||
key: sum(minutes.get(key, 0.0) for minutes in rows_by_date.values())
|
||
for key in SHIFT_BUCKETS
|
||
}
|
||
|
||
|
||
def _item_bucket_totals(minutes_by_item: dict[int, dict[date, dict[str, float]]]) -> dict[str, float]:
|
||
totals = _empty_shift_minutes()
|
||
for rows_by_date in minutes_by_item.values():
|
||
for key, value in _bucket_totals(rows_by_date).items():
|
||
totals[key] += value
|
||
return totals
|
||
|
||
|
||
def _allocate_unassigned_minutes_to_existing_items(
|
||
minutes_by_item: dict[int, dict[date, dict[str, float]]],
|
||
unassigned_minutes: dict[date, dict[str, float]],
|
||
) -> None:
|
||
unassigned_total = _minutes_total(unassigned_minutes)
|
||
if unassigned_total <= 0 or not minutes_by_item:
|
||
return
|
||
|
||
raw_item_totals = {
|
||
item_id: _minutes_total(rows_by_date)
|
||
for item_id, rows_by_date in minutes_by_item.items()
|
||
}
|
||
raw_total = sum(raw_item_totals.values())
|
||
item_count = len(minutes_by_item)
|
||
for item_id, rows_by_date in minutes_by_item.items():
|
||
weight = raw_item_totals[item_id] / raw_total if raw_total > 0 else 1 / item_count
|
||
_add_date_bucket_minutes(rows_by_date, unassigned_minutes, scale=weight)
|
||
|
||
|
||
def _scale_item_minutes_to_bucket_targets(
|
||
minutes_by_item: dict[int, dict[date, dict[str, float]]],
|
||
target_buckets: dict[str, float],
|
||
) -> None:
|
||
raw_buckets = _item_bucket_totals(minutes_by_item)
|
||
for key in SHIFT_BUCKETS:
|
||
raw_value = raw_buckets.get(key, 0.0)
|
||
target_value = target_buckets.get(key, 0.0)
|
||
if raw_value <= 0 or abs(raw_value - target_value) <= 0.000001:
|
||
continue
|
||
scale = target_value / raw_value
|
||
for rows_by_date in minutes_by_item.values():
|
||
for minutes in rows_by_date.values():
|
||
minutes[key] = minutes.get(key, 0.0) * scale
|
||
|
||
|
||
def _scale_bucket_minutes(
|
||
minutes_by_item: dict[int, dict[date, dict[str, float]]],
|
||
bucket: str,
|
||
scale: float,
|
||
) -> None:
|
||
for rows_by_date in minutes_by_item.values():
|
||
for minutes in rows_by_date.values():
|
||
minutes[bucket] = minutes.get(bucket, 0.0) * scale
|
||
|
||
|
||
def _balance_minutes_to_targets(
|
||
minutes_by_item: dict[int, dict[date, dict[str, float]]],
|
||
target_minutes_by_item: dict[int, float],
|
||
target_buckets: dict[str, float],
|
||
) -> None:
|
||
for _ in range(100):
|
||
for item_id, rows_by_date in minutes_by_item.items():
|
||
raw_total = _minutes_total(rows_by_date)
|
||
target_total = target_minutes_by_item.get(item_id, raw_total)
|
||
if raw_total <= 0:
|
||
continue
|
||
scale = target_total / raw_total
|
||
if abs(scale - 1) <= 0.000000001:
|
||
continue
|
||
for minutes in rows_by_date.values():
|
||
for key in SHIFT_BUCKETS:
|
||
minutes[key] = minutes.get(key, 0.0) * scale
|
||
|
||
raw_buckets = _item_bucket_totals(minutes_by_item)
|
||
for key in SHIFT_BUCKETS:
|
||
raw_value = raw_buckets.get(key, 0.0)
|
||
target_value = target_buckets.get(key, 0.0)
|
||
if raw_value <= 0:
|
||
continue
|
||
scale = target_value / raw_value
|
||
if abs(scale - 1) <= 0.000000001:
|
||
continue
|
||
_scale_bucket_minutes(minutes_by_item, key, scale)
|
||
|
||
|
||
def _round_bucket_cells_to_targets(
|
||
minutes_by_item: dict[int, dict[date, dict[str, float]]],
|
||
target_buckets: dict[str, float],
|
||
item_order: dict[int, int],
|
||
) -> None:
|
||
for bucket in SHIFT_BUCKETS:
|
||
cells: list[tuple[float, int, int, date]] = []
|
||
for item_id, rows_by_date in minutes_by_item.items():
|
||
for allocation_date, minutes in rows_by_date.items():
|
||
value = minutes.get(bucket, 0.0)
|
||
if value > 0:
|
||
cents_value = max(0.0, value * 100)
|
||
floor_cents = int(cents_value + 0.000000001)
|
||
cells.append((cents_value - floor_cents, floor_cents, item_order.get(item_id, 0), allocation_date))
|
||
minutes[bucket] = floor_cents / 100
|
||
else:
|
||
minutes[bucket] = 0.0
|
||
|
||
target_cents = int(round(round2(target_buckets.get(bucket, 0.0)) * 100))
|
||
floor_total = sum(cell[1] for cell in cells)
|
||
residual = target_cents - floor_total
|
||
if not cells or residual == 0:
|
||
continue
|
||
|
||
ordered = sorted(
|
||
cells,
|
||
key=lambda cell: (-cell[0], cell[2], cell[3].isoformat()),
|
||
)
|
||
if residual < 0:
|
||
ordered = sorted(
|
||
cells,
|
||
key=lambda cell: (cell[0], cell[2], cell[3].isoformat()),
|
||
)
|
||
|
||
cents_by_cell: dict[tuple[int, date], int] = {
|
||
(cell[2], cell[3]): cell[1] for cell in cells
|
||
}
|
||
steps = abs(residual)
|
||
for index in range(steps):
|
||
_, _, item_index, allocation_date = ordered[index % len(ordered)]
|
||
key = (item_index, allocation_date)
|
||
if residual > 0:
|
||
cents_by_cell[key] += 1
|
||
elif cents_by_cell[key] > 0:
|
||
cents_by_cell[key] -= 1
|
||
|
||
item_id_by_order = {order: item_id for item_id, order in item_order.items()}
|
||
for (item_index, allocation_date), cents in cents_by_cell.items():
|
||
item_id = item_id_by_order[item_index]
|
||
minutes_by_item[item_id][allocation_date][bucket] = cents / 100
|
||
|
||
|
||
def _items_by_device(items: list) -> dict[str, list]:
|
||
grouped: dict[str, list] = defaultdict(list)
|
||
for item in items:
|
||
mold_key = _mold_key(
|
||
getattr(item, "product_name", "") or item.device_no,
|
||
getattr(item, "process_name", ""),
|
||
)
|
||
grouped[mold_key].append(item)
|
||
return grouped
|
||
|
||
|
||
def _device_minutes_by_item(report, items: list, schedule: WorkScheduleConfig | None = None):
|
||
start_at = getattr(report, "start_at")
|
||
end_at = getattr(report, "end_at")
|
||
segment_ranges = _device_segment_ranges(start_at, end_at, _report_devices(report))
|
||
if not segment_ranges:
|
||
return None
|
||
|
||
items_by_device = _items_by_device(items)
|
||
minutes_by_item: dict[int, dict[date, dict[str, float]]] = {}
|
||
target_minutes: dict[date, dict[str, float]] = defaultdict(_empty_shift_minutes)
|
||
unassigned_minutes: dict[date, dict[str, float]] = defaultdict(_empty_shift_minutes)
|
||
allocated_item_ids: set[int] = set()
|
||
|
||
for device_no, ranges in segment_ranges.items():
|
||
device_items = items_by_device.get(device_no, [])
|
||
for segment_start, segment_end in ranges:
|
||
segment_minutes = _range_allocation_minutes(segment_start, segment_end, schedule)
|
||
_add_date_bucket_minutes(target_minutes, segment_minutes)
|
||
if not device_items:
|
||
_add_date_bucket_minutes(unassigned_minutes, segment_minutes)
|
||
continue
|
||
for item_range in _device_item_time_ranges(device_items, segment_start, segment_end):
|
||
item_minutes = minutes_by_item.setdefault(id(item_range.item), defaultdict(_empty_shift_minutes))
|
||
range_minutes = _range_allocation_minutes(item_range.start_at, item_range.end_at, schedule)
|
||
_add_date_bucket_minutes(
|
||
item_minutes,
|
||
range_minutes,
|
||
scale=as_float(getattr(item_range, "allocation_weight", 1.0)),
|
||
)
|
||
for item in device_items:
|
||
allocated_item_ids.add(id(item))
|
||
|
||
unmatched_items = [item for item in items if id(item) not in allocated_item_ids]
|
||
if unmatched_items and _minutes_total(unassigned_minutes) > 0:
|
||
target_buckets = _bucket_totals(target_minutes)
|
||
matched_buckets = _item_bucket_totals(minutes_by_item)
|
||
unassigned_buckets = _bucket_totals(unassigned_minutes)
|
||
for unmatched_item in unmatched_items:
|
||
item_minutes = minutes_by_item.setdefault(id(unmatched_item), defaultdict(_empty_shift_minutes))
|
||
for allocation_date, minutes in unassigned_minutes.items():
|
||
row = item_minutes.setdefault(allocation_date, _empty_shift_minutes())
|
||
for key in SHIFT_BUCKETS:
|
||
remaining = max(0.0, target_buckets.get(key, 0.0) - matched_buckets.get(key, 0.0))
|
||
raw_unassigned = unassigned_buckets.get(key, 0.0)
|
||
if remaining <= 0 or raw_unassigned <= 0:
|
||
continue
|
||
row[key] += minutes.get(key, 0.0) * (remaining / raw_unassigned) / len(unmatched_items)
|
||
return minutes_by_item
|
||
|
||
_allocate_unassigned_minutes_to_existing_items(minutes_by_item, unassigned_minutes)
|
||
_scale_item_minutes_to_bucket_targets(minutes_by_item, _bucket_totals(target_minutes))
|
||
return minutes_by_item
|
||
|
||
|
||
def _range_minutes_by_item(report, items: list, schedule: WorkScheduleConfig | None = None):
|
||
ranges = item_time_ranges(getattr(report, "start_at"), getattr(report, "end_at"), items, _report_devices(report))
|
||
minutes_by_item: dict[int, dict[date, dict[str, float]]] = {}
|
||
for item_range in ranges:
|
||
item_key = id(item_range.item)
|
||
target = minutes_by_item.setdefault(item_key, defaultdict(_empty_shift_minutes))
|
||
for allocation_date, minutes in _range_allocation_minutes(item_range.start_at, item_range.end_at, schedule).items():
|
||
row = target.setdefault(allocation_date, _empty_shift_minutes())
|
||
for key in SHIFT_BUCKETS:
|
||
row[key] += minutes.get(key, 0.0) * as_float(
|
||
getattr(item_range, "allocation_weight", 1.0)
|
||
)
|
||
return minutes_by_item
|
||
|
||
|
||
def _fallback_row(report, item) -> ReportAllocationDraft:
|
||
return ReportAllocationDraft(
|
||
report_id=getattr(report, "id", None),
|
||
report_item_id=getattr(item, "id", None),
|
||
attendance_point_name=str(getattr(report, "attendance_point_name", "") or ""),
|
||
employee_phone=str(getattr(report, "employee_phone", "") or ""),
|
||
allocation_date=getattr(report, "report_date"),
|
||
good_qty=_round_split_value(getattr(item, "good_qty", 0)),
|
||
defect_qty=_round_split_value(getattr(item, "defect_qty", 0)),
|
||
scrap_qty=_round_split_value(getattr(item, "scrap_qty", 0)),
|
||
changeover_count=_round_split_value(getattr(item, "changeover_count", 0)),
|
||
reference_wage=_round_split_value(_item_reference_wage(item)),
|
||
)
|
||
|
||
|
||
def _draft_from_minutes(report, item, allocation_date: date, minutes: dict[str, float], ratio: float) -> ReportAllocationDraft:
|
||
reference_wage = _item_reference_wage(item)
|
||
day_minutes = round2(minutes.get("day", 0))
|
||
overtime_minutes = round2(minutes.get("overtime", 0))
|
||
night_minutes = round2(minutes.get("night", 0))
|
||
return ReportAllocationDraft(
|
||
report_id=getattr(report, "id", None),
|
||
report_item_id=getattr(item, "id", None),
|
||
attendance_point_name=str(getattr(report, "attendance_point_name", "") or ""),
|
||
employee_phone=str(getattr(report, "employee_phone", "") or ""),
|
||
allocation_date=allocation_date,
|
||
day_minutes=day_minutes,
|
||
overtime_minutes=overtime_minutes,
|
||
night_minutes=night_minutes,
|
||
effective_minutes=round2(day_minutes + overtime_minutes + night_minutes),
|
||
good_qty=_scaled_split_value(getattr(item, "good_qty", 0), ratio),
|
||
defect_qty=_scaled_split_value(getattr(item, "defect_qty", 0), ratio),
|
||
scrap_qty=_scaled_split_value(getattr(item, "scrap_qty", 0), ratio),
|
||
changeover_count=_scaled_split_value(getattr(item, "changeover_count", 0), ratio),
|
||
reference_wage=_round_split_value(reference_wage * _decimal_value(ratio)),
|
||
)
|
||
|
||
|
||
SPLIT_RESIDUAL_FIELDS = (
|
||
"good_qty",
|
||
"defect_qty",
|
||
"scrap_qty",
|
||
"changeover_count",
|
||
"reference_wage",
|
||
)
|
||
|
||
|
||
def _item_split_targets(item) -> dict[str, float]:
|
||
return {
|
||
"good_qty": _round_split_value(getattr(item, "good_qty", 0)),
|
||
"defect_qty": _round_split_value(getattr(item, "defect_qty", 0)),
|
||
"scrap_qty": _round_split_value(getattr(item, "scrap_qty", 0)),
|
||
"changeover_count": _round_split_value(getattr(item, "changeover_count", 0)),
|
||
"reference_wage": _round_split_value(_item_reference_wage(item)),
|
||
}
|
||
|
||
|
||
def _balance_item_split_residuals(
|
||
drafts: list[ReportAllocationDraft],
|
||
targets: dict[str, float],
|
||
) -> list[ReportAllocationDraft]:
|
||
if not drafts:
|
||
return drafts
|
||
|
||
mutable_values = [
|
||
{field: _split_cents(getattr(draft, field)) for field in SPLIT_RESIDUAL_FIELDS}
|
||
for draft in drafts
|
||
]
|
||
|
||
for field in SPLIT_RESIDUAL_FIELDS:
|
||
target_cents = _split_cents(targets[field])
|
||
current_cents = sum(values[field] for values in mutable_values)
|
||
residual = target_cents - current_cents
|
||
if residual == 0:
|
||
continue
|
||
|
||
if residual > 0:
|
||
ordered_indexes = sorted(
|
||
range(len(drafts)),
|
||
key=lambda index: (
|
||
-as_float(drafts[index].effective_minutes),
|
||
drafts[index].allocation_date.isoformat(),
|
||
index,
|
||
),
|
||
)
|
||
else:
|
||
ordered_indexes = sorted(
|
||
range(len(drafts)),
|
||
key=lambda index: (
|
||
-mutable_values[index][field],
|
||
-as_float(drafts[index].effective_minutes),
|
||
drafts[index].allocation_date.isoformat(),
|
||
index,
|
||
),
|
||
)
|
||
|
||
step = 1 if residual > 0 else -1
|
||
remaining = abs(residual)
|
||
while remaining > 0:
|
||
changed = False
|
||
for index in ordered_indexes:
|
||
if step < 0 and mutable_values[index][field] <= 0:
|
||
continue
|
||
mutable_values[index][field] += step
|
||
remaining -= 1
|
||
changed = True
|
||
if remaining == 0:
|
||
break
|
||
if not changed:
|
||
break
|
||
|
||
return [
|
||
replace(
|
||
draft,
|
||
**{
|
||
field: mutable_values[index][field] / 100
|
||
for field in SPLIT_RESIDUAL_FIELDS
|
||
},
|
||
)
|
||
for index, draft in enumerate(drafts)
|
||
]
|
||
|
||
|
||
def build_report_allocation_drafts(report, schedule: WorkScheduleConfig | None = None) -> list[ReportAllocationDraft]:
|
||
items = list(getattr(report, "items", []) or [])
|
||
if not items:
|
||
return []
|
||
|
||
minutes_by_item = _device_minutes_by_item(report, items, schedule)
|
||
if minutes_by_item is None:
|
||
minutes_by_item = _range_minutes_by_item(report, items, schedule)
|
||
item_targets, bucket_targets = _allocation_targets(report, items, schedule)
|
||
_balance_minutes_to_targets(minutes_by_item, item_targets, bucket_targets)
|
||
_round_bucket_cells_to_targets(
|
||
minutes_by_item,
|
||
bucket_targets,
|
||
{id(item): index for index, item in enumerate(items)},
|
||
)
|
||
|
||
rows: list[ReportAllocationDraft] = []
|
||
for item in items:
|
||
item_minutes = minutes_by_item.get(id(item), {})
|
||
total_effective = sum(sum(minutes.get(key, 0.0) for key in SHIFT_BUCKETS) for minutes in item_minutes.values())
|
||
if total_effective <= 0:
|
||
rows.append(_fallback_row(report, item))
|
||
continue
|
||
item_rows: list[ReportAllocationDraft] = []
|
||
for allocation_date in sorted(item_minutes):
|
||
minutes = item_minutes[allocation_date]
|
||
effective = sum(minutes.get(key, 0.0) for key in SHIFT_BUCKETS)
|
||
if effective <= 0:
|
||
continue
|
||
item_rows.append(_draft_from_minutes(report, item, allocation_date, minutes, effective / total_effective))
|
||
rows.extend(_balance_item_split_residuals(item_rows, _item_split_targets(item)))
|
||
return rows
|
||
|
||
|
||
def allocation_summary_text(rows) -> str:
|
||
grouped: dict[date, dict[str, float]] = defaultdict(lambda: {key: 0.0 for key in SHIFT_BUCKETS})
|
||
for row in rows:
|
||
allocation_date = getattr(row, "allocation_date")
|
||
grouped[allocation_date]["day"] += as_float(getattr(row, "day_minutes", 0))
|
||
grouped[allocation_date]["overtime"] += as_float(getattr(row, "overtime_minutes", 0))
|
||
grouped[allocation_date]["night"] += as_float(getattr(row, "night_minutes", 0))
|
||
|
||
parts: list[str] = []
|
||
for allocation_date in sorted(grouped):
|
||
shift_text = "、".join(
|
||
f"{SHIFT_LABELS[key]}{format_hours(grouped[allocation_date].get(key, 0))}小时"
|
||
for key in SHIFT_BUCKETS
|
||
if round2(grouped[allocation_date].get(key, 0)) > 0
|
||
)
|
||
if shift_text:
|
||
parts.append(f"{allocation_date.isoformat()} {shift_text}")
|
||
return "；".join(parts)
|
||
|
||
|
||
def refresh_report_allocations(
|
||
db: Session,
|
||
report,
|
||
schedule: WorkScheduleConfig | None = None,
|
||
*,
|
||
commit: bool = False,
|
||
) -> list[ProductionReportAllocation]:
|
||
"""Rebuild allocation rows with metrics semantics, updating item allocation-derived fields."""
|
||
report_id = getattr(report, "id")
|
||
if isinstance(report_id, int):
|
||
db.execute(
|
||
select(ProductionReport.id)
|
||
.where(ProductionReport.id == report_id)
|
||
.with_for_update()
|
||
).scalar_one_or_none()
|
||
db.execute(delete(ProductionReportAllocation).where(ProductionReportAllocation.report_id == report_id))
|
||
rows = [
|
||
ProductionReportAllocation(
|
||
report_id=draft.report_id,
|
||
report_item_id=draft.report_item_id,
|
||
attendance_point_name=draft.attendance_point_name,
|
||
employee_phone=draft.employee_phone,
|
||
allocation_date=draft.allocation_date,
|
||
day_minutes=draft.day_minutes,
|
||
overtime_minutes=draft.overtime_minutes,
|
||
night_minutes=draft.night_minutes,
|
||
effective_minutes=draft.effective_minutes,
|
||
good_qty=draft.good_qty,
|
||
defect_qty=draft.defect_qty,
|
||
scrap_qty=draft.scrap_qty,
|
||
changeover_count=draft.changeover_count,
|
||
reference_wage=draft.reference_wage,
|
||
)
|
||
for draft in build_report_allocation_drafts(report, schedule)
|
||
]
|
||
db.add_all(rows)
|
||
db.flush()
|
||
if commit:
|
||
db.commit()
|
||
return rows
|