UPDATE

2026-04-27 00:40:59 +03:30
parent 2cd96ceec6
commit 64e67c282c
56 changed files with 3912 additions and 745 deletions
@@ -0,0 +1,9 @@
+from django.urls import path
+
+from .views import AnalyzeView, RiskSummaryView, RiskView
+
+urlpatterns = [
+    path("detect/", AnalyzeView.as_view(), name="pest-disease-detect"),
+    path("risk/", RiskView.as_view(), name="pest-disease-risk"),
+    path("risk-summary/", RiskSummaryView.as_view(), name="pest-disease-risk-summary"),
+]
@@ -1,13 +1,64 @@
 from rest_framework import serializers


-class RiskDetailsSerializer(serializers.Serializer):
-    risk_level = serializers.CharField(required=False, allow_blank=True)
-    risk_percentage = serializers.IntegerField(required=False)
-    detected_diseases = serializers.ListField(child=serializers.DictField(), required=False)
-    detected_pests = serializers.ListField(child=serializers.DictField(), required=False)
-    last_assessed_at = serializers.CharField(required=False, allow_blank=True)
-    recommendation = serializers.CharField(required=False, allow_blank=True)
+class PestDetectionAnalyzeRequestSerializer(serializers.Serializer):
+    farm_uuid = serializers.UUIDField(required=True, help_text="UUID مزرعه برای تحلیل آفت/بیماری.")
+    sensor_uuid = serializers.UUIDField(required=False, help_text="UUID سنسور مرتبط در صورت وجود.")
+    plant_name = serializers.CharField(required=False, allow_blank=True, default="", help_text="نام گیاه یا محصول.")
+    query = serializers.CharField(required=False, allow_blank=True, default="", help_text="پرسش یا توضیح متنی کاربر.")
+    image_urls = serializers.ListField(
+        child=serializers.CharField(),
+        required=False,
+        default=list,
+    )
+    image = serializers.CharField(required=False, allow_blank=True, default="")
+    images = serializers.ListField(
+        child=serializers.CharField(),
+        required=False,
+        default=list,
+    )
+
+    def validate(self, attrs):
+        attrs["query"] = (attrs.get("query") or "").strip()
+        attrs["plant_name"] = (attrs.get("plant_name") or "").strip()
+        return attrs
+
+
+class PestDetectionAnalyzeResponseSerializer(serializers.Serializer):
+    has_issue = serializers.BooleanField(required=False)
+    category = serializers.CharField(required=False, allow_blank=True)
+    confidence = serializers.FloatField(required=False)
+    severity = serializers.CharField(required=False, allow_blank=True)
+    summary = serializers.CharField(required=False, allow_blank=True)
+    detected_signs = serializers.ListField(child=serializers.CharField(), required=False)
+    possible_causes = serializers.ListField(child=serializers.CharField(), required=False)
+    immediate_actions = serializers.ListField(child=serializers.CharField(), required=False)
+    reasoning = serializers.ListField(child=serializers.CharField(), required=False)
+
+
+class PestDetectionRiskRequestSerializer(serializers.Serializer):
+    farm_uuid = serializers.UUIDField(required=True, help_text="UUID مزرعه برای تحلیل ریسک آفت/بیماری.")
+    sensor_uuid = serializers.UUIDField(required=False, help_text="UUID سنسور مرتبط در صورت وجود.")
+    plant_name = serializers.CharField(required=False, allow_blank=True, default="", help_text="نام محصول یا گیاه.")
+    growth_stage = serializers.CharField(required=False, allow_blank=True, default="", help_text="مرحله رشد گیاه.")
+    query = serializers.CharField(required=False, allow_blank=True, default="", help_text="پرسش تکمیلی کاربر.")
+
+
+class RiskBreakdownSerializer(serializers.Serializer):
+    score = serializers.FloatField(required=False)
+    level = serializers.CharField(required=False, allow_blank=True)
+    likely_conditions = serializers.ListField(child=serializers.CharField(), required=False)
+    reasoning = serializers.ListField(child=serializers.CharField(), required=False)
+
+
+class PestDetectionRiskResponseSerializer(serializers.Serializer):
+    summary = serializers.CharField(required=False, allow_blank=True)
+    forecast_window = serializers.CharField(required=False, allow_blank=True)
+    overall_risk = serializers.CharField(required=False, allow_blank=True)
+    disease_risk = RiskBreakdownSerializer(required=False)
+    pest_risk = RiskBreakdownSerializer(required=False)
+    key_drivers = serializers.ListField(child=serializers.CharField(), required=False)
+    recommended_actions = serializers.ListField(child=serializers.CharField(), required=False)


 class RiskCardSerializer(serializers.Serializer):
@@ -19,9 +70,11 @@ class RiskCardSerializer(serializers.Serializer):
    avatarIcon = serializers.CharField(required=False, allow_blank=True)
    chipText = serializers.CharField(required=False, allow_blank=True)
    chipColor = serializers.CharField(required=False, allow_blank=True)
-    details = RiskDetailsSerializer(required=False)
+    details = serializers.DictField(required=False)


-class RiskSummaryDataSerializer(serializers.Serializer):
-    disease_risk = RiskCardSerializer(required=False)
-    pest_risk = RiskCardSerializer(required=False)
+class PestDetectionRiskSummaryResponseSerializer(serializers.Serializer):
+    farm_uuid = serializers.UUIDField(required=False, allow_null=True)
+    diseaseRisk = RiskCardSerializer(required=False)
+    pestRisk = RiskCardSerializer(required=False)
+    drivers = serializers.DictField(required=False)
@@ -0,0 +1,229 @@
+from unittest.mock import patch
+
+from django.contrib.auth import get_user_model
+from django.test import TestCase
+from django.urls import resolve
+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 AnalyzeView, RiskSummaryView, RiskView
+
+
+class PestDetectionViewTests(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("pest_detection.views.external_api_request")
+    def test_analyze_proxies_to_ai_service(self, mock_external_api_request):
+        mock_external_api_request.return_value = AdapterResponse(
+            status_code=200,
+            data={
+                "data": {
+                    "result": {
+                        "has_issue": True,
+                        "category": "disease",
+                        "confidence": 0.93,
+                        "severity": "medium",
+                        "summary": "Leaf spot symptoms detected.",
+                        "detected_signs": ["Brown leaf spots"],
+                        "possible_causes": ["Fungal pressure"],
+                        "immediate_actions": ["Isolate affected plants"],
+                        "reasoning": ["Pattern matched common fungal lesions"],
+                    }
+                }
+            },
+        )
+
+        request = self.factory.post(
+            "/api/pest-detection/analyze/",
+            {"farm_uuid": str(self.farm.farm_uuid), "image_urls": ["https://example.com/leaf.jpg"]},
+            format="json",
+        )
+        force_authenticate(request, user=self.user)
+
+        response = AnalyzeView.as_view()(request)
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["code"], 200)
+        self.assertEqual(response.data["data"]["category"], "disease")
+        mock_external_api_request.assert_called_once_with(
+            "ai",
+            "/api/pest-disease/detect/",
+            method="POST",
+            payload={
+                "farm_uuid": str(self.farm.farm_uuid),
+                "plant_name": "",
+                "query": "",
+                "image_urls": ["https://example.com/leaf.jpg"],
+            },
+        )
+
+    def test_analyze_requires_at_least_one_image(self):
+        request = self.factory.post(
+            "/api/pest-detection/analyze/",
+            {"farm_uuid": str(self.farm.farm_uuid)},
+            format="json",
+        )
+        force_authenticate(request, user=self.user)
+
+        response = AnalyzeView.as_view()(request)
+
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(response.data["code"], 400)
+        self.assertIn("images", response.data["data"])
+
+    @patch("pest_detection.views.external_api_request")
+    def test_risk_proxies_to_ai_service(self, mock_external_api_request):
+        mock_external_api_request.return_value = AdapterResponse(
+            status_code=200,
+            data={
+                "data": {
+                    "result": {
+                        "summary": "Warm humidity raises fungal pressure.",
+                        "forecast_window": "72h",
+                        "overall_risk": "medium",
+                        "disease_risk": {"score": 0.7, "level": "medium", "likely_conditions": [], "reasoning": []},
+                        "pest_risk": {"score": 0.4, "level": "low", "likely_conditions": [], "reasoning": []},
+                        "key_drivers": ["High humidity"],
+                        "recommended_actions": ["Scout vulnerable rows"],
+                    }
+                }
+            },
+        )
+
+        request = self.factory.post(
+            "/api/pest-detection/risk/",
+            {"farm_uuid": str(self.farm.farm_uuid), "plant_name": "wheat"},
+            format="json",
+        )
+        force_authenticate(request, user=self.user)
+
+        response = RiskView.as_view()(request)
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["data"]["overall_risk"], "medium")
+        mock_external_api_request.assert_called_once_with(
+            "ai",
+            "/api/pest-disease/risk/",
+            method="POST",
+            payload={
+                "farm_uuid": str(self.farm.farm_uuid),
+                "plant_name": "wheat",
+                "growth_stage": "",
+                "query": "",
+            },
+        )
+
+    @patch("pest_detection.views.external_api_request")
+    def test_risk_summary_maps_response_shape(self, mock_external_api_request):
+        mock_external_api_request.return_value = AdapterResponse(
+            status_code=200,
+            data={
+                "data": {
+                    "result": {
+                        "disease_risk": {"title": "Disease"},
+                        "pest_risk": {"title": "Pest"},
+                        "drivers": {"humidity": "high"},
+                    }
+                }
+            },
+        )
+
+        request = self.factory.post(
+            "/api/pest-disease/risk-summary/",
+            {"farm_uuid": str(self.farm.farm_uuid)},
+            format="json",
+        )
+        force_authenticate(request, user=self.user)
+
+        response = RiskSummaryView.as_view()(request)
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["code"], 200)
+        self.assertEqual(response.data["data"]["farm_uuid"], str(self.farm.farm_uuid))
+        self.assertEqual(response.data["data"]["diseaseRisk"]["title"], "Disease")
+        self.assertEqual(response.data["data"]["pestRisk"]["title"], "Pest")
+        self.assertEqual(response.data["data"]["drivers"], {"humidity": "high"})
+        mock_external_api_request.assert_called_once_with(
+            "ai",
+            "/api/pest-disease/risk-summary/",
+            method="POST",
+            payload={"farm_uuid": str(self.farm.farm_uuid)},
+        )
+
+    @patch("pest_detection.views.external_api_request")
+    def test_risk_summary_post_uses_pest_disease_route(self, mock_external_api_request):
+        mock_external_api_request.return_value = AdapterResponse(
+            status_code=200,
+            data={
+                "data": {
+                    "result": {
+                        "disease_risk": {"title": "Disease"},
+                        "pest_risk": {"title": "Pest"},
+                        "drivers": {"humidity": "high"},
+                    }
+                }
+            },
+        )
+
+        request = self.factory.post(
+            "/api/pest-disease/risk-summary/",
+            {"farm_uuid": str(self.farm.farm_uuid)},
+            format="json",
+        )
+        force_authenticate(request, user=self.user)
+
+        response = RiskSummaryView.as_view()(request)
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["data"]["farm_uuid"], str(self.farm.farm_uuid))
+        mock_external_api_request.assert_called_once_with(
+            "ai",
+            "/api/pest-disease/risk-summary/",
+            method="POST",
+            payload={"farm_uuid": str(self.farm.farm_uuid)},
+        )
+
+    def test_risk_summary_rejects_foreign_farm_uuid(self):
+        request = self.factory.post(
+            "/api/pest-disease/risk-summary/",
+            {"farm_uuid": str(self.other_farm.farm_uuid)},
+            format="json",
+        )
+        force_authenticate(request, user=self.user)
+
+        response = RiskSummaryView.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.")
+
+    def test_risk_summary_get_is_not_allowed(self):
+        request = self.factory.get(f"/api/pest-disease/risk-summary/?farm_uuid={self.farm.farm_uuid}")
+        force_authenticate(request, user=self.user)
+
+        response = RiskSummaryView.as_view()(request)
+
+        self.assertEqual(response.status_code, 405)
+
+    def test_pest_disease_alias_routes_exist(self):
+        self.assertIs(resolve("/api/pest-disease/detect/").func.view_class, AnalyzeView)
+        self.assertIs(resolve("/api/pest-disease/risk/").func.view_class, RiskView)
+        self.assertIs(resolve("/api/pest-disease/risk-summary/").func.view_class, RiskSummaryView)
@@ -1,8 +1 @@
-from django.urls import path
-
-from .views import AnalyzeView, RiskSummaryView
-
-urlpatterns = [
-    path("analyze/", AnalyzeView.as_view(), name="pest-detection-analyze"),
-    path("risk-summary/", RiskSummaryView.as_view(), name="pest-detection-risk-summary"),
-]
+urlpatterns = []
@@ -1,101 +1,254 @@
 """
-Pest Detection API views.
-No database. All responses are static mock data.
-Response format: {"status": "success", "data": <payload>}. HTTP 200 only.
-No processing, validation, or use of input parameters in responses.
+Pest detection API views.
 """

-from rest_framework import serializers, status
+import json
+
+from drf_spectacular.utils import extend_schema
+from rest_framework import 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 config.swagger import status_response
 from external_api_adapter import request as external_api_request
-from .mock_data import ANALYZE_RESPONSE_DATA
-from .serializers import RiskSummaryDataSerializer
+from farm_hub.models import FarmHub
+from .serializers import (
+    PestDetectionAnalyzeRequestSerializer,
+    PestDetectionAnalyzeResponseSerializer,
+    PestDetectionRiskRequestSerializer,
+    PestDetectionRiskResponseSerializer,
+    PestDetectionRiskSummaryResponseSerializer,
+)


-class AnalyzeView(APIView):
-    """
-    POST endpoint for pest detection analysis.
+class PestDetectionFarmMixin:
+    @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,
+            )

-    Purpose:
-        Returns a static pest detection result (pest name, confidence,
-        description, treatment). Used when the user uploads a plant image
-        and requests analysis. No processing is performed on the request.
+    @staticmethod
+    def _parse_json_array(value):
+        if not isinstance(value, str):
+            return None
+        try:
+            parsed = json.loads(value)
+        except (TypeError, ValueError):
+            return None
+        return parsed if isinstance(parsed, list) else None

-    Input parameters:
-        - body (optional): JSON or form-data; may contain image or file.
-          Data type: object. Location: body. Not read or validated; not used in response.
+    def _collect_uploaded_images(self, request):
+        uploaded_images = []
+        single_image = request.FILES.get("image")
+        if single_image is not None:
+            uploaded_images.append(single_image)
+        uploaded_images.extend(request.FILES.getlist("images"))
+        return uploaded_images

-    Response structure:
-        - status: string, always "success".
-        - data: object with keys pest (string), confidence (number),
-          description (string), treatment (string).
+    def _prepare_image_urls(self, request):
+        image_urls = request.data.get("image_urls", [])
+        if isinstance(image_urls, str):
+            parsed = self._parse_json_array(image_urls)
+            image_urls = parsed if parsed is not None else [image_urls]
+        return [str(item) for item in image_urls if str(item).strip()]

-    No processing or validation is performed on inputs.
-    """
+    @staticmethod
+    def _attach_uploaded_files(payload, uploaded_images):
+        if not uploaded_images:
+            return payload

-    @extend_schema(
-        tags=["Pest Detection"],
-        request=OpenApiTypes.OBJECT,
-        responses={200: status_response("PestDetectionAnalyzeResponse", data=serializers.JSONField())},
-    )
-    def post(self, request):
+        files = []
+        for uploaded_image in uploaded_images:
+            files.append(
+                (
+                    "images",
+                    (
+                        uploaded_image.name,
+                        uploaded_image,
+                        getattr(uploaded_image, "content_type", "application/octet-stream"),
+                    ),
+                )
+            )
+
+        multipart_payload = dict(payload)
+        multipart_payload["image_urls"] = json.dumps(payload.get("image_urls", []), ensure_ascii=False)
+        multipart_payload["__files__"] = files
+        return multipart_payload
+
+    @staticmethod
+    def _extract_result_payload(adapter_data):
+        if not isinstance(adapter_data, dict):
+            return {}
+
+        data = adapter_data.get("data")
+        if isinstance(data, dict) and isinstance(data.get("result"), dict):
+            return data.get("result", {})
+        if isinstance(data, dict):
+            return data
+
+        result = adapter_data.get("result")
+        if isinstance(result, dict):
+            return result
+
+        return adapter_data
+
+    @staticmethod
+    def _error_response(adapter_response):
+        response_data = (
+            adapter_response.data
+            if isinstance(adapter_response.data, dict)
+            else {"message": str(adapter_response.data)}
+        )
        return Response(
-            {"status": "success", "data": ANALYZE_RESPONSE_DATA},
-            status=status.HTTP_200_OK,
+            {"code": adapter_response.status_code, "msg": "error", "data": response_data},
+            status=adapter_response.status_code,
        )


-class RiskSummaryView(APIView):
-    """
-    GET endpoint for combined pest and disease risk summary.
-
-    Purpose:
-        Returns disease_risk and pest_risk card data for the farm dashboard.
-        Calls the AI external adapter for live/mock risk assessment results.
-
-    Input parameters:
-        - farm_uuid (query, optional): UUID of the farm to assess.
-
-    Response structure:
-        - status: string, always "success".
-        - data: object with keys disease_risk and pest_risk,
-          each containing card display fields (id, title, subtitle, stats,
-          avatarColor, avatarIcon, chipText, chipColor) and a details object.
-    """
-
+class AnalyzeView(PestDetectionFarmMixin, APIView):
    @extend_schema(
        tags=["Pest Detection"],
-        parameters=[
-            OpenApiParameter(
-                name="farm_uuid",
-                type=OpenApiTypes.UUID,
-                location=OpenApiParameter.QUERY,
-                required=False,
-                description="UUID of the farm for risk assessment.",
-                default="11111111-1111-1111-1111-111111111111"),
-        ],
-        responses={200: status_response("PestDetectionRiskSummaryResponse", data=RiskSummaryDataSerializer())},
+        request=PestDetectionAnalyzeRequestSerializer,
+        responses={200: status_response("PestDetectionAnalyzeResponse", data=PestDetectionAnalyzeResponseSerializer())},
    )
-    def get(self, request):
-        farm_uuid = request.query_params.get("farm_uuid")
-        query = {"farm_uuid": str(farm_uuid)} if farm_uuid else {}
+    def post(self, request):
+        serializer = PestDetectionAnalyzeRequestSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        payload = serializer.validated_data.copy()
+
+        farm, error_response = self._get_farm(request, payload.get("farm_uuid"))
+        if error_response is not None:
+            return error_response
+
+        image_urls = self._prepare_image_urls(request)
+        uploaded_images = self._collect_uploaded_images(request)
+        if not image_urls and not uploaded_images:
+            return Response(
+                {
+                    "code": 400,
+                    "msg": "error",
+                    "data": {
+                        "images": ["At least one image must be provided via image_urls, image, or images."],
+                    },
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        ai_payload = {
+            "farm_uuid": str(farm.farm_uuid),
+            "plant_name": payload.get("plant_name", ""),
+            "query": payload.get("query", ""),
+            "image_urls": image_urls,
+        }
+        sensor_uuid = payload.get("sensor_uuid")
+        if sensor_uuid:
+            ai_payload["sensor_uuid"] = str(sensor_uuid)
+
+        ai_payload = self._attach_uploaded_files(ai_payload, uploaded_images)

        adapter_response = external_api_request(
            "ai",
-            "/pest-detection/risk-summary",
-            method="GET",
-            query=query,
+            "/api/pest-disease/detect/",
+            method="POST",
+            payload=ai_payload,
        )

-        response_data = adapter_response.data if isinstance(adapter_response.data, dict) else {}
-        result = response_data.get("result", response_data.get("data", response_data))
+        if adapter_response.status_code >= 400:
+            return self._error_response(adapter_response)

        return Response(
-            {"status": "success", "data": result},
+            {"code": 200, "msg": "success", "data": self._extract_result_payload(adapter_response.data)},
+            status=status.HTTP_200_OK,
+        )
+
+
+class RiskView(PestDetectionFarmMixin, APIView):
+    @extend_schema(
+        tags=["Pest Detection"],
+        request=PestDetectionRiskRequestSerializer,
+        responses={200: status_response("PestDetectionRiskResponse", data=PestDetectionRiskResponseSerializer())},
+    )
+    def post(self, request):
+        serializer = PestDetectionRiskRequestSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        payload = serializer.validated_data.copy()
+
+        farm, error_response = self._get_farm(request, payload.get("farm_uuid"))
+        if error_response is not None:
+            return error_response
+
+        ai_payload = {
+            "farm_uuid": str(farm.farm_uuid),
+            "plant_name": payload.get("plant_name", ""),
+            "growth_stage": payload.get("growth_stage", ""),
+            "query": payload.get("query", ""),
+        }
+        sensor_uuid = payload.get("sensor_uuid")
+        if sensor_uuid:
+            ai_payload["sensor_uuid"] = str(sensor_uuid)
+
+        adapter_response = external_api_request(
+            "ai",
+            "/api/pest-disease/risk/",
+            method="POST",
+            payload=ai_payload,
+        )
+
+        if adapter_response.status_code >= 400:
+            return self._error_response(adapter_response)
+
+        return Response(
+            {"code": 200, "msg": "success", "data": self._extract_result_payload(adapter_response.data)},
+            status=status.HTTP_200_OK,
+        )
+
+
+class RiskSummaryView(PestDetectionFarmMixin, APIView):
+    @extend_schema(
+        tags=["Pest Detection"],
+        request=PestDetectionRiskRequestSerializer,
+        responses={200: status_response("PestDetectionRiskSummaryResponse", data=PestDetectionRiskSummaryResponseSerializer())},
+    )
+    def post(self, request):
+        farm_uuid = request.data.get("farm_uuid")
+        sensor_uuid = request.data.get("sensor_uuid")
+
+        farm, error_response = self._get_farm(request, farm_uuid)
+        if error_response is not None:
+            return error_response
+
+        payload = {"farm_uuid": str(farm.farm_uuid)}
+        if sensor_uuid:
+            payload["sensor_uuid"] = str(sensor_uuid)
+
+        adapter_response = external_api_request(
+            "ai",
+            "/api/pest-disease/risk-summary/",
+            method="POST",
+            payload=payload,
+        )
+
+        if adapter_response.status_code >= 400:
+            return self._error_response(adapter_response)
+
+        result = self._extract_result_payload(adapter_response.data)
+        response_payload = {
+            "farm_uuid": str(farm.farm_uuid),
+            "diseaseRisk": result.get("diseaseRisk") or result.get("disease_risk") or {},
+            "pestRisk": result.get("pestRisk") or result.get("pest_risk") or {},
+            "drivers": result.get("drivers") if isinstance(result.get("drivers"), dict) else {},
+        }
+        return Response(
+            {"code": 200, "msg": "success", "data": response_payload},
            status=status.HTTP_200_OK,
        )