144 lines
5.6 KiB
Python
144 lines
5.6 KiB
Python
import logging
|
|
|
|
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 config.failure_contract import StructuredServiceError
|
|
from config.swagger import status_response
|
|
from external_api_adapter import request as external_api_request
|
|
from external_api_adapter.exceptions import ExternalAPIRequestError
|
|
from farm_hub.models import FarmHub
|
|
from .models import EconomicOverviewLog
|
|
from .serializers import EconomicOverviewRequestSerializer, EconomicOverviewSerializer
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class EconomicOverviewAdapterError(StructuredServiceError):
|
|
def __init__(self, *, error_code: str, message: str, source: str, retriable: bool = False, details: dict | None = None):
|
|
super().__init__(
|
|
error_code=error_code,
|
|
message=message,
|
|
source=source,
|
|
retriable=retriable,
|
|
details=details,
|
|
)
|
|
|
|
|
|
class EconomyOverviewView(APIView):
|
|
@staticmethod
|
|
def _extract_result_or_error(adapter_data):
|
|
if not isinstance(adapter_data, dict):
|
|
raise EconomicOverviewAdapterError(
|
|
error_code="invalid_payload",
|
|
message="Economic overview adapter returned a non-object payload.",
|
|
source="ai_provider",
|
|
)
|
|
|
|
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
|
|
|
|
raise EconomicOverviewAdapterError(
|
|
error_code="invalid_payload",
|
|
message="Economic overview adapter payload did not contain structured result data.",
|
|
source="ai_provider",
|
|
)
|
|
|
|
@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 _persist_log(farm, overview_data):
|
|
if not isinstance(overview_data, dict):
|
|
raise EconomicOverviewAdapterError(
|
|
error_code="invalid_payload",
|
|
message="Economic overview data must be a JSON object before persistence.",
|
|
source="backend",
|
|
)
|
|
EconomicOverviewLog.objects.create(
|
|
farm=farm,
|
|
economic_data=overview_data.get("economicData", []),
|
|
chart_series=overview_data.get("chartSeries", []),
|
|
chart_categories=overview_data.get("chartCategories", []),
|
|
)
|
|
|
|
@extend_schema(
|
|
tags=["Economy"],
|
|
request=EconomicOverviewRequestSerializer,
|
|
responses={200: status_response("EconomyOverviewResponse", data=EconomicOverviewSerializer())},
|
|
)
|
|
def post(self, request):
|
|
serializer = EconomicOverviewRequestSerializer(data=request.data)
|
|
serializer.is_valid(raise_exception=True)
|
|
|
|
farm, error_response = self._get_farm(request, serializer.validated_data["farm_uuid"])
|
|
if error_response is not None:
|
|
return error_response
|
|
|
|
payload = {"farm_uuid": str(farm.farm_uuid)}
|
|
try:
|
|
adapter_response = external_api_request(
|
|
"ai",
|
|
"/api/economy/overview/",
|
|
method="POST",
|
|
payload=payload,
|
|
)
|
|
except ExternalAPIRequestError as exc:
|
|
logger.error("Economic overview upstream request failed for farm_uuid=%s: %s", farm.farm_uuid, exc)
|
|
failure = EconomicOverviewAdapterError(
|
|
error_code="upstream_unavailable",
|
|
message="Economic overview upstream request failed.",
|
|
source="ai_provider",
|
|
retriable=True,
|
|
details={"farm_uuid": str(farm.farm_uuid)},
|
|
)
|
|
return Response(
|
|
{"code": 503, "msg": "error", "data": failure.to_dict()},
|
|
status=status.HTTP_503_SERVICE_UNAVAILABLE,
|
|
)
|
|
|
|
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,
|
|
)
|
|
|
|
try:
|
|
overview_data = self._extract_result_or_error(adapter_response.data)
|
|
if isinstance(overview_data, dict):
|
|
overview_data.setdefault("farm_uuid", str(farm.farm_uuid))
|
|
self._persist_log(farm, overview_data)
|
|
except EconomicOverviewAdapterError as exc:
|
|
logger.error("Economic overview payload handling failed for farm_uuid=%s: %s", farm.farm_uuid, exc)
|
|
return Response(
|
|
{"code": 502, "msg": "error", "data": exc.to_dict()},
|
|
status=status.HTTP_502_BAD_GATEWAY,
|
|
)
|
|
return Response({"code": 200, "msg": "success", "data": overview_data}, status=status.HTTP_200_OK)
|