Интегрирован wesp в сайт

WESP_REL/app/services/recipe_update_service.py

@@ -0,0 +1,529 @@
+"""
+Обновление рецепта (PUT): логика перенесена из legacy/proga_monolith.update_recipe.
+
+Sync: listeners + явные enqueue для recipe/ingredient/unloading_group (в т.ч. deleted_* из UI).
+"""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from sqlalchemy import select
+
+from app import db
+from app.models import Component, Ingredient, Recipe, UnloadingGroup
+from app.services.recipe_calculator import calculate_recipe
+from app.services.sync_manager import enqueue_sync_queue_task
+
+logger = logging.getLogger(__name__)
+
+
+class RecipeUpdateError(Exception):
+    def __init__(self, message: str, status_code: int = 400):
+        self.message = message
+        self.status_code = status_code
+        super().__init__(message)
+
+
+def _now() -> datetime:
+    return datetime.now()
+
+
+def _ing_weight_per_head(ing: dict) -> float:
+    for key in ("weightPerHead", "weight_per_head"):
+        if key in ing and ing[key] is not None and ing[key] != "":
+            try:
+                return float(ing[key])
+            except (TypeError, ValueError):
+                continue
+    return 0.0
+
+
+def _resolve_component(ing: dict) -> Optional[Component]:
+    component_id = ing.get("component_id")
+    component = None
+    if component_id:
+        component = db.session.get(Component, str(component_id))
+    if not component:
+        name = ing.get("name")
+        if name:
+            component = db.session.execute(
+                select(Component).where(Component.name == name, Component.is_deleted.is_(False))
+            ).scalar_one_or_none()
+    return component
+
+
+def _validate_strict_header(data: dict) -> None:
+    """Как в монолите: name, heads_count, mixing_time обязательны."""
+    for key in ("name", "heads_count", "mixing_time"):
+        if key not in data:
+            raise RecipeUpdateError(f'Отсутствует обязательное поле "{key}"', 400)
+
+
+def _enqueue_recipe_children_sync(recipe_id: str) -> None:
+    """
+    После сохранения рецепта — update в sync для всех активных ингредиентов и групп.
+
+    ORM-listeners ставят задачи только на изменённые строки; reorder ингредиентов и
+    частичные правки групп выгрузки иначе не доходят до peer (баготест #5–#6).
+
+    Через pending-очередь session.info (как after_insert/after_update), а не прямой
+    enqueue_sync_queue_task — иначе при autoflush дубли в sync_queue (SQLite).
+    """
+    from app.models import _SYNC_ENQUEUE_INFO_KEY
+
+    pending = db.session.info.setdefault(_SYNC_ENQUEUE_INFO_KEY, [])
+    with db.session.no_autoflush:
+        active_ingredients = db.session.execute(
+            select(Ingredient).where(
+                Ingredient.recipe_id == recipe_id,
+                Ingredient.is_deleted.is_(False),
+            )
+        ).scalars().all()
+        active_groups = db.session.execute(
+            select(UnloadingGroup).where(
+                UnloadingGroup.recipe_id == recipe_id,
+                UnloadingGroup.is_deleted.is_(False),
+            )
+        ).scalars().all()
+    for ing in active_ingredients:
+        pending.append(("ingredient", str(ing.id), "update", 3, None))
+    for grp in active_groups:
+        pending.append(("unloading_group", str(grp.id), "update", 3, None))
+
+
+def update_recipe_from_payload(recipe_id: str, data: Optional[dict]) -> Dict[str, Any]:
+    """
+    Выполняет обновление рецепта в текущей сессии (без commit).
+    Возвращает dict для jsonify: message, id, stats (как в легаси).
+    """
+    if not data:
+        raise RecipeUpdateError("Данные не предоставлены", 400)
+
+    _validate_strict_header(data)
+
+    logger.info(
+        "[RECIPES-DB] update_recipe_from_payload start id=%s name_in_payload=%s",
+        recipe_id,
+        (data.get("name") or "")[:80],
+    )
+
+    recipe = db.session.get(Recipe, recipe_id)
+    if recipe is None:
+        raise RecipeUpdateError("Рецепт не найден", 404)
+    if getattr(recipe, "is_deleted", False):
+        raise RecipeUpdateError("Рецепт удалён", 404)
+
+    try:
+        recipe.name = data["name"]
+        recipe.heads_per_trip = int(data["heads_count"])
+        recipe.mixing_time = int(data["mixing_time"])
+    except (TypeError, ValueError) as e:
+        raise RecipeUpdateError(f"Некорректные числовые поля рецепта: {e}", 400) from e
+
+    recipe.trip_percent = float(data.get("trip_percent", 100) or 100)
+    if "dry_matter_locked" in data:
+        recipe.dry_matter_locked = bool(data.get("dry_matter_locked"))
+    if "unloading_link_broken" in data:
+        recipe.unloading_link_broken = bool(data.get("unloading_link_broken"))
+    if "target_component_id" in data:
+        recipe.target_component_id = data.get("target_component_id")
+
+    recipe.updated_by = "system"
+    recipe.updated_at = _now()
+    recipe.version = (recipe.version or 1) + 1
+
+    existing_rows = db.session.execute(
+        select(Ingredient).where(
+            Ingredient.recipe_id == recipe_id,
+            Ingredient.is_deleted.is_(False),
+        )
+    ).scalars().all()
+    existing_ingredients: Dict[int, Ingredient] = {ing.order: ing for ing in existing_rows}
+    existing_ingredients_by_id: Dict[str, Ingredient] = {str(ing.id): ing for ing in existing_rows}
+
+    existing_grows = db.session.execute(
+        select(UnloadingGroup).where(
+            UnloadingGroup.recipe_id == recipe_id,
+            UnloadingGroup.is_deleted.is_(False),
+        )
+    ).scalars().all()
+    existing_groups: Dict[int, UnloadingGroup] = {g.order: g for g in existing_grows}
+    existing_groups_by_id: Dict[str, UnloadingGroup] = {str(g.id): g for g in existing_grows}
+
+    def _delete_ingredient_row(cur: Ingredient) -> None:
+        ing_id = str(cur.id)
+        cur.soft_delete(deleted_by_user="system")
+        enqueue_sync_queue_task("ingredient", ing_id, "delete", priority=1)
+        existing_ingredients_by_id.pop(ing_id, None)
+        for ord_k, row in list(existing_ingredients.items()):
+            if str(row.id) == ing_id:
+                existing_ingredients.pop(ord_k, None)
+
+    def _delete_group_row(cur: UnloadingGroup) -> None:
+        gid = str(cur.id)
+        cur.soft_delete(deleted_by_user="system")
+        enqueue_sync_queue_task("unloading_group", gid, "delete", priority=1)
+        existing_groups_by_id.pop(gid, None)
+        for ord_k, row in list(existing_groups.items()):
+            if str(row.id) == gid:
+                existing_groups.pop(ord_k, None)
+
+    for raw_id in data.get("deleted_ingredient_ids") or []:
+        ing_id = str(raw_id or "").strip()
+        if not ing_id:
+            continue
+        cur = existing_ingredients_by_id.get(ing_id) or db.session.get(Ingredient, ing_id)
+        if cur is None or str(cur.recipe_id) != str(recipe_id) or cur.is_deleted:
+            continue
+        _delete_ingredient_row(cur)
+
+    for raw_id in data.get("deleted_unloading_group_ids") or []:
+        gid = str(raw_id or "").strip()
+        if not gid:
+            continue
+        cur = existing_groups_by_id.get(gid) or db.session.get(UnloadingGroup, gid)
+        if cur is None or str(cur.recipe_id) != str(recipe_id) or cur.is_deleted:
+            continue
+        _delete_group_row(cur)
+
+    recipe_is_locked = bool(getattr(recipe, "dry_matter_locked", False))
+    calc_by_order: Dict[int, Dict[str, Any]] = {}
+    group_calc_by_order: Dict[int, Dict[str, Any]] = {}
+
+    ingredients_in: List[dict] = [x for x in (data.get("ingredients") or []) if isinstance(x, dict)]
+    groups_in: List[dict] = [x for x in (data.get("unloading_groups") or []) if isinstance(x, dict)]
+
+    if recipe_is_locked:
+        try:
+            heads_count_calc = int(data.get("heads_count") or recipe.heads_per_trip or 0)
+            trip_percent_calc = float(
+                data.get("trip_percent", recipe.trip_percent or 100) or 100
+            )
+
+            dm_component_ids = [
+                ing.get("component_id")
+                for ing in ingredients_in
+                if ing.get("component_id")
+            ]
+            dm_components = []
+            if dm_component_ids:
+                dm_components = (
+                    db.session.execute(
+                        select(Component).where(
+                            Component.id.in_(dm_component_ids),
+                            Component.is_deleted.is_(False),
+                        )
+                    )
+                    .scalars()
+                    .all()
+                )
+            dm_by_component_id = {c.id: float(c.dry_matter or 0) for c in dm_components}
+
+            calc_ingredients_payload: List[dict] = []
+            ing_orders: List[int] = []
+            for idx, ing in enumerate(ingredients_in, 1):
+                order_value = int(ing.get("order", idx))
+                ing_orders.append(order_value)
+
+                dm_percent = ing.get("dry_matter")
+                if dm_percent is None:
+                    dm_percent = 0
+                try:
+                    dm_percent = float(dm_percent)
+                except (TypeError, ValueError):
+                    dm_percent = 0.0
+
+                if dm_percent <= 0:
+                    cid = ing.get("component_id")
+                    try:
+                        dm_percent = float(
+                            dm_by_component_id.get(str(cid), 0) if cid else 0
+                        )
+                    except (TypeError, ValueError):
+                        dm_percent = 0.0
+
+                dm_per_head = (
+                    ing.get("dry_matter_per_head")
+                    if ing.get("dry_matter_per_head") is not None
+                    else ing.get("dryMatterPerHead")
+                )
+                try:
+                    dm_per_head = float(dm_per_head) if dm_per_head is not None else 0.0
+                except (TypeError, ValueError):
+                    dm_per_head = 0.0
+
+                if dm_per_head <= 0 and recipe_is_locked and order_value in existing_ingredients:
+                    old_ing = existing_ingredients[order_value]
+                    if (
+                        old_ing.dry_matter_per_head is not None
+                        and old_ing.dry_matter_per_head > 0
+                    ):
+                        dm_per_head = float(old_ing.dry_matter_per_head)
+                    else:
+                        old_wph = float(old_ing.weight_per_head or 0)
+                        old_dm = float(old_ing.dry_matter or 0)
+                        if old_dm > 0 and old_wph > 0:
+                            dm_per_head = old_wph * (old_dm / 100.0)
+                        else:
+                            raise RecipeUpdateError(
+                                f"Не удалось восстановить СВ/гол для ингредиента (order={order_value}). "
+                                "Убедитесь, что отправлено поле dry_matter_per_head или ингредиент существует в БД.",
+                                400,
+                            )
+
+                if dm_per_head <= 0 and dm_percent > 0 and not recipe_is_locked:
+                    try:
+                        wph = float(
+                            ing.get("weight_per_head")
+                            or ing.get("weightPerHead")
+                            or 0
+                        )
+                    except (TypeError, ValueError):
+                        wph = 0.0
+                    if wph > 0:
+                        dm_per_head = wph * (dm_percent / 100.0)
+
+                if dm_percent <= 0:
+                    raise RecipeUpdateError(
+                        f"СВ,% (dry_matter) должно быть > 0 для расчета (order={order_value})",
+                        400,
+                    )
+
+                calc_ingredients_payload.append(
+                    {
+                        "component_id": ing.get("component_id"),
+                        "dryMatterPerHead": dm_per_head,
+                        "dryMatter": dm_percent,
+                    }
+                )
+
+            calc_groups_payload: List[dict] = []
+            group_orders: List[int] = []
+            for idx, group in enumerate(groups_in, 1):
+                order_value = int(group.get("order", idx))
+                group_orders.append(order_value)
+                calc_groups_payload.append(
+                    {
+                        "distributionType": group.get("distribution_type", "percent"),
+                        "value": float(group.get("value") or 0),
+                    }
+                )
+
+            result_calc = calculate_recipe(
+                ingredients=calc_ingredients_payload,
+                heads_count=heads_count_calc,
+                trip_percent=trip_percent_calc,
+                unloading_groups=calc_groups_payload,
+                component_dry_matter_map=None,
+                calculate_from_dry_matter=True,
+            )
+
+            for order_value, calc in zip(
+                ing_orders, result_calc.get("ingredients", [])
+            ):
+                calc_by_order[order_value] = calc
+            for order_value, calcg in zip(
+                group_orders, result_calc.get("unloadingGroups", [])
+            ):
+                group_calc_by_order[order_value] = calcg
+        except RecipeUpdateError:
+            raise
+        except Exception as e:
+            logger.error(
+                "[RECIPE-UPDATE] Ошибка серверного расчета при замке СВ: %s",
+                e,
+                exc_info=True,
+            )
+            raise RecipeUpdateError(
+                f"Ошибка расчета при замке СВ: {str(e)}", 400
+            ) from e
+
+    seen_ingredient_ids: set[str] = set()
+    seen_orders: set[int] = set()
+    for idx, ing in enumerate(ingredients_in, 1):
+        order_value = int(ing.get("order", idx))
+        component = _resolve_component(ing)
+        if not component:
+            raise RecipeUpdateError(
+                f'Компонент не найден (id="{ing.get("component_id", "")}", '
+                f'name="{ing.get("name", "")}"). Проверьте, что компонент существует в базе данных.',
+                400,
+            )
+
+        ing_id = str(ing.get("id") or "").strip()
+        cur = None
+        if ing_id and ing_id in existing_ingredients_by_id:
+            cur = existing_ingredients_by_id[ing_id]
+        elif order_value in existing_ingredients:
+            cur = existing_ingredients[order_value]
+
+        if cur is not None:
+            cur.name = component.name
+            if recipe_is_locked and order_value in calc_by_order:
+                cur.weight_per_head = float(
+                    calc_by_order[order_value].get("weightPerHead", 0) or 0
+                )
+                cur.amount = float(calc_by_order[order_value].get("tripWeight", 0) or 0)
+                dm_per_head_to_save = float(
+                    calc_by_order[order_value].get("dryMatterPerHead", 0) or 0
+                )
+                cur.dry_matter_per_head = (
+                    dm_per_head_to_save if dm_per_head_to_save > 0 else None
+                )
+            else:
+                cur.weight_per_head = _ing_weight_per_head(ing)
+                cur.amount = float(ing.get("amount", 0) or 0)
+                cur_dm = float(ing.get("dry_matter", component.dry_matter) or 0)
+                cur_wph = float(cur.weight_per_head or 0)
+                cur.dry_matter_per_head = (
+                    cur_wph * (cur_dm / 100.0) if (cur_dm > 0 and cur_wph > 0) else None
+                )
+            cur.dry_matter = float(ing.get("dry_matter", component.dry_matter) or 0)
+            cur.component_id = component.id
+            cur.order = order_value
+            cur.updated_by = "system"
+            cur.updated_at = _now()
+            cur.version = (cur.version or 1) + 1
+            existing_ingredients[order_value] = cur
+            existing_ingredients_by_id[str(cur.id)] = cur
+            seen_ingredient_ids.add(str(cur.id))
+        else:
+            new_wph = _ing_weight_per_head(ing)
+            new_amount = float(ing.get("amount", 0) or 0)
+            new_dm_per_head = None
+
+            if recipe_is_locked and order_value in calc_by_order:
+                new_wph = float(calc_by_order[order_value].get("weightPerHead", 0) or 0)
+                new_amount = float(calc_by_order[order_value].get("tripWeight", 0) or 0)
+                new_dm_per_head = float(
+                    calc_by_order[order_value].get("dryMatterPerHead", 0) or 0
+                ) or None
+            elif recipe_is_locked:
+                raw = ing.get("dry_matter_per_head") or ing.get("dryMatterPerHead")
+                new_dm_per_head = float(raw) if raw not in (None, "") else None
+            else:
+                cur_dm = float(ing.get("dry_matter", component.dry_matter) or 0)
+                new_dm_per_head = (
+                    new_wph * (cur_dm / 100.0) if (cur_dm > 0 and new_wph > 0) else None
+                )
+
+            new_ingredient = Ingredient(
+                name=component.name,
+                weight_per_head=new_wph,
+                amount=new_amount,
+                dry_matter=float(ing.get("dry_matter", component.dry_matter) or 0),
+                dry_matter_per_head=new_dm_per_head,
+                component_id=component.id,
+                order=order_value,
+                recipe_id=recipe_id,
+                created_by="system",
+                updated_by="system",
+            )
+            db.session.add(new_ingredient)
+            db.session.flush()
+            existing_ingredients[order_value] = new_ingredient
+            existing_ingredients_by_id[str(new_ingredient.id)] = new_ingredient
+            seen_ingredient_ids.add(str(new_ingredient.id))
+
+        seen_orders.add(order_value)
+
+    for cur in list(existing_ingredients_by_id.values()):
+        if str(cur.id) not in seen_ingredient_ids:
+            _delete_ingredient_row(cur)
+
+    seen_group_ids: set[str] = set()
+    seen_group_orders: set[int] = set()
+    for idx, group in enumerate(groups_in, 1):
+        order_value = int(group.get("order", idx))
+        try:
+            gname = group["name"]
+            gdist = group["distribution_type"]
+            gval = float(group["value"])
+        except (KeyError, TypeError, ValueError) as e:
+            raise RecipeUpdateError(
+                f"Некорректная группа выгрузки (order={order_value}): {e}", 400
+            ) from e
+
+        group_id = str(group.get("id") or "").strip()
+        cur = None
+        if group_id and group_id in existing_groups_by_id:
+            cur = existing_groups_by_id[group_id]
+        elif order_value in existing_groups:
+            cur = existing_groups[order_value]
+
+        if cur is not None:
+            cur.name = gname
+            cur.distribution_type = gdist
+            cur.value = gval
+            if recipe_is_locked and order_value in group_calc_by_order:
+                cur.weight = float(
+                    group_calc_by_order[order_value].get("calculatedWeight", 0) or 0
+                )
+            else:
+                w = group.get("weight")
+                cur.weight = float(w) if w not in (None, "") else None
+            cur.order = order_value
+            cur.updated_by = "system"
+            cur.updated_at = _now()
+            cur.version = (cur.version or 1) + 1
+            existing_groups[order_value] = cur
+            existing_groups_by_id[str(cur.id)] = cur
+            seen_group_ids.add(str(cur.id))
+        else:
+            weight_val: Optional[float]
+            if recipe_is_locked and order_value in group_calc_by_order:
+                weight_val = float(
+                    group_calc_by_order[order_value].get("calculatedWeight", 0) or 0
+                )
+            else:
+                w = group.get("weight")
+                weight_val = float(w) if w not in (None, "") else None
+
+            new_group = UnloadingGroup(
+                name=gname,
+                distribution_type=gdist,
+                value=gval,
+                weight=weight_val,
+                order=order_value,
+                recipe_id=recipe_id,
+                created_by="system",
+                updated_by="system",
+            )
+            db.session.add(new_group)
+            db.session.flush()
+            existing_groups[order_value] = new_group
+            existing_groups_by_id[str(new_group.id)] = new_group
+            seen_group_ids.add(str(new_group.id))
+
+        seen_group_orders.add(order_value)
+
+    for cur in list(existing_groups_by_id.values()):
+        if str(cur.id) not in seen_group_ids:
+            _delete_group_row(cur)
+
+    _enqueue_recipe_children_sync(recipe_id)
+    enqueue_sync_queue_task("recipe", recipe_id, "update", priority=3)
+
+    logger.info(
+        "[RECIPES-DB] update_recipe_from_payload session_ready id=%s name=%s version=%s "
+        "ingredients_payload=%s groups_payload=%s",
+        recipe_id,
+        (recipe.name or "")[:80],
+        recipe.version,
+        len(ingredients_in),
+        len(groups_in),
+    )
+
+    stats = {
+        "changed_components": 0,
+        "affected_recipes": 0,
+        "recalculated_recipes": 0,
+        "updated_ingredients": 0,
+        "updated_unloading_groups": 0,
+        "skipped_recipes": 0,
+    }
+
+    return {"message": "Сохранено", "id": recipe_id, "stats": stats}