UPDATE

irrigation_recommendation/serializers.py

@@ -8,56 +8,31 @@ class IrrigationFarmDataSerializer(serializers.Serializer):
 
 
 class IrrigationRecommendRequestSerializer(serializers.Serializer):
-    farm_uuid = serializers.UUIDField(required=True)
-    crop_id = serializers.CharField(required=False, allow_blank=True)
-    farm_data = IrrigationFarmDataSerializer(required=False)
-    soilType = serializers.CharField(required=False, allow_blank=True)
-    waterQuality = serializers.CharField(required=False, allow_blank=True)
-    climateZone = serializers.CharField(required=False, allow_blank=True)
+    farm_uuid = serializers.UUIDField(required=True, help_text="UUID مزرعه برای دریافت توصیه آبیاری.")
+    plant_name = serializers.CharField(required=False, allow_blank=True, help_text="نام محصول یا گیاه.")
+    growth_stage = serializers.CharField(required=False, allow_blank=True, help_text="مرحله رشد گیاه.")
+    irrigation_method_name = serializers.CharField(required=False, allow_blank=True, help_text="نام روش آبیاری انتخابی.")
 
 
-class IrrigationPlanSerializer(serializers.Serializer):
-    frequencyPerWeek = serializers.CharField(required=False, allow_blank=True)
-    durationMinutes = serializers.CharField(required=False, allow_blank=True)
-    bestTimeOfDay = serializers.CharField(required=False, allow_blank=True)
-    moistureLevel = serializers.CharField(required=False, allow_blank=True)
-    warning = serializers.CharField(required=False, allow_blank=True)
+class WaterStressRequestSerializer(serializers.Serializer):
+    farm_uuid = serializers.UUIDField(required=True, help_text="UUID مزرعه برای محاسبه تنش آبی.")
+    sensor_uuid = serializers.UUIDField(required=False, help_text="UUID سنسور برای فیلتر اختیاری.")
 
 
-class IrrigationWaterBalanceDaySerializer(serializers.Serializer):
-    forecast_date = serializers.CharField(required=False, allow_blank=True)
-    et0_mm = serializers.FloatField(required=False)
-    etc_mm = serializers.FloatField(required=False)
-    effective_rainfall_mm = serializers.FloatField(required=False)
-    gross_irrigation_mm = serializers.FloatField(required=False)
-    irrigation_timing = serializers.CharField(required=False, allow_blank=True)
-
-
-class IrrigationCropProfileSerializer(serializers.Serializer):
-    kc_initial = serializers.FloatField(required=False)
-    kc_mid = serializers.FloatField(required=False)
-    kc_end = serializers.FloatField(required=False)
-
-
-class IrrigationWaterBalanceSerializer(serializers.Serializer):
-    daily = IrrigationWaterBalanceDaySerializer(many=True, required=False)
-    crop_profile = IrrigationCropProfileSerializer(required=False)
-    active_kc = serializers.FloatField(required=False)
+class IrrigationMethodSerializer(serializers.Serializer):
+    id = serializers.IntegerField(required=False)
+    name = serializers.CharField(required=False, allow_blank=True)
+    category = serializers.CharField(required=False, allow_blank=True)
+    description = serializers.CharField(required=False, allow_blank=True)
+    water_efficiency_percent = serializers.FloatField(required=False)
+    water_pressure_required = serializers.CharField(required=False, allow_blank=True)
+    flow_rate = serializers.CharField(required=False, allow_blank=True)
+    coverage_area = serializers.CharField(required=False, allow_blank=True)
+    soil_type = serializers.CharField(required=False, allow_blank=True)
+    climate_suitability = serializers.CharField(required=False, allow_blank=True)
+    created_at = serializers.DateTimeField(required=False)
+    updated_at = serializers.DateTimeField(required=False)
 
 
 class IrrigationRecommendResponseDataSerializer(serializers.Serializer):
-    plan = IrrigationPlanSerializer(required=False)
-    raw_response = serializers.CharField(required=False, allow_blank=True)
-    water_balance = IrrigationWaterBalanceSerializer(required=False)
-    status = serializers.CharField(required=False, allow_blank=True)
-
-
-class IrrigationTaskSubmitDataSerializer(serializers.Serializer):
-    task_id = serializers.CharField(required=False, allow_blank=True)
-    status = serializers.CharField(required=False, allow_blank=True)
-
-
-class IrrigationTaskStatusDataSerializer(serializers.Serializer):
-    task_id = serializers.CharField(required=False, allow_blank=True)
-    status = serializers.CharField(required=False, allow_blank=True)
-    result = IrrigationRecommendResponseDataSerializer(required=False)
+    sections = serializers.ListField(child=serializers.DictField(), read_only=True)

irrigation_recommendation/tests.py

@@ -0,0 +1,141 @@
+from unittest.mock import patch
+
+from django.contrib.auth import get_user_model
+from django.test import TestCase
+from rest_framework.test import APIRequestFactory, force_authenticate
+
+from external_api_adapter.adapter import AdapterResponse
+from farm_hub.models import FarmHub, FarmType
+
+from .views import IrrigationMethodListView, WaterStressView
+
+
+class WaterStressViewTests(TestCase):
+    def setUp(self):
+        self.factory = APIRequestFactory()
+        self.user = get_user_model().objects.create_user(
+            username="farmer",
+            password="secret123",
+            email="farmer@example.com",
+            phone_number="09120000000",
+        )
+        self.other_user = get_user_model().objects.create_user(
+            username="other-farmer",
+            password="secret123",
+            email="other@example.com",
+            phone_number="09120000001",
+        )
+        self.farm_type = FarmType.objects.create(name="زراعی")
+        self.farm = FarmHub.objects.create(owner=self.user, farm_type=self.farm_type, name="Farm 1")
+        self.other_farm = FarmHub.objects.create(owner=self.other_user, farm_type=self.farm_type, name="Farm 2")
+
+    @patch("irrigation_recommendation.views.external_api_request")
+    def test_post_proxies_request_to_ai_service(self, mock_external_api_request):
+        mock_external_api_request.return_value = AdapterResponse(
+            status_code=200,
+            data={
+                "data": {
+                    "result": {
+                        "waterStressIndex": 12,
+                        "level": "پایین",
+                        "sourceMetric": {"soilMoisture": 24},
+                    }
+                }
+            },
+        )
+
+        request = self.factory.post(
+            "/api/irrigation/water-stress/",
+            {"farm_uuid": str(self.farm.farm_uuid)},
+            format="json",
+        )
+        force_authenticate(request, user=self.user)
+
+        response = WaterStressView.as_view()(request)
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["code"], 200)
+        self.assertEqual(response.data["msg"], "success")
+        self.assertEqual(response.data["data"]["farm_uuid"], str(self.farm.farm_uuid))
+        self.assertEqual(response.data["data"]["waterStressIndex"], 12)
+        self.assertEqual(response.data["data"]["level"], "پایین")
+        self.assertEqual(response.data["data"]["sourceMetric"], {"soilMoisture": 24})
+        mock_external_api_request.assert_called_once_with(
+            "ai",
+            "/api/irrigation/water-stress/",
+            method="POST",
+            payload={"farm_uuid": str(self.farm.farm_uuid)},
+        )
+
+    def test_post_rejects_foreign_farm_uuid(self):
+        request = self.factory.post(
+            "/api/irrigation/water-stress/",
+            {"farm_uuid": str(self.other_farm.farm_uuid)},
+            format="json",
+        )
+        force_authenticate(request, user=self.user)
+
+        response = WaterStressView.as_view()(request)
+
+        self.assertEqual(response.status_code, 404)
+        self.assertEqual(response.data["code"], 404)
+        self.assertEqual(response.data["data"]["farm_uuid"][0], "Farm not found.")
+
+
+class IrrigationMethodListViewTests(TestCase):
+    def setUp(self):
+        self.factory = APIRequestFactory()
+
+    @patch("irrigation_recommendation.views.external_api_request")
+    def test_get_proxies_irrigation_methods_from_ai(self, mock_external_api_request):
+        mock_external_api_request.return_value = AdapterResponse(
+            status_code=200,
+            data={
+                "data": [
+                    {
+                        "id": 1,
+                        "name": "Drip",
+                        "category": "micro",
+                        "description": "Efficient irrigation",
+                        "water_efficiency_percent": 90.0,
+                    }
+                ]
+            },
+        )
+
+        request = self.factory.get("/api/irrigation/")
+        response = IrrigationMethodListView.as_view()(request)
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["code"], 200)
+        self.assertEqual(response.data["data"][0]["name"], "Drip")
+        mock_external_api_request.assert_called_once_with(
+            "ai",
+            "/api/irrigation/",
+            method="GET",
+        )
+
+    @patch("irrigation_recommendation.views.external_api_request")
+    def test_post_proxies_irrigation_method_creation_to_ai(self, mock_external_api_request):
+        mock_external_api_request.return_value = AdapterResponse(
+            status_code=201,
+            data={
+                "data": {
+                    "id": 1,
+                    "name": "Drip",
+                    "category": "micro",
+                }
+            },
+        )
+
+        request = self.factory.post("/api/irrigation/", {"name": "Drip"}, format="json")
+        response = IrrigationMethodListView.as_view()(request)
+
+        self.assertEqual(response.status_code, 201)
+        self.assertEqual(response.data["data"]["name"], "Drip")
+        mock_external_api_request.assert_called_once_with(
+            "ai",
+            "/api/irrigation/",
+            method="POST",
+            payload={"name": "Drip"},
+        )

irrigation_recommendation/urls.py

@@ -1,13 +1,10 @@
 from django.urls import path
 
-from .views import ConfigView, RecommendTaskStatusView, RecommendView
+from .views import ConfigView, IrrigationMethodListView, RecommendView, WaterStressView
 
 urlpatterns = [
+    path("", IrrigationMethodListView.as_view(), name="irrigation-method-list"),
     path("config/", ConfigView.as_view(), name="irrigation-recommendation-config"),
     path("recommend/", RecommendView.as_view(), name="irrigation-recommendation-recommend"),
-    path(
-        "recommend/status/<str:task_id>/",
-        RecommendTaskStatusView.as_view(),
-        name="irrigation-recommendation-task-status",
-    ),
+    path("water-stress/", WaterStressView.as_view(), name="irrigation-water-stress"),
 ]

irrigation_recommendation/views.py

@@ -2,25 +2,31 @@
 Irrigation Recommendation API views.
 """
 
+import logging
+
 from rest_framework import serializers, status
 from rest_framework.response import Response
 from rest_framework.views import APIView
-from drf_spectacular.types import OpenApiTypes
-from drf_spectacular.utils import OpenApiParameter, extend_schema
+from drf_spectacular.utils import extend_schema
 
 from config.swagger import status_response
 from external_api_adapter import request as external_api_request
 from farm_hub.models import FarmHub
+from water.serializers import WaterStressIndexSerializer
+from water.views import WaterStressIndexView
 from .mock_data import CONFIG_RESPONSE_DATA
 from .models import IrrigationRecommendationRequest
 from .serializers import (
+    IrrigationMethodSerializer,
     IrrigationRecommendRequestSerializer,
     IrrigationRecommendResponseDataSerializer,
-    IrrigationTaskStatusDataSerializer,
-    IrrigationTaskSubmitDataSerializer,
+    WaterStressRequestSerializer,
 )
 
 
+logger = logging.getLogger(__name__)
+
+
 class FarmAccessMixin:
     @staticmethod
     def _get_farm(request, farm_uuid):
@@ -35,9 +41,6 @@ class FarmAccessMixin:
 class ConfigView(FarmAccessMixin, APIView):
     @extend_schema(
         tags=["Irrigation Recommendation"],
-        parameters=[
-            OpenApiParameter(name="farm_uuid", type=OpenApiTypes.UUID, location=OpenApiParameter.QUERY, required=True, default="11111111-1111-1111-1111-111111111111"),
-        ],
         responses={200: status_response("IrrigationConfigResponse", data=serializers.JSONField())},
     )
     def get(self, request):
@@ -47,7 +50,133 @@ class ConfigView(FarmAccessMixin, APIView):
         return Response({"status": "success", "data": data}, status=status.HTTP_200_OK)
 
 
+class IrrigationMethodListView(APIView):
+    @staticmethod
+    def _extract_methods(adapter_data):
+        if not isinstance(adapter_data, dict):
+            return adapter_data if isinstance(adapter_data, list) else []
+
+        data = adapter_data.get("data")
+        if isinstance(data, dict) and isinstance(data.get("result"), list):
+            return data["result"]
+        if isinstance(data, list):
+            return data
+
+        result = adapter_data.get("result")
+        if isinstance(result, list):
+            return result
+
+        return []
+
+    @extend_schema(
+        tags=["Irrigation Recommendation"],
+        responses={200: status_response("IrrigationMethodListResponse", data=IrrigationMethodSerializer(many=True))},
+    )
+    def get(self, request):
+        adapter_response = external_api_request(
+            "ai",
+            "/api/irrigation/",
+            method="GET",
+        )
+
+        if adapter_response.status_code >= 400:
+            response_data = adapter_response.data if isinstance(adapter_response.data, dict) else {"message": str(adapter_response.data)}
+            return Response(
+                {"code": adapter_response.status_code, "msg": "error", "data": response_data},
+                status=adapter_response.status_code,
+            )
+
+        return Response(
+            {"code": 200, "msg": "success", "data": self._extract_methods(adapter_response.data)},
+            status=status.HTTP_200_OK,
+        )
+
+    @extend_schema(
+        tags=["Irrigation Recommendation"],
+        request=serializers.JSONField,
+        responses={201: status_response("IrrigationMethodCreateResponse", data=IrrigationMethodSerializer())},
+    )
+    def post(self, request):
+        adapter_response = external_api_request(
+            "ai",
+            "/api/irrigation/",
+            method="POST",
+            payload=request.data,
+        )
+
+        response_data = adapter_response.data if isinstance(adapter_response.data, dict) else {"message": str(adapter_response.data)}
+        if adapter_response.status_code >= 400:
+            return Response(
+                {"code": adapter_response.status_code, "msg": "error", "data": response_data},
+                status=adapter_response.status_code,
+            )
+
+        payload = self._extract_methods(adapter_response.data)
+        if not payload:
+            payload = response_data.get("data", response_data)
+
+        return Response(
+            {"code": adapter_response.status_code, "msg": "success", "data": payload},
+            status=adapter_response.status_code,
+        )
+
+
 class RecommendView(FarmAccessMixin, APIView):
+    @staticmethod
+    def _normalize_sections(raw_sections):
+        if not isinstance(raw_sections, list):
+            return []
+
+        allowed_keys = {
+            "type",
+            "title",
+            "icon",
+            "content",
+            "items",
+            "frequency",
+            "amount",
+            "timing",
+            "validityPeriod",
+            "expandableExplanation",
+        }
+
+        normalized_sections = []
+        for section in raw_sections:
+            if not isinstance(section, dict) or not section.get("type"):
+                continue
+
+            normalized_section = {}
+            for key in allowed_keys:
+                value = section.get(key)
+                if value is None:
+                    continue
+                if key == "items":
+                    if not isinstance(value, list):
+                        continue
+                    normalized_section[key] = [str(item) for item in value]
+                    continue
+                normalized_section[key] = str(value) if key != "type" else value
+
+            normalized_sections.append(normalized_section)
+        return normalized_sections
+
+    def _extract_public_sections(self, adapter_data):
+        if not isinstance(adapter_data, dict):
+            return []
+
+        data = adapter_data.get("data")
+        if isinstance(data, dict) and isinstance(data.get("sections"), list):
+            return self._normalize_sections(data.get("sections"))
+
+        result = data.get("result") if isinstance(data, dict) else None
+        if isinstance(result, dict) and isinstance(result.get("sections"), list):
+            return self._normalize_sections(result.get("sections"))
+
+        if isinstance(adapter_data.get("sections"), list):
+            return self._normalize_sections(adapter_data.get("sections"))
+
+        return []
+
     @extend_schema(
         tags=["Irrigation Recommendation"],
         request=IrrigationRecommendRequestSerializer,
@@ -62,75 +191,103 @@ class RecommendView(FarmAccessMixin, APIView):
 
         adapter_response = external_api_request(
             "ai",
-            "/irrigation/recommend",
+            "/api/irrigation/recommend/",
             method="POST",
             payload=payload,
         )
 
         response_data = adapter_response.data if isinstance(adapter_response.data, dict) else {}
+        public_sections = self._extract_public_sections(response_data)
+
+        logger.warning(
+            "Irrigation recommendation response parsed: farm_uuid=%s status_code=%s response_keys=%s sections_count=%s",
+            str(farm.farm_uuid),
+            adapter_response.status_code,
+            sorted(response_data.keys()) if isinstance(response_data, dict) else None,
+            len(public_sections),
+        )
+
         IrrigationRecommendationRequest.objects.create(
             farm=farm,
-            crop_id=payload.get("crop_id", ""),
-            task_id=str(response_data.get("data", {}).get("task_id") or response_data.get("task_id") or ""),
-            status=str(response_data.get("data", {}).get("status") or response_data.get("status") or ""),
+            crop_id=payload.get("plant_name", ""),
+            task_id="",
+            status="success" if adapter_response.status_code < 400 else "error",
             request_payload=payload,
             response_payload=adapter_response.data if isinstance(adapter_response.data, dict) else {"raw": adapter_response.data},
         )
-        return Response(adapter_response.data, status=adapter_response.status_code)
+        if adapter_response.status_code >= 400:
+            return Response(
+                {
+                    "code": adapter_response.status_code,
+                    "msg": "error",
+                    "data": response_data if isinstance(response_data, dict) else {"message": str(adapter_response.data)},
+                },
+                status=adapter_response.status_code,
+            )
+
+        return Response(
+            {
+                "code": 200,
+                "msg": "success",
+                "data": {
+                    "sections": public_sections,
+                },
+            },
+            status=status.HTTP_200_OK,
+        )
 
 
-class RecommendTaskCreateView(FarmAccessMixin, APIView):
+class WaterStressView(APIView):
+    @staticmethod
+    def _get_farm(request, farm_uuid):
+        if not farm_uuid:
+            return None, Response(
+                {"code": 400, "msg": "error", "data": {"farm_uuid": ["This field is required."]}},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        try:
+            return FarmHub.objects.get(farm_uuid=farm_uuid, owner=request.user), None
+        except FarmHub.DoesNotExist:
+            return None, Response(
+                {"code": 404, "msg": "error", "data": {"farm_uuid": ["Farm not found."]}},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
     @extend_schema(
         tags=["Irrigation Recommendation"],
-        request=IrrigationRecommendRequestSerializer,
-        responses={200: status_response("IrrigationRecommendTaskCreateResponse", data=IrrigationTaskSubmitDataSerializer())},
+        request=WaterStressRequestSerializer,
+        responses={200: status_response("WaterStressResponse", data=WaterStressIndexSerializer())},
     )
     def post(self, request):
-        serializer = IrrigationRecommendRequestSerializer(data=request.data)
+        serializer = WaterStressRequestSerializer(data=request.data)
         serializer.is_valid(raise_exception=True)
         payload = serializer.validated_data.copy()
-        farm = self._get_farm(request, payload.get("farm_uuid"))
-        payload["farm_uuid"] = str(farm.farm_uuid)
+
+        farm, error_response = self._get_farm(request, payload.get("farm_uuid"))
+        if error_response is not None:
+            return error_response
+
+        query = {"farm_uuid": str(farm.farm_uuid)}
+        sensor_uuid = payload.get("sensor_uuid")
+        if sensor_uuid:
+            query["sensor_uuid"] = str(sensor_uuid)
 
         adapter_response = external_api_request(
             "ai",
-            "/irrigation/recommend",
+            "/api/irrigation/water-stress/",
             method="POST",
-            payload=payload,
+            payload=query,
         )
 
-        response_data = adapter_response.data if isinstance(adapter_response.data, dict) else {}
-        IrrigationRecommendationRequest.objects.create(
-            farm=farm,
-            crop_id=payload.get("crop_id", ""),
-            task_id=str(response_data.get("data", {}).get("task_id") or response_data.get("task_id") or ""),
-            status=str(response_data.get("data", {}).get("status") or response_data.get("status") or ""),
-            request_payload=payload,
-            response_payload=adapter_response.data if isinstance(adapter_response.data, dict) else {"raw": adapter_response.data},
-        )
-        return Response(adapter_response.data, status=adapter_response.status_code)
+        if adapter_response.status_code >= 400:
+            response_data = adapter_response.data if isinstance(adapter_response.data, dict) else {"message": str(adapter_response.data)}
+            return Response(
+                {"code": adapter_response.status_code, "msg": "error", "data": response_data},
+                status=adapter_response.status_code,
+            )
 
-
-class RecommendTaskStatusView(FarmAccessMixin, APIView):
-    @extend_schema(
-        tags=["Irrigation Recommendation"],
-        parameters=[
-            OpenApiParameter(name="task_id", type=OpenApiTypes.STR, location=OpenApiParameter.PATH),
-            OpenApiParameter(name="farm_uuid", type=OpenApiTypes.UUID, location=OpenApiParameter.QUERY, required=True, default="11111111-1111-1111-1111-111111111111"),
-        ],
-        responses={200: status_response("IrrigationRecommendTaskStatusResponse", data=IrrigationTaskStatusDataSerializer())},
-    )
-    def get(self, request, task_id):
-        farm = self._get_farm(request, request.query_params.get("farm_uuid"))
-        adapter_response = external_api_request(
-            "ai",
-            f"/irrigation/recommend/status/{task_id}",
-            method="GET",
-            query={"farm_uuid": str(farm.farm_uuid)},
+        stress_payload = WaterStressIndexView.extract_stress_payload(adapter_response.data, farm.farm_uuid)
+        return Response(
+            {"code": 200, "msg": "success", "data": stress_payload},
+            status=status.HTTP_200_OK,
         )
-        response_data = adapter_response.data if isinstance(adapter_response.data, dict) else {}
-        IrrigationRecommendationRequest.objects.filter(farm=farm, task_id=task_id).update(
-            status=str(response_data.get("data", {}).get("status") or response_data.get("status") or ""),
-            response_payload=adapter_response.data if isinstance(adapter_response.data, dict) else {"raw": adapter_response.data},
-        )
-        return Response(adapter_response.data, status=adapter_response.status_code)