Merge pull request #32 from wmo-raf/forecast_post_api

enable adding city forecasts via post request

Author: Grace-Amondi

.gitignore

@@ -170,3 +170,4 @@ cython_debug/
 .DS_Store
 
 # End of https://www.toptal.com/developers/gitignore/api/django
+.vscode

forecastmanager/forecast_settings.py

@@ -71,7 +71,7 @@ def effective_periods(self):
         return [
             {"label": period.label, "time": period.forecast_effective_time}
             for period in self.periods.all()]
-    
+
     @property
     def weather_conditions_list(self):
         weather_conditions = self.weather_conditions.all()

forecastmanager/serializers.py

@@ -1,6 +1,10 @@
+from django.db import transaction
+from django.db.models import Q
+from uuid import UUID
 from rest_framework import serializers
 
-from .models import City, Forecast
+from .forecast_settings import ForecastPeriod, WeatherCondition, ForecastDataParameters
+from .models import City, Forecast, CityForecast, DataValue
 
 
 class CitySerializer(serializers.ModelSerializer):
@@ -24,3 +28,157 @@ def to_representation(self, instance):
         request = self.context.get("request")
 
         return instance.get_geojson(request)
+
+
+class CityForecastPostSerializer(serializers.Serializer):
+    city = serializers.CharField()
+    condition = serializers.CharField()
+    data_values = serializers.DictField(
+        child=serializers.JSONField(),
+        required=False,
+        default=dict,
+    )
+
+    def validate(self, attrs):
+        city_ref = attrs.get("city")
+        condition_ref = attrs.get("condition")
+        data_values = attrs.get("data_values") or {}
+
+        city_query = Q(name__iexact=city_ref) | Q(slug__iexact=city_ref)
+        try:
+            city_uuid = UUID(str(city_ref))
+            city_query = city_query | Q(id=city_uuid)
+        except (ValueError, TypeError):
+            pass
+
+        city_obj = City.objects.filter(city_query).first()
+
+        if not city_obj:
+            raise serializers.ValidationError({"city": f"Unknown city: {city_ref}"})
+
+        condition_obj = WeatherCondition.objects.filter(
+            Q(symbol__iexact=condition_ref) |
+            Q(label__iexact=condition_ref) |
+            Q(alias__iexact=condition_ref)
+        ).first()
+
+        if not condition_obj:
+            raise serializers.ValidationError({"condition": f"Unknown weather condition: {condition_ref}"})
+
+        normalized_data_values = []
+        for parameter_key, value in data_values.items():
+            parameter_obj = ForecastDataParameters.objects.filter(
+                Q(parameter__iexact=parameter_key) |
+                Q(name__iexact=parameter_key)
+            ).first()
+
+            if not parameter_obj:
+                raise serializers.ValidationError(
+                    {"data_values": f"Unknown parameter: {parameter_key}"}
+                )
+
+            if value is None or value == "":
+                continue
+
+            if parameter_obj.parameter_type == "numeric":
+                try:
+                    float(value)
+                except (TypeError, ValueError):
+                    raise serializers.ValidationError(
+                        {
+                            "data_values": (
+                                f"Invalid numeric value for '{parameter_key}': {value}"
+                            )
+                        }
+                    )
+
+            normalized_data_values.append({
+                "parameter": parameter_obj,
+                "value": str(value),
+            })
+
+        attrs["city_obj"] = city_obj
+        attrs["condition_obj"] = condition_obj
+        attrs["resolved_data_values"] = normalized_data_values
+        return attrs
+
+
+class ForecastPostSerializer(serializers.Serializer):
+    forecast_date = serializers.DateField()
+    effective_time = serializers.TimeField(help_text="Forecast effective time, e.g. '06:00:00'")
+    source = serializers.ChoiceField(
+        choices=[choice[0] for choice in Forecast.FORECAST_SOURCE_CHOICES],
+        required=False,
+        default="local",
+    )
+    replace_existing = serializers.BooleanField(required=False, default=True)
+    city_forecasts = CityForecastPostSerializer(many=True)
+
+    def validate_city_forecasts(self, value):
+        if not value:
+            raise serializers.ValidationError("At least one city forecast is required.")
+
+        seen = set()
+        for city_forecast in value:
+            city_id = str(city_forecast["city_obj"].id)
+            if city_id in seen:
+                raise serializers.ValidationError(
+                    f"Duplicate city in payload: {city_forecast['city_obj'].name}"
+                )
+            seen.add(city_id)
+
+        return value
+
+    def validate(self, attrs):
+        effective_time = attrs.get("effective_time")
+        period_obj = ForecastPeriod.objects.filter(forecast_effective_time=effective_time).first()
+        if not period_obj:
+            raise serializers.ValidationError({"effective_time": f"No ForecastPeriod found for time {effective_time}"})
+        attrs["effective_period"] = period_obj
+        return attrs
+
+    @transaction.atomic
+    def create(self, validated_data):
+        city_forecasts = validated_data.pop("city_forecasts")
+        replace_existing = validated_data.pop("replace_existing", True)
+        effective_period = validated_data.pop("effective_period")
+
+        existing_forecasts = Forecast.objects.filter(
+            forecast_date=validated_data["forecast_date"],
+            effective_period=effective_period,
+        )
+
+        if existing_forecasts.exists():
+            if not replace_existing:
+                raise serializers.ValidationError(
+                    "Forecast already exists for this date and effective period. "
+                    "Set replace_existing=true to overwrite it."
+                )
+            existing_forecasts.delete()
+
+        forecast = Forecast.objects.create(
+            forecast_date=validated_data["forecast_date"],
+            effective_period=effective_period,
+            source=validated_data.get("source", "local")
+        )
+
+        for city_forecast_data in city_forecasts:
+            city_forecast = CityForecast.objects.create(
+                parent=forecast,
+                city=city_forecast_data["city_obj"],
+                condition=city_forecast_data["condition_obj"],
+            )
+
+            data_values = [
+                DataValue(
+                    parent=city_forecast,
+                    parameter=data_value["parameter"],
+                    value=data_value["value"],
+                )
+                for data_value in city_forecast_data["resolved_data_values"]
+            ]
+
+            if data_values:
+                DataValue.objects.bulk_create(data_values)
+
+        return forecast

forecastmanager/templatetags/forecastmanager_tags.py

@@ -3,6 +3,7 @@
 from .views import (
     CityListView,
     ForecastListView,
+    ForecastPostView,
     download_forecast_template,
     weather_icons,
     forecast_settings
@@ -11,7 +12,8 @@
 urlpatterns = [
     path('api/cities', CityListView.as_view(), name='cities-list'),
     path('api/forecasts', ForecastListView.as_view(), name='forecast-list'),
+    path('api/forecasts/post', ForecastPostView.as_view(), name='forecast-post'),
     path('api/forecast-settings', forecast_settings, name='forecast-settings'),
     path('api/weather-icons', weather_icons, name='weather-icons'),
-    path('api/forecast_templace.csv', download_forecast_template, name='download-forecast-template'),
+    path('api/forecast_template.csv', download_forecast_template, name='download-forecast-template'),
 ]

forecastmanager/urls.py

@@ -7,14 +7,17 @@
 from django.urls import reverse
 from django.utils import timezone
 from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
 from rest_framework.generics import ListAPIView
 from rest_framework.permissions import BasePermission, IsAuthenticated, SAFE_METHODS
 from wagtail.api.v2.utils import get_full_url
 
 from forecastmanager.models import City, Forecast
 from .forecast_settings import ForecastSetting
 from .forms import CityLoaderForm
-from .serializers import CitySerializer, ForecastSerializer
+from .serializers import CitySerializer, ForecastSerializer, ForecastPostSerializer
 from .utils import get_weather_condition_icons
 
 
@@ -49,6 +52,21 @@ def get_queryset(self):
         return queryset
 
 
+class ForecastPostView(APIView):
+    permission_classes = [IsAuthenticated]
+
+    def post(self, request, *args, **kwargs):
+        serializer = ForecastPostSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        forecast = serializer.save()
+
+        response_data = {
+            "message": "Forecast data pushed successfully.",
+            "forecast": ForecastSerializer(forecast, context={"request": request}).data,
+        }
+        return Response(response_data, status=status.HTTP_201_CREATED)
+
+
 def download_forecast_template(request):
     response = HttpResponse(content_type='text/csv')
     response['Content-Disposition'] = 'attachment; filename="forecast_template.csv"'

forecastmanager/views.py

@@ -20,39 +20,18 @@ class HomePage(Page):
     ]
 
     def get_context(self, request, *args, **kwargs):
-        context = super().get_context(request, *args, **kwargs)
-        fm_settings = ForecastSetting.for_request(request)
-        city_detail_page = fm_settings.weather_detail_page
-        city_detail_page_url = None
-
-        if city_detail_page:
-            city_detail_page = city_detail_page.specific
-            city_detail_page_url = city_detail_page.get_full_url(request)
-            city_detail_page_url = city_detail_page_url + city_detail_page.reverse_subpage("forecast_for_city")
-            context.update({
-                "city_detail_page_url": city_detail_page_url,
-            })
-
+        context = super(HomePage, self).get_context(request, *args, **kwargs)        
+        
         city_search_url = get_full_url(request, reverse("cities-list"))
         context.update({
             "city_search_url": city_search_url,
-            "city_detail_page_url": city_detail_page_url
         })
-
-        default_city = fm_settings.default_city
-        if not default_city:
-            default_city = City.objects.first()
-
-        if default_city:
-            default_city_forecasts = CityForecast.objects.filter(
-                city=default_city,
-                parent__forecast_date__gte=timezone.localtime()
-            ).order_by("parent__forecast_date")
-
-            context.update({
-                "default_city_forecasts": default_city_forecasts
-            })
-
+        
+        context.update({
+            "home_weather_widget_url": get_full_url(request, reverse("home-weather-widget")),
+        })
+        
+        
         return context