UPDATE

Modules/Backend/water/apps.py

@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+
+
+class WaterConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "water"
+    label = "weather_forecast"
+    verbose_name = "water"

Modules/Backend/water/defaults.py

@@ -0,0 +1,36 @@
+EMPTY_FARM_WEATHER_CARD = {
+    "condition": None,
+    "temperature": None,
+    "unit": "°C",
+    "humidity": None,
+    "windSpeed": None,
+    "windUnit": "km/h",
+    "chartData": {"labels": [], "series": [[]]},
+    "status": "empty",
+    "source": "db",
+    "warnings": ["No persisted weather data is available for this farm."],
+}
+
+EMPTY_WATER_NEED_PREDICTION = {
+    "totalNext7Days": 0,
+    "unit": "mm",
+    "categories": [],
+    "series": [{"name": "نیاز آبی", "data": []}],
+    "status": "empty",
+    "source": "db",
+    "warnings": ["No persisted irrigation water-balance data is available for this farm."],
+}
+
+EMPTY_WATER_STRESS_INDEX = {
+    "id": "water_stress_index",
+    "title": "شاخص تنش آبی",
+    "subtitle": "فعلی",
+    "stats": None,
+    "avatarColor": "secondary",
+    "avatarIcon": "tabler-droplet",
+    "chipText": "بدون داده",
+    "chipColor": "secondary",
+    "status": "empty",
+    "source": "db",
+    "warnings": ["No persisted irrigation stress data is available for this farm."],
+}

Modules/Backend/water/migrations/0001_initial.py

@@ -0,0 +1,43 @@
+import django.db.models.deletion
+import uuid
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = [
+        ("farm_hub", "0007_farmhub_subscription_plan"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="WeatherForecastLog",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("uuid", models.UUIDField(db_index=True, default=uuid.uuid4, editable=False, unique=True)),
+                ("condition", models.CharField(blank=True, default="", max_length=128)),
+                ("temperature", models.FloatField(blank=True, null=True)),
+                ("unit", models.CharField(blank=True, default="°C", max_length=16)),
+                ("humidity", models.IntegerField(blank=True, null=True)),
+                ("wind_speed", models.FloatField(blank=True, null=True)),
+                ("wind_unit", models.CharField(blank=True, default="km/h", max_length=16)),
+                ("chart_data", models.JSONField(blank=True, default=dict)),
+                ("fetched_at", models.DateTimeField(auto_now_add=True)),
+                (
+                    "farm",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="weather_forecasts",
+                        to="farm_hub.farmhub",
+                    ),
+                ),
+            ],
+            options={
+                "db_table": "weather_forecast_logs",
+                "ordering": ["-fetched_at"],
+            },
+        ),
+    ]

Modules/Backend/water/mock_data.py

@@ -0,0 +1,34 @@
+"""
+Static mock data for WATER API.
+"""
+
+FARM_WEATHER_CARD = {
+    "condition": "صاف",
+    "temperature": 24,
+    "unit": "°C",
+    "humidity": 45,
+    "windSpeed": 12,
+    "windUnit": "km/h",
+    "chartData": {
+        "labels": ["۶ صبح", "۹ صبح", "۱۲ ظهر", "۳ بعدازظهر", "۶ عصر", "۹ شب", "۱۲ شب"],
+        "series": [[18, 22, 26, 28, 25, 20, 18]],
+    },
+}
+
+WATER_NEED_PREDICTION = {
+    "totalNext7Days": 3290,
+    "unit": "m3",
+    "categories": ["روز 1", "روز 2", "روز 3", "روز 4", "روز 5", "روز 6", "روز 7"],
+    "series": [{"name": "نیاز آبی", "data": [420, 450, 480, 460, 490, 510, 480]}],
+}
+
+WATER_STRESS_INDEX = {
+    "id": "water_stress_index",
+    "title": "شاخص تنش آبی",
+    "subtitle": "فعلی",
+    "stats": "12%",
+    "avatarColor": "info",
+    "avatarIcon": "tabler-droplet",
+    "chipText": "پایین",
+    "chipColor": "success",
+}

Modules/Backend/water/models.py

@@ -0,0 +1,32 @@
+import uuid as uuid_lib
+
+from django.db import models
+
+from farm_hub.models import FarmHub
+
+
+class WeatherForecastLog(models.Model):
+    uuid = models.UUIDField(default=uuid_lib.uuid4, unique=True, editable=False, db_index=True)
+    farm = models.ForeignKey(
+        FarmHub,
+        on_delete=models.CASCADE,
+        related_name="weather_forecasts",
+        null=True,
+        blank=True,
+    )
+    condition = models.CharField(max_length=128, blank=True, default="")
+    temperature = models.FloatField(null=True, blank=True)
+    unit = models.CharField(max_length=16, blank=True, default="°C")
+    humidity = models.IntegerField(null=True, blank=True)
+    wind_speed = models.FloatField(null=True, blank=True)
+    wind_unit = models.CharField(max_length=16, blank=True, default="km/h")
+    chart_data = models.JSONField(default=dict, blank=True)
+    fetched_at = models.DateTimeField(auto_now_add=True)
+
+    class Meta:
+        db_table = "weather_forecast_logs"
+        ordering = ["-fetched_at"]
+
+    def __str__(self):
+        farm_label = str(self.farm_id) if self.farm_id else "no-farm"
+        return f"{farm_label} — {self.condition} {self.temperature}{self.unit}"

Modules/Backend/water/serializers.py

@@ -0,0 +1,57 @@
+from rest_framework import serializers
+
+
+class WeatherFarmCardRequestSerializer(serializers.Serializer):
+    farm_uuid = serializers.UUIDField(
+        required=True,
+        initial="11111111-1111-1111-1111-111111111111",
+        help_text="UUID مزرعه.",
+    )
+
+
+class WeatherChartDataSerializer(serializers.Serializer):
+    labels = serializers.ListField(child=serializers.CharField(), required=False)
+    series = serializers.ListField(
+        child=serializers.ListField(child=serializers.FloatField()),
+        required=False,
+    )
+
+
+class FarmWeatherCardSerializer(serializers.Serializer):
+    condition = serializers.CharField(required=False, allow_blank=True, help_text="وضعیت فعلی آب‌وهوا.")
+    temperature = serializers.FloatField(required=False, help_text="دمای فعلی.")
+    unit = serializers.CharField(required=False, allow_blank=True, help_text="واحد دما.")
+    humidity = serializers.IntegerField(required=False, help_text="رطوبت نسبی.")
+    windSpeed = serializers.FloatField(required=False, help_text="سرعت باد.")
+    windUnit = serializers.CharField(required=False, allow_blank=True, help_text="واحد سرعت باد.")
+    chartData = WeatherChartDataSerializer(required=False)
+
+
+class WaterNeedSeriesSerializer(serializers.Serializer):
+    name = serializers.CharField(required=False, allow_blank=True)
+    data = serializers.ListField(child=serializers.FloatField(), required=False)
+
+
+class WaterNeedPredictionSerializer(serializers.Serializer):
+    farm_uuid = serializers.CharField(required=False, allow_blank=True, help_text="UUID مزرعه.")
+    totalNext7Days = serializers.FloatField(required=False, help_text="جمع نیاز آبی ۷ روز آینده.")
+    unit = serializers.CharField(required=False, allow_blank=True, help_text="واحد نیاز آبی.")
+    categories = serializers.ListField(child=serializers.CharField(), required=False, help_text="برچسب روزها یا تاریخ‌ها.")
+    series = WaterNeedSeriesSerializer(many=True, required=False)
+    dailyBreakdown = serializers.ListField(child=serializers.DictField(), required=False, help_text="جزئیات روزانه پیش‌بینی.")
+    insight = serializers.DictField(required=False, help_text="جمع‌بندی و insight تحلیلی.")
+    knowledge_base = serializers.CharField(required=False, allow_blank=True, help_text="مرجع دانشی در صورت ارائه توسط upstream.")
+    raw_response = serializers.CharField(required=False, allow_blank=True, help_text="پاسخ خام upstream در صورت وجود.")
+
+
+class WaterStressIndexSerializer(serializers.Serializer):
+    farm_uuid = serializers.UUIDField(required=False, allow_null=True, help_text="UUID مزرعه.")
+    waterStressIndex = serializers.IntegerField(required=False, help_text="شاخص تنش آبی.")
+    level = serializers.CharField(required=False, allow_blank=True, help_text="سطح تنش آبی.")
+    sourceMetric = serializers.DictField(required=False, help_text="متریک یا منبع محاسبه تنش آبی.")
+
+
+class WaterSummarySerializer(serializers.Serializer):
+    farmWeatherCard = FarmWeatherCardSerializer(required=False)
+    waterNeedPrediction = WaterNeedPredictionSerializer(required=False)
+    waterStressIndex = WaterStressIndexSerializer(required=False)

Modules/Backend/water/services.py

@@ -0,0 +1,115 @@
+from copy import deepcopy
+
+from irrigation.models import IrrigationRecommendationRequest
+
+from .defaults import EMPTY_FARM_WEATHER_CARD, EMPTY_WATER_NEED_PREDICTION, EMPTY_WATER_STRESS_INDEX
+from .models import WeatherForecastLog
+
+
+def get_farm_weather_card_data(farm=None):
+    if farm is None:
+        return deepcopy(EMPTY_FARM_WEATHER_CARD)
+
+    log = WeatherForecastLog.objects.filter(farm=farm).first()
+    if log is None:
+        return deepcopy(EMPTY_FARM_WEATHER_CARD)
+
+    return {
+        "condition": log.condition or None,
+        "temperature": log.temperature if log.temperature is not None else None,
+        "unit": log.unit or EMPTY_FARM_WEATHER_CARD["unit"],
+        "humidity": log.humidity if log.humidity is not None else None,
+        "windSpeed": log.wind_speed if log.wind_speed is not None else None,
+        "windUnit": log.wind_unit or EMPTY_FARM_WEATHER_CARD["windUnit"],
+        "chartData": deepcopy(log.chart_data or EMPTY_FARM_WEATHER_CARD["chartData"]),
+        "status": "success",
+        "source": "db",
+        "warnings": [],
+    }
+
+
+def _extract_irrigation_result(response_payload):
+    if not isinstance(response_payload, dict):
+        return {}
+
+    data = response_payload.get("data")
+    if isinstance(data, dict) and isinstance(data.get("result"), dict):
+        return data["result"]
+
+    result = response_payload.get("result")
+    if isinstance(result, dict):
+        return result
+
+    return {}
+
+
+def _get_latest_irrigation_result(farm):
+    if farm is None:
+        return {}
+
+    for request in IrrigationRecommendationRequest.objects.filter(farm=farm):
+        result = _extract_irrigation_result(request.response_payload)
+        if result:
+            return result
+
+    return {}
+
+
+def get_water_need_prediction_data(farm=None):
+    default_data = deepcopy(EMPTY_WATER_NEED_PREDICTION)
+    result = _get_latest_irrigation_result(farm)
+    water_balance = result.get("water_balance", {})
+    daily = water_balance.get("daily", [])
+
+    if not daily:
+        return default_data
+
+    categories = [item.get("forecast_date") or f"روز {index + 1}" for index, item in enumerate(daily)]
+    series_data = [float(item.get("gross_irrigation_mm") or 0) for item in daily]
+
+    return {
+        "totalNext7Days": round(sum(series_data), 2),
+        "unit": "mm",
+        "categories": categories,
+        "series": [{"name": "نیاز آبی", "data": series_data}],
+        "status": "success",
+        "source": "db",
+        "warnings": [],
+    }
+
+
+def get_water_stress_index_data(farm=None):
+    data = deepcopy(EMPTY_WATER_STRESS_INDEX)
+    result = _get_latest_irrigation_result(farm)
+    moisture_level = (result.get("plan") or {}).get("moistureLevel")
+
+    if moisture_level is None:
+        return data
+
+    stress_value = max(0, round(80 - float(moisture_level)))
+    if stress_value <= 15:
+        data["chipText"] = "پایین"
+        data["chipColor"] = "success"
+        data["avatarColor"] = "info"
+    elif stress_value <= 30:
+        data["chipText"] = "متوسط"
+        data["chipColor"] = "warning"
+        data["avatarColor"] = "warning"
+    else:
+        data["chipText"] = "بالا"
+        data["chipColor"] = "error"
+        data["avatarColor"] = "error"
+
+    data["stats"] = f"{stress_value}%"
+    data["status"] = "success"
+    data["source"] = "db"
+    data["warnings"] = []
+    return data
+
+
+def get_water_summary_data(farm=None):
+    return {
+        "farmWeatherCard": get_farm_weather_card_data(farm),
+        "waterNeedPrediction": get_water_need_prediction_data(farm),
+        "waterStressIndex": get_water_stress_index_data(farm),
+    }

Modules/Backend/water/tests.py

@@ -0,0 +1,200 @@
+from unittest.mock import patch
+
+from django.core.cache import cache
+from django.contrib.auth import get_user_model
+from django.test import TestCase, override_settings
+from django.urls import Resolver404, 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 WaterNeedPredictionView, WaterSummaryView, WeatherFarmCardView
+
+
+TEST_CACHES = {
+    "default": {
+        "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
+        "LOCATION": "water-tests",
+    }
+}
+
+TEST_WATER_NEED_PREDICTION_CACHE_TTL = 14400
+
+
+@override_settings(
+    CACHES=TEST_CACHES,
+    WATER_NEED_PREDICTION_CACHE_TTL=TEST_WATER_NEED_PREDICTION_CACHE_TTL,
+)
+class WeatherViewTests(TestCase):
+    def setUp(self):
+        cache.clear()
+        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("water.views.external_api_request")
+    def test_farm_card_proxies_to_ai_service(self, mock_external_api_request):
+        mock_external_api_request.return_value = AdapterResponse(
+            status_code=200,
+            data={"data": {"result": {"condition": "صاف", "temperature": 28.0}}},
+        )
+
+        request = self.factory.post("/api/weather/farm-card/", {"farm_uuid": str(self.farm.farm_uuid)}, format="json")
+        force_authenticate(request, user=self.user)
+
+        response = WeatherFarmCardView.as_view()(request)
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["code"], 200)
+        self.assertEqual(response.data["data"]["condition"], "صاف")
+        mock_external_api_request.assert_called_once_with(
+            "ai",
+            "/api/weather/farm-card/",
+            method="POST",
+            payload={"farm_uuid": str(self.farm.farm_uuid)},
+        )
+
+    @patch("water.views.external_api_request")
+    def test_get_water_need_prediction_uses_same_ai_service_for_farm_uuid(self, mock_external_api_request):
+        mock_external_api_request.return_value = AdapterResponse(
+            status_code=200,
+            data={"data": {"result": {"totalNext7Days": 24.6, "unit": "mm"}}},
+        )
+
+        request = self.factory.get(f"/api/water/need-prediction/?farm_uuid={self.farm.farm_uuid}")
+
+        response = WaterNeedPredictionView.as_view()(request)
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["data"]["farm_uuid"], str(self.farm.farm_uuid))
+        self.assertEqual(response.data["data"]["totalNext7Days"], 24.6)
+        mock_external_api_request.assert_called_once_with(
+            "ai",
+            "/api/weather/water-need-prediction/",
+            method="POST",
+            payload={"farm_uuid": str(self.farm.farm_uuid)},
+        )
+
+    @patch("water.views.external_api_request")
+    def test_water_need_prediction_caches_last_four_ai_responses(self, mock_external_api_request):
+        farms = []
+        for index in range(5):
+            farm = FarmHub.objects.create(owner=self.user, farm_type=self.farm_type, name=f"Farm Cache {index}")
+            farms.append(farm)
+
+            mock_external_api_request.return_value = AdapterResponse(
+                status_code=200,
+                data={"data": {"result": {"totalNext7Days": float(index), "unit": "mm"}}},
+            )
+
+            request = self.factory.get(f"/api/water/need-prediction/?farm_uuid={farm.farm_uuid}")
+            response = WaterNeedPredictionView.as_view()(request)
+
+            self.assertEqual(response.status_code, 200)
+
+        cached_items = cache.get(WeatherFarmCardView.WATER_NEED_PREDICTION_CACHE_KEY)
+
+        self.assertEqual(len(cached_items), 4)
+        self.assertEqual(cached_items[0]["totalNext7Days"], 4.0)
+        self.assertEqual(cached_items[-1]["totalNext7Days"], 1.0)
+
+    @patch("water.views.external_api_request")
+    def test_water_need_prediction_returns_cached_response_for_same_farm(self, mock_external_api_request):
+        mock_external_api_request.return_value = AdapterResponse(
+            status_code=200,
+            data={"data": {"result": {"totalNext7Days": 24.6, "unit": "mm"}}},
+        )
+
+        for _ in range(2):
+            request = self.factory.get(f"/api/water/need-prediction/?farm_uuid={self.farm.farm_uuid}")
+            force_authenticate(request, user=self.user)
+            response = WaterNeedPredictionView.as_view()(request)
+
+            self.assertEqual(response.status_code, 200)
+            self.assertEqual(response.data["data"]["farm_uuid"], str(self.farm.farm_uuid))
+
+        cache_key = WeatherFarmCardView._build_water_need_prediction_cache_key(self.user.id, self.farm.farm_uuid)
+        self.assertEqual(cache.get(cache_key)["totalNext7Days"], 24.6)
+        mock_external_api_request.assert_called_once()
+
+    @patch("water.views.cache.set")
+    @patch("water.views.external_api_request")
+    def test_water_need_prediction_uses_env_ttl_for_cache(self, mock_external_api_request, mock_cache_set):
+        mock_external_api_request.return_value = AdapterResponse(
+            status_code=200,
+            data={"data": {"result": {"totalNext7Days": 24.6, "unit": "mm"}}},
+        )
+
+        request = self.factory.get(f"/api/water/need-prediction/?farm_uuid={self.farm.farm_uuid}")
+        force_authenticate(request, user=self.user)
+        response = WaterNeedPredictionView.as_view()(request)
+
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(
+            any(call.kwargs.get("timeout") == TEST_WATER_NEED_PREDICTION_CACHE_TTL for call in mock_cache_set.call_args_list)
+        )
+
+    def test_water_summary_caches_last_four_responses(self):
+        for index in range(5):
+            farm = FarmHub.objects.create(owner=self.user, farm_type=self.farm_type, name=f"Summary Farm {index}")
+            request = self.factory.get(f"/api/water/summary/?farm_uuid={farm.farm_uuid}")
+            response = WaterSummaryView.as_view()(request)
+
+            self.assertEqual(response.status_code, 200)
+            cached_items = cache.get(WeatherFarmCardView.WATER_SUMMARY_CACHE_KEY)
+            cached_items[0]["farmWeatherCard"]["condition"] = f"Condition {index}"
+            cache.set(WeatherFarmCardView.WATER_SUMMARY_CACHE_KEY, cached_items, timeout=None)
+
+        cached_items = cache.get(WeatherFarmCardView.WATER_SUMMARY_CACHE_KEY)
+
+        self.assertEqual(len(cached_items), 4)
+        self.assertEqual(cached_items[0]["farmWeatherCard"]["condition"], "Condition 4")
+        self.assertEqual(cached_items[-1]["farmWeatherCard"]["condition"], "Condition 1")
+
+    def test_weather_view_rejects_foreign_farm_uuid(self):
+        request = self.factory.post("/api/weather/farm-card/", {"farm_uuid": str(self.other_farm.farm_uuid)}, format="json")
+        force_authenticate(request, user=self.user)
+
+        response = WeatherFarmCardView.as_view()(request)
+
+        self.assertEqual(response.status_code, 404)
+        self.assertEqual(response.data["code"], 404)
+
+    def test_weather_post_routes_exist_only_under_weather_prefix(self):
+        self.assertIs(resolve("/api/weather/farm-card/").func.view_class, WeatherFarmCardView)
+
+        with self.assertRaises(Resolver404):
+            resolve("/api/water/farm-card/")
+
+        with self.assertRaises(Resolver404):
+            resolve("/api/water/water-need-prediction/")
+
+    def test_water_get_routes_do_not_exist_under_weather_prefix(self):
+        with self.assertRaises(Resolver404):
+            resolve("/api/weather/card/")
+
+        with self.assertRaises(Resolver404):
+            resolve("/api/weather/need-prediction/")
+
+        with self.assertRaises(Resolver404):
+            resolve("/api/weather/water-need-prediction/")
+
+        with self.assertRaises(Resolver404):
+            resolve("/api/weather/stress-index/")
+
+        with self.assertRaises(Resolver404):
+            resolve("/api/weather/summary/")

Modules/Backend/water/urls.py

@@ -0,0 +1,10 @@
+from django.urls import path
+
+from .views import FarmWeatherCardView, WaterNeedPredictionView, WaterStressIndexView, WaterSummaryView
+
+urlpatterns = [
+    path("card/", FarmWeatherCardView.as_view(), name="water-card"),
+    path("need-prediction/", WaterNeedPredictionView.as_view(), name="water-need-prediction"),
+    path("stress-index/", WaterStressIndexView.as_view(), name="water-stress-index"),
+    path("summary/", WaterSummaryView.as_view(), name="water-summary"),
+]

Modules/Backend/water/views.py

@@ -0,0 +1,347 @@
+"""
+WATER API views.
+"""
+
+from django.conf import settings
+from django.core.cache import cache
+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 config.swagger import farm_uuid_query_param, sensor_uuid_query_param, status_response
+from external_api_adapter import request as external_api_request
+from farm_hub.models import FarmHub
+from .models import WeatherForecastLog
+from .serializers import (
+    FarmWeatherCardSerializer,
+    WaterNeedPredictionSerializer,
+    WaterStressIndexSerializer,
+    WaterSummarySerializer,
+    WeatherFarmCardRequestSerializer,
+)
+from .services import get_water_need_prediction_data, get_water_stress_index_data, get_water_summary_data
+
+
+class FarmWeatherCardView(APIView):
+    """
+    GET endpoint for the farm weather card dashboard data.
+
+    Purpose:
+        Returns current weather conditions and an intraday temperature chart
+        for a given farm. Data is fetched from the AI external adapter.
+        If farm_uuid is provided and the farm exists, the result is persisted
+        in WeatherForecastLog for historical reference.
+
+    Input parameters:
+        - farm_uuid (query, optional): UUID of the farm.
+
+    Response structure:
+        - status: string, always "success".
+        - data: object matching the farmWeatherCard shape — condition,
+          temperature, unit, humidity, windSpeed, windUnit, chartData.
+    """
+
+    @extend_schema(
+        tags=["WATER"],
+        parameters=[
+            farm_uuid_query_param(required=False, description="UUID of the farm to fetch weather data for."),
+        ],
+        responses={200: status_response("FarmWeatherCardResponse", data=FarmWeatherCardSerializer())},
+    )
+    def get(self, request):
+        farm_uuid = request.query_params.get("farm_uuid")
+        query = {"farm_uuid": str(farm_uuid)} if farm_uuid else {}
+
+        adapter_response = external_api_request(
+            "ai",
+            "/weather-forecast/card",
+            method="GET",
+            query=query,
+        )
+
+        response_data = adapter_response.data if isinstance(adapter_response.data, dict) else {}
+        card_data = response_data.get("result", response_data.get("data", response_data))
+
+        self._persist_log(farm_uuid, card_data)
+
+        return Response(
+            {"status": "success", "data": card_data},
+            status=status.HTTP_200_OK,
+        )
+
+    @staticmethod
+    def _persist_log(farm_uuid, card_data):
+        farm = None
+        if farm_uuid:
+            try:
+                farm = FarmHub.objects.get(farm_uuid=farm_uuid)
+            except (FarmHub.DoesNotExist, Exception):
+                pass
+
+        WeatherForecastLog.objects.create(
+            farm=farm,
+            condition=card_data.get("condition", ""),
+            temperature=card_data.get("temperature"),
+            unit=card_data.get("unit", "°C"),
+            humidity=card_data.get("humidity"),
+            wind_speed=card_data.get("windSpeed"),
+            wind_unit=card_data.get("windUnit", "km/h"),
+            chart_data=card_data.get("chartData", {}),
+        )
+
+
+class WeatherFarmBaseView(APIView):
+    WATER_NEED_PREDICTION_CACHE_KEY = "water:need-prediction:recent"
+    WATER_NEED_PREDICTION_CACHE_LIMIT = 4
+    WATER_SUMMARY_CACHE_KEY = "water:summary:recent"
+    WATER_SUMMARY_CACHE_LIMIT = 4
+
+    @classmethod
+    def _store_recent_entries(cls, cache_key, cache_limit, payload):
+        cached_items = cache.get(cache_key, [])
+        if not isinstance(cached_items, list):
+            cached_items = []
+
+        cached_items.insert(0, payload)
+        cache.set(cache_key, cached_items[:cache_limit], timeout=None)
+
+    @classmethod
+    def _store_recent_water_need_prediction(cls, payload):
+        cls._store_recent_entries(cls.WATER_NEED_PREDICTION_CACHE_KEY, cls.WATER_NEED_PREDICTION_CACHE_LIMIT, payload)
+
+    @classmethod
+    def _store_recent_water_summary(cls, payload):
+        cls._store_recent_entries(cls.WATER_SUMMARY_CACHE_KEY, cls.WATER_SUMMARY_CACHE_LIMIT, payload)
+
+    @staticmethod
+    def _build_water_need_prediction_cache_key(user_id, farm_uuid):
+        return f"water:need-prediction:{user_id}:{farm_uuid}"
+
+    @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,
+            )
+
+    @staticmethod
+    def _extract_result(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["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(
+            {"code": adapter_response.status_code, "msg": "error", "data": response_data},
+            status=adapter_response.status_code,
+        )
+
+    @classmethod
+    def _fetch_water_need_prediction_data(cls, farm_uuid):
+        adapter_response = external_api_request(
+            "ai",
+            "/api/weather/water-need-prediction/",
+            method="POST",
+            payload={"farm_uuid": str(farm_uuid)},
+        )
+        if adapter_response.status_code >= 400:
+            return None, cls._error_response(adapter_response)
+
+        prediction_data = cls._extract_result(adapter_response.data)
+        if isinstance(prediction_data, dict):
+            prediction_data.setdefault("farm_uuid", str(farm_uuid))
+        return prediction_data, None
+
+
+class WeatherFarmCardView(WeatherFarmBaseView):
+    @extend_schema(
+        tags=["WEATHER"],
+        request=WeatherFarmCardRequestSerializer,
+        responses={200: status_response("WeatherFarmCardResponse", data=FarmWeatherCardSerializer())},
+    )
+    def post(self, request):
+        farm, error_response = self._get_farm(request, request.data.get("farm_uuid"))
+        if error_response is not None:
+            return error_response
+
+        adapter_response = external_api_request(
+            "ai",
+            "/api/weather/farm-card/",
+            method="POST",
+            payload={"farm_uuid": str(farm.farm_uuid)},
+        )
+        if adapter_response.status_code >= 400:
+            return self._error_response(adapter_response)
+
+        card_data = self._extract_result(adapter_response.data)
+        FarmWeatherCardView._persist_log(farm.farm_uuid, card_data)
+        return Response({"code": 200, "msg": "success", "data": card_data}, status=status.HTTP_200_OK)
+
+
+class WaterNeedPredictionView(APIView):
+    @extend_schema(
+        tags=["WATER"],
+        parameters=[
+            farm_uuid_query_param(required=False, description="UUID of the farm to fetch water need prediction for."),
+        ],
+        responses={200: status_response("WaterNeedPredictionResponse", data=WaterNeedPredictionSerializer())},
+    )
+    def get(self, request):
+        farm_uuid = request.query_params.get("farm_uuid")
+        if farm_uuid:
+            try:
+                farm = FarmHub.objects.get(farm_uuid=farm_uuid)
+            except (FarmHub.DoesNotExist, Exception):
+                farm = None
+            else:
+                cache_key = WeatherFarmBaseView._build_water_need_prediction_cache_key(
+                    getattr(request.user, "id", "anonymous"),
+                    farm.farm_uuid,
+                )
+                cached_prediction = cache.get(cache_key)
+                if isinstance(cached_prediction, dict):
+                    return Response(
+                        {"status": "success", "data": cached_prediction},
+                        status=status.HTTP_200_OK,
+                    )
+
+                prediction_data, error_response = WeatherFarmBaseView._fetch_water_need_prediction_data(farm.farm_uuid)
+                if error_response is not None:
+                    return error_response
+                cache.set(cache_key, prediction_data, timeout=settings.WATER_NEED_PREDICTION_CACHE_TTL)
+                WeatherFarmBaseView._store_recent_water_need_prediction(prediction_data)
+                return Response(
+                    {"status": "success", "data": prediction_data},
+                    status=status.HTTP_200_OK,
+                )
+        else:
+            farm = None
+
+        return Response(
+            {"status": "success", "data": get_water_need_prediction_data(farm)},
+            status=status.HTTP_200_OK,
+        )
+
+
+class WaterStressIndexView(APIView):
+    @staticmethod
+    def _get_farm(farm_uuid):
+        if not farm_uuid:
+            raise serializers.ValidationError({"farm_uuid": ["This field is required."]})
+        try:
+            return FarmHub.objects.get(farm_uuid=farm_uuid)
+        except FarmHub.DoesNotExist as exc:
+            raise serializers.ValidationError({"farm_uuid": ["Farm not found."]}) from exc
+
+    @staticmethod
+    def extract_stress_payload(adapter_data, farm_uuid):
+        if not isinstance(adapter_data, dict):
+            return {
+                "farm_uuid": str(farm_uuid),
+                "waterStressIndex": 0,
+                "level": "",
+                "sourceMetric": {},
+            }
+
+        data = adapter_data.get("data") if isinstance(adapter_data.get("data"), dict) else adapter_data
+        result = data.get("result") if isinstance(data, dict) and isinstance(data.get("result"), dict) else data
+
+        return {
+            "farm_uuid": str(farm_uuid),
+            "waterStressIndex": int(result.get("waterStressIndex") or 0),
+            "level": str(result.get("level") or ""),
+            "sourceMetric": result.get("sourceMetric") if isinstance(result.get("sourceMetric"), dict) else {},
+        }
+
+    @extend_schema(
+        tags=["WATER"],
+        parameters=[
+            farm_uuid_query_param(required=True, description="UUID of the farm to fetch water stress index for."),
+            sensor_uuid_query_param(),
+        ],
+        responses={200: status_response("WaterStressIndexResponse", data=WaterStressIndexSerializer())},
+    )
+    def get(self, request):
+        farm_uuid = request.query_params.get("farm_uuid")
+        sensor_uuid = request.query_params.get("sensor_uuid")
+        farm = self._get_farm(farm_uuid)
+
+        query = {"farm_uuid": str(farm.farm_uuid)}
+        if sensor_uuid:
+            query["sensor_uuid"] = str(sensor_uuid)
+
+        adapter_response = external_api_request(
+            "ai",
+            "/api/water/stress-index/",
+            method="GET",
+            query=query,
+        )
+
+        if adapter_response.status_code >= 400:
+            return Response(
+                {
+                    "code": adapter_response.status_code,
+                    "msg": "error",
+                    "data": adapter_response.data if isinstance(adapter_response.data, dict) else {"message": str(adapter_response.data)},
+                },
+                status=adapter_response.status_code,
+            )
+
+        stress_payload = self.extract_stress_payload(adapter_response.data, farm.farm_uuid)
+
+        return Response(
+            {"code": 200, "msg": "success", "data": stress_payload},
+            status=status.HTTP_200_OK,
+        )
+
+
+class WaterSummaryView(APIView):
+    @extend_schema(
+        tags=["WATER"],
+        parameters=[
+            farm_uuid_query_param(required=False, description="UUID of the farm to fetch water summary for."),
+        ],
+        responses={200: status_response("WaterSummaryResponse", data=WaterSummarySerializer())},
+    )
+    def get(self, request):
+        farm = None
+        farm_uuid = request.query_params.get("farm_uuid")
+        if farm_uuid:
+            try:
+                farm = FarmHub.objects.get(farm_uuid=farm_uuid)
+            except (FarmHub.DoesNotExist, Exception):
+                farm = None
+
+        summary_data = get_water_summary_data(farm)
+        WeatherFarmBaseView._store_recent_water_summary(summary_data)
+        return Response(
+            {"status": "success", "data": summary_data},
+            status=status.HTTP_200_OK,
+        )

Modules/Backend/water/weather_urls.py

@@ -0,0 +1,7 @@
+from django.urls import path
+
+from .views import WeatherFarmCardView
+
+urlpatterns = [
+    path("farm-card/", WeatherFarmCardView.as_view(), name="weather-farm-card"),
+]