UPDATE

2026-04-24 18:34:17 +03:30
parent 24ed5776bc
commit f7dc05dc9e
22 changed files with 3730 additions and 139 deletions
@@ -5,6 +5,7 @@
 import json
 import logging

+from django.apps import apps
 from django.db import transaction
 from irrigation.models import IrrigationMethod
 from irrigation.evapotranspiration import calculate_forecast_water_needs, resolve_crop_profile, resolve_kc
@@ -27,23 +28,171 @@ KB_NAME = "irrigation"
 SERVICE_ID = "irrigation"

 DEFAULT_IRRIGATION_PROMPT = (
-    "بر اساس محاسبات نهایی تبخیر-تعرق و نیاز آبی که در ورودی آمده، "
-    "یک برنامه آبیاری قابل‌فهم برای کشاورز تولید کن. "
-    "پاسخ حتماً به فرمت JSON با ساختار زیر باشد:\n"
-    '{\n'
-    '    "plan": {\n'
-    '        "frequencyPerWeek": <int>,\n'
-    '        "durationMinutes": <int>,\n'
-    '        "bestTimeOfDay": "<str>",\n'
-    '        "moistureLevel": <int>,\n'
-    '        "warning": "<str>"\n'
-    '    }\n'
-    '}\n'
-    "فقط JSON خروجی بده، بدون توضیح اضافی. "
-    "از انجام هرگونه محاسبه عددی جدید خودداری کن و فقط از داده‌های ساختاریافته ورودی استفاده کن."
+    "از محاسبات FAO-56 و خروجی بهینه ساز شبیه سازی برای ساخت توصیه آبیاری استفاده کن. "
+    "اگر بلوک [خروجی بهینه ساز شبیه سازی] وجود داشت، همان را مرجع اصلی اعداد قرار بده. "
+    "پاسخ فقط JSON معتبر با کلید sections باشد و عدد جدید متناقض نساز."
 )


+def _get_optimizer():
+    return apps.get_app_config("crop_simulation").get_recommendation_optimizer()
+
+
+def _unique_items(items: list[str]) -> list[str]:
+    seen = set()
+    output = []
+    for item in items:
+        normalized = (item or "").strip()
+        if not normalized or normalized in seen:
+            continue
+        seen.add(normalized)
+        output.append(normalized)
+    return output
+
+
+def _find_section(sections: list[dict], section_type: str) -> dict | None:
+    for section in sections:
+        if isinstance(section, dict) and section.get("type") == section_type:
+            return section
+    return None
+
+
+def _build_irrigation_fallback(
+    *,
+    optimized_result: dict | None,
+    daily_water_needs: list[dict],
+) -> dict:
+    if optimized_result:
+        recommended = optimized_result["recommended_strategy"]
+        content = (
+            f"{recommended['events']} نوبت آبیاری با حدود "
+            f"{recommended['amount_per_event_mm']} میلی متر در هر نوبت اجرا شود."
+        )
+        list_items = [
+            f"در بازه اعتبار حدود {recommended['total_irrigation_mm']} میلی متر آب توزیع شود.",
+            f"نوبت های پیشنهادی: {', '.join(recommended['event_dates']) or 'بر اساس پایش روزانه مزرعه'}",
+            f"رطوبت خاک نزدیک {recommended['moisture_target_percent']} درصد نگه داشته شود.",
+        ]
+        warning = optimized_result.get("alternatives", [])
+        warning_text = (
+            f"اگر شرایط مزرعه تغییر کرد، سناریوی جایگزین {warning[0]['label']} هم قابل بررسی است."
+            if warning
+            else "در صورت تغییر ناگهانی بارش یا باد، برنامه را دوباره ارزیابی کنید."
+        )
+        explanation = " ".join(recommended.get("reasoning", []))
+        return {
+            "sections": [
+                {
+                    "type": "recommendation",
+                    "title": "برنامه آبیاری بهینه",
+                    "icon": "droplet",
+                    "content": content,
+                    "frequency": f"{recommended['events']} نوبت در بازه اعتبار",
+                    "amount": (
+                        f"{recommended['amount_per_event_mm']} میلی متر در هر نوبت "
+                        f"(جمع کل {recommended['total_irrigation_mm']} میلی متر)"
+                    ),
+                    "timing": recommended["timing"],
+                    "validityPeriod": recommended["validity_period"],
+                    "expandableExplanation": explanation,
+                },
+                {
+                    "type": "list",
+                    "title": "اقدامات اجرایی",
+                    "icon": "list",
+                    "items": _unique_items(list_items),
+                },
+                {
+                    "type": "warning",
+                    "title": "هشدار آبیاری",
+                    "icon": "alert-triangle",
+                    "content": warning_text,
+                },
+            ]
+        }
+
+    total_mm = round(sum(float(item.get("gross_irrigation_mm", 0.0) or 0.0) for item in daily_water_needs), 2)
+    return {
+        "sections": [
+            {
+                "type": "recommendation",
+                "title": "برنامه آبیاری پیشنهادی",
+                "icon": "droplet",
+                "content": "پایش رطوبت خاک ادامه پیدا کند و برنامه آبیاری بر اساس نیاز روزانه تنظیم شود.",
+                "frequency": "بر اساس پایش روزانه",
+                "amount": f"جمع نیاز تخمینی این بازه حدود {total_mm} میلی متر است.",
+                "timing": "اوایل صبح یا نزدیک غروب",
+                "validityPeriod": "معتبر برای 3 روز آینده",
+                "expandableExplanation": "به دلیل محدود بودن داده ها، توصیه با اتکا به نیاز آبی روزانه ساخته شده است.",
+            },
+            {
+                "type": "list",
+                "title": "اقدامات اجرایی",
+                "icon": "list",
+                "items": [
+                    "قبل از هر نوبت آبیاری رطوبت خاک سطحی را دوباره بررسی کنید.",
+                    "اگر بارش موثر رخ داد، نوبت بعدی را به تعویق بیندازید.",
+                ],
+            },
+            {
+                "type": "warning",
+                "title": "هشدار آبیاری",
+                "icon": "alert-triangle",
+                "content": "با تغییر دما یا بارش پیش بینی شده، برنامه فعلی باید بازبینی شود.",
+            },
+        ]
+    }
+
+
+def _merge_irrigation_response(
+    *,
+    parsed_result: dict,
+    optimized_result: dict | None,
+    daily_water_needs: list[dict],
+) -> dict:
+    fallback = _build_irrigation_fallback(
+        optimized_result=optimized_result,
+        daily_water_needs=daily_water_needs,
+    )
+    if not isinstance(parsed_result, dict):
+        return fallback
+
+    sections = parsed_result.get("sections")
+    if not isinstance(sections, list):
+        return fallback
+
+    recommendation = _find_section(sections, "recommendation") or {}
+    list_section = _find_section(sections, "list") or {}
+    warning_section = _find_section(sections, "warning") or {}
+
+    fallback_recommendation = fallback["sections"][0]
+    fallback_list = fallback["sections"][1]
+    fallback_warning = fallback["sections"][2]
+
+    merged_recommendation = {**recommendation, **fallback_recommendation}
+    merged_recommendation["expandableExplanation"] = (
+        recommendation.get("expandableExplanation")
+        or fallback_recommendation["expandableExplanation"]
+    )
+    merged_recommendation["content"] = recommendation.get("content") or fallback_recommendation["content"]
+    merged_recommendation["title"] = recommendation.get("title") or fallback_recommendation["title"]
+
+    merged_list = {
+        **fallback_list,
+        **list_section,
+        "items": _unique_items(
+            list(list_section.get("items", [])) + list(fallback_list["items"])
+        )[:5],
+    }
+    merged_warning = {
+        **fallback_warning,
+        **warning_section,
+        "content": warning_section.get("content") or fallback_warning["content"],
+    }
+
+    return {"sections": [merged_recommendation, merged_list, merged_warning]}
+
+
 def _resolve_irrigation_method(
    sensor: SensorData | None,
    irrigation_method_name: str | None,
@@ -131,6 +280,7 @@ def get_irrigation_recommendation(
    active_kc = resolve_kc(crop_profile, growth_stage=growth_stage)
    forecasts = []
    daily_water_needs = []
+    optimized_result = None
    if sensor is not None:
        forecasts = list(
            WeatherForecast.objects.filter(location=sensor.center_location, forecast_date__isnull=False)
@@ -148,6 +298,15 @@ def get_irrigation_recommendation(
            growth_stage=growth_stage,
            irrigation_efficiency_percent=efficiency_percent,
        )
+        if plant is not None and forecasts:
+            optimized_result = _get_optimizer().optimize_irrigation(
+                sensor=sensor,
+                plant=plant,
+                forecasts=forecasts,
+                daily_water_needs=daily_water_needs,
+                growth_stage=growth_stage,
+                irrigation_method=irrigation_method,
+            )

    context = build_rag_context(
        user_query, sensor_uuid, config=cfg, limit=limit, kb_name=KB_NAME, service_id=SERVICE_ID,
@@ -179,6 +338,11 @@ def get_irrigation_recommendation(
            f"Kc مورد استفاده: {active_kc}\n"
            + "\n".join(schedule_lines)
        )
+    if optimized_result is not None:
+        extra_parts.append(
+            "[خروجی بهینه ساز شبیه سازی]\n"
+            + optimized_result["context_text"]
+        )
    if extra_parts:
        context = "\n\n---\n\n".join(extra_parts) + ("\n\n---\n\n" + context if context else "")

@@ -212,13 +376,12 @@ def get_irrigation_recommendation(
        raw = response.choices[0].message.content.strip()
    except Exception as exc:
        logger.error("Irrigation recommendation error for %s: %s", sensor_uuid, exc)
-        result = {
-            "irrigation_needed": None,
-            "amount_mm": None,
-            "reason": f"خطا در دریافت توصیه: {exc}",
-            "next_check_date": None,
-            "raw_response": None,
-        }
+        result = _build_irrigation_fallback(
+            optimized_result=optimized_result,
+            daily_water_needs=daily_water_needs,
+        )
+        result["error"] = f"خطا در دریافت توصیه: {exc}"
+        result["raw_response"] = None
        _fail_audit_log(
            audit_log,
            str(exc),
@@ -232,18 +395,20 @@ def get_irrigation_recommendation(
            cleaned = cleaned.strip("`").removeprefix("json").strip()
        result = json.loads(cleaned)
    except (json.JSONDecodeError, ValueError):
-        result = {
-            "plan": {
-                "warning": raw,
-            },
-        }
+        result = {}

+    result = _merge_irrigation_response(
+        parsed_result=result,
+        optimized_result=optimized_result,
+        daily_water_needs=daily_water_needs,
+    )
    result["raw_response"] = raw
    result["water_balance"] = {
        "daily": daily_water_needs,
        "crop_profile": crop_profile,
        "active_kc": active_kc,
    }
+    result["simulation_optimizer"] = optimized_result
    result["selected_irrigation_method"] = (
        {
            "id": irrigation_method.id,