sajad-dev/Backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

UPDATE

Browse Source
This commit is contained in:
Mohammad Sajad Pourajam
2026-04-30 01:01:04 +03:30
parent 8139a49756
commit 5d8ad57b2d
21 changed files with 1841 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files
water/serializers.py
+8
View File
@@ -1,6 +1,14 @@
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(
water/tests.py
+94 -2
View File
@@ -1,18 +1,34 @@
from unittest.mock import patch
from django.core.cache import cache
from django.contrib.auth import get_user_model
from django.test import TestCase
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, WeatherFarmCardView
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",
@@ -73,6 +89,82 @@ class WeatherViewTests(TestCase):
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)
water/views.py
+52 -3
View File
@@ -2,6 +2,8 @@
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
@@ -12,7 +14,13 @@ from config.swagger import farm_uuid_query_param, sensor_uuid_query_param, statu
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
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
@@ -85,6 +93,32 @@ class FarmWeatherCardView(APIView):
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:
@@ -149,7 +183,7 @@ class WeatherFarmBaseView(APIView):
class WeatherFarmCardView(WeatherFarmBaseView):
@extend_schema(
tags=["WEATHER"],
request=serializers.Serializer,
request=WeatherFarmCardRequestSerializer,
responses={200: status_response("WeatherFarmCardResponse", data=FarmWeatherCardSerializer())},
)
def post(self, request):
@@ -187,9 +221,22 @@ class WaterNeedPredictionView(APIView):
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,
@@ -292,7 +339,9 @@ class WaterSummaryView(APIView):
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": get_water_summary_data(farm)},
{"status": "success", "data": summary_data},
status=status.HTTP_200_OK,
)