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-27 00:40:59 +03:30
parent 2cd96ceec6
commit 64e67c282c
56 changed files with 3912 additions and 745 deletions
Download Patch File Download Diff File Expand all files Collapse all files
water/serializers.py
+18 -17
View File
@@ -10,12 +10,12 @@ class WeatherChartDataSerializer(serializers.Serializer):
class FarmWeatherCardSerializer(serializers.Serializer):
condition = serializers.CharField(required=False, allow_blank=True)
temperature = serializers.FloatField(required=False)
unit = serializers.CharField(required=False, allow_blank=True)
humidity = serializers.IntegerField(required=False)
windSpeed = serializers.FloatField(required=False)
windUnit = serializers.CharField(required=False, allow_blank=True)
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)
@@ -25,21 +25,22 @@ class WaterNeedSeriesSerializer(serializers.Serializer):
class WaterNeedPredictionSerializer(serializers.Serializer):
totalNext7Days = serializers.FloatField(required=False)
unit = serializers.CharField(required=False, allow_blank=True)
categories = serializers.ListField(child=serializers.CharField(), required=False)
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):
id = serializers.CharField(required=False, allow_blank=True)
title = serializers.CharField(required=False, allow_blank=True)
subtitle = serializers.CharField(required=False, allow_blank=True)
stats = serializers.CharField(required=False, allow_blank=True)
avatarColor = serializers.CharField(required=False, allow_blank=True)
avatarIcon = serializers.CharField(required=False, allow_blank=True)
chipText = serializers.CharField(required=False, allow_blank=True)
chipColor = serializers.CharField(required=False, allow_blank=True)
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):
water/tests.py
+108
View File
@@ -0,0 +1,108 @@
from unittest.mock import patch
from django.contrib.auth import get_user_model
from django.test import TestCase
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
class WeatherViewTests(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("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)},
)
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/")
water/views.py
+158 -40
View File
@@ -8,7 +8,7 @@ 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 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
@@ -38,13 +38,7 @@ class FarmWeatherCardView(APIView):
@extend_schema(
tags=["WATER"],
parameters=[
OpenApiParameter(
name="farm_uuid",
type=OpenApiTypes.UUID,
location=OpenApiParameter.QUERY,
required=False,
description="UUID of the farm to fetch weather data for.",
default="11111111-1111-1111-1111-111111111111"),
farm_uuid_query_param(required=False, description="UUID of the farm to fetch weather data for."),
],
responses={200: status_response("FarmWeatherCardResponse", data=FarmWeatherCardSerializer())},
)
@@ -90,29 +84,118 @@ class FarmWeatherCardView(APIView):
)
class WeatherFarmBaseView(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,
)
@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=serializers.Serializer,
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=[
OpenApiParameter(
name="farm_uuid",
type=OpenApiTypes.UUID,
location=OpenApiParameter.QUERY,
required=False,
description="UUID of the farm to fetch water need prediction for.",
default="11111111-1111-1111-1111-111111111111",
),
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 = 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
else:
prediction_data, error_response = WeatherFarmBaseView._fetch_water_need_prediction_data(farm.farm_uuid)
if error_response is not None:
return error_response
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)},
@@ -121,31 +204,73 @@ class WaterNeedPredictionView(APIView):
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=[
OpenApiParameter(
name="farm_uuid",
type=OpenApiTypes.UUID,
location=OpenApiParameter.QUERY,
required=False,
description="UUID of the farm to fetch water stress index for.",
default="11111111-1111-1111-1111-111111111111",
),
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 = 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
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(
{"status": "success", "data": get_water_stress_index_data(farm)},
{"code": 200, "msg": "success", "data": stress_payload},
status=status.HTTP_200_OK,
)
@@ -154,14 +279,7 @@ class WaterSummaryView(APIView):
@extend_schema(
tags=["WATER"],
parameters=[
OpenApiParameter(
name="farm_uuid",
type=OpenApiTypes.UUID,
location=OpenApiParameter.QUERY,
required=False,
description="UUID of the farm to fetch water summary for.",
default="11111111-1111-1111-1111-111111111111",
),
farm_uuid_query_param(required=False, description="UUID of the farm to fetch water summary for."),
],
responses={200: status_response("WaterSummaryResponse", data=WaterSummarySerializer())},
)
water/weather_urls.py
+7
View File
@@ -0,0 +1,7 @@
from django.urls import path
from .views import WeatherFarmCardView
urlpatterns = [
path("farm-card/", WeatherFarmCardView.as_view(), name="weather-farm-card"),
]