new ecap webservices

Dockerfile

@@ -29,4 +29,4 @@ RUN mv ${ENV_FILE} .env
 RUN export $(egrep -v '^#' .env | xargs) && \
     python manage.py collectstatic --noinput && \
     python manage.py compilemessages --locale=fr && \
-    python manage.py migrate health
+    python manage.py migrate

ecap_intra/models.py

@@ -4,29 +4,71 @@
 from sitn.mixins import GeoJSONModelMixin
 
 class ObjetImmobilise(models.Model, GeoJSONModelMixin):
-    idobj = models.CharField(max_length=40, primary_key=True)
-    no_obj = models.BigIntegerField(unique=True)
+    no_obj = models.BigIntegerField(unique=True, primary_key=True)
     statut_obj = models.CharField(max_length=3)
     peggi_id = models.IntegerField()
     geom = models.PointField(srid=settings.DEFAULT_SRID)
 
     PUBLIC_FIELDS = [
-        'idobj',
         'no_obj',
-        'geom',
+        'peggi_id',
     ]
 
     class Meta:
         db_table = 'ecap\".\"ecap05_objets_immobilises_actifs'
         managed = False
 
 
-class RepartitionExpert(models.Model):
+class RepartitionExpert(models.Model, GeoJSONModelMixin):
     idobj = models.CharField(max_length=40, primary_key=True)
     nom_expert = models.CharField(max_length=50)
     ini_expert = models.CharField(max_length=5)
     geom = models.MultiPolygonField(srid=settings.DEFAULT_SRID)
 
+    PUBLIC_FIELDS = [
+        'idobj',
+        'nom_expert',
+        'ini_expert',
+    ]
+
     class Meta:
         db_table = 'ecap\".\"ecap04_experts_sinistre_statistique'
         managed = False
+
+
+class PlanQuartier(models.Model, GeoJSONModelMixin):
+    identifiant_unique_ct = models.CharField(max_length=15, primary_key=True)
+    commune_ct = models.CharField(max_length=25)
+    type_instrument_ct = models.CharField(max_length=20)
+    designation_specifique_ct = models.CharField(max_length=180, null=True)
+    geom = models.MultiPolygonField(srid=settings.DEFAULT_SRID)
+
+    PUBLIC_FIELDS = [
+        'identifiant_unique_ct',
+        'designation_specifique_ct',
+        'type_instrument_ct',
+        'commune_ct',
+    ]
+
+    class Meta:
+        db_table = 'amenagement\".\"at204_plans_quartier'
+        managed = False
+
+
+class PlanSpecial(models.Model, GeoJSONModelMixin):
+    identifiant_unique_ct = models.CharField(max_length=15, primary_key=True)
+    commune_ct = models.CharField(max_length=25)
+    type_instrument_ct = models.CharField(max_length=20)
+    designation_specifique_ct = models.CharField(max_length=180, null=True)
+    geom = models.MultiPolygonField(srid=settings.DEFAULT_SRID)
+
+    PUBLIC_FIELDS = [
+        'identifiant_unique_ct',
+        'designation_specifique_ct',
+        'type_instrument_ct',
+        'commune_ct',
+    ]
+
+    class Meta:
+        db_table = 'amenagement\".\"at205_plans_speciaux'
+        managed = False

ecap_intra/serializers.py

@@ -1,8 +1,38 @@
-from rest_framework_gis import serializers
-from ecap_intra.models import ObjetImmobilise
+from rest_framework_gis.serializers import GeoFeatureModelSerializer
+from rest_framework.serializers import HyperlinkedModelSerializer
 
-class ObjetImmobiliseSerializer(serializers.GeoFeatureModelSerializer):
+from ecap_intra.models import ObjetImmobilise, RepartitionExpert, PlanQuartier, PlanSpecial
+
+
+class ObjetImmobiliseSerializer(GeoFeatureModelSerializer):
     class Meta:
         model = ObjetImmobilise
         geo_field = 'geom'
-        fields = ['no_obj']
+        fields = ObjetImmobilise.PUBLIC_FIELDS + ['url']
+
+
+class RepartitionExpertDigestSerializer(HyperlinkedModelSerializer):
+    class Meta:
+        model = RepartitionExpert
+        fields = RepartitionExpert.PUBLIC_FIELDS + ['url']
+
+
+class RepartitionExpertSerializer(GeoFeatureModelSerializer):
+    class Meta:
+        model = RepartitionExpert
+        geo_field = 'geom'
+        fields = RepartitionExpert.PUBLIC_FIELDS + ['url']
+
+
+class PlanQuartierSerializer(GeoFeatureModelSerializer):
+    class Meta:
+        model = PlanQuartier
+        geo_field = 'geom'
+        fields = PlanQuartier.PUBLIC_FIELDS + ['url']
+
+
+class PlanSpecialSerializer(GeoFeatureModelSerializer):
+    class Meta:
+        model = PlanSpecial
+        geo_field = 'geom'
+        fields = PlanSpecial.PUBLIC_FIELDS + ['url']

ecap_intra/urls.py

@@ -6,6 +6,9 @@
 
 router = SitnRouter()
 router.register(r'ois', views.ObjetImmobiliseViewSet)
+router.register(r'experts', views.RepartitionExpertViewSet)
+router.register(r'plansquartiers', views.PlanQuartierViewSet)
+router.register(r'planspeciaux', views.PlanSpecialViewSet)
 router.register_additional_route_to_root('estate', 'ecap-intra-estate')
 router.register_additional_route_to_root('search', 'ecap-intra-search')
 

ecap_intra/views.py

@@ -1,4 +1,3 @@
-from django.views.generic import TemplateView
 from django.http import HttpResponse, HttpResponseBadRequest
 from djgeojson.serializers import Serializer as GeoJSONSerializer
 from django.contrib.gis.geos import Point
@@ -10,8 +9,21 @@
 from rest_framework_gis.pagination import GeoJsonPagination
 
 from cadastre.models import Mo9Immeubles
-from ecap_intra.models import ObjetImmobilise
-from ecap_intra.serializers import ObjetImmobiliseSerializer
+from sitn.mixins import MultiSerializerMixin
+from ecap_intra.models import (
+    ObjetImmobilise,
+    RepartitionExpert,
+    PlanSpecial,
+    PlanQuartier,
+)
+from ecap_intra.serializers import (
+    ObjetImmobiliseSerializer,
+    RepartitionExpertSerializer,
+    RepartitionExpertDigestSerializer,
+    PlanQuartierSerializer,
+    PlanSpecialSerializer,
+)
+
 
 def is_valid_number(value):
     try:
@@ -20,7 +32,8 @@ def is_valid_number(value):
     except ValueError:
         return False
 
-@api_view(['GET'])
+
+@api_view(["GET"])
 def get_estate(request):
     """
     Retrieves estates found at east and north params.
@@ -29,28 +42,29 @@ def get_estate(request):
     """
     if "east" not in request.GET or "north" not in request.GET:
         return HttpResponseBadRequest("east and north coordinates should be provided")
-    
-    east = request.GET.get('east')
-    north = request.GET.get('north')
+
+    east = request.GET.get("east")
+    north = request.GET.get("north")
 
     if not is_valid_number(east) or not is_valid_number(north):
-        return HttpResponseBadRequest("Invalid parameters: east and north must be valid numbers.")
+        return HttpResponseBadRequest(
+            "Invalid parameters: east and north must be valid numbers."
+        )
 
     intersector = Point(float(east), float(north), srid=settings.DEFAULT_SRID)
 
     if "buffer" in request.GET:
-        buffer = request.GET.get('buffer')
+        buffer = request.GET.get("buffer")
         if not is_valid_number(buffer):
-            return HttpResponseBadRequest("Invalid parameters: buffer must be a valid number.")
+            return HttpResponseBadRequest(
+                "Invalid parameters: buffer must be a valid number."
+            )
         intersector = intersector.buffer(float(buffer))
 
     intersected_estate = Mo9Immeubles.objects.filter(geom__intersects=intersector)[:200]
 
     serializer = GeoJSONSerializer()
-    response_data = serializer.serialize(
-        intersected_estate,
-        srid=settings.DEFAULT_SRID
-    )
+    response_data = serializer.serialize(intersected_estate, srid=settings.DEFAULT_SRID)
 
     return HttpResponse(
         response_data,
@@ -60,16 +74,61 @@ def get_estate(request):
     )
 
 
-class ObjetImmobiliseViewSet(viewsets.ModelViewSet):
+class ObjetImmobiliseViewSet(viewsets.ReadOnlyModelViewSet):
+    """
+    Objects immobilisés actifs
+    """
+
     serializer_class = ObjetImmobiliseSerializer
     pagination_class = GeoJsonPagination
-    queryset = ObjetImmobilise.objects.order_by('peggi_id').all()
+    queryset = ObjetImmobilise.objects.order_by("no_obj").all()
 
     @action(detail=False)
     def download(self, request):
         data = ObjetImmobilise.as_geojson()
-        return JsonResponse(
-            data, 
-            safe=False,
-            json_dumps_params={'ensure_ascii': False}
-        )
+        return JsonResponse(data, safe=False, json_dumps_params={"ensure_ascii": False})
+
+
+class RepartitionExpertViewSet(MultiSerializerMixin, viewsets.ReadOnlyModelViewSet):
+    """
+    Répartition générale des experts
+    """
+
+    queryset = RepartitionExpert.objects.order_by("ini_expert").all()
+    serializers = {
+        "default": RepartitionExpertSerializer,
+        "list": RepartitionExpertDigestSerializer,
+    }
+
+    @action(detail=False)
+    def download(self, request):
+        data = RepartitionExpert.as_geojson()
+        return JsonResponse(data, safe=False, json_dumps_params={"ensure_ascii": False})
+
+
+class PlanQuartierViewSet(viewsets.ReadOnlyModelViewSet):
+    """
+    Périmètres de plan de quartier
+    """
+
+    serializer_class = PlanQuartierSerializer
+    queryset = PlanQuartier.objects.order_by("identifiant_unique_ct").all()
+
+    @action(detail=False)
+    def download(self, request):
+        data = PlanSpecial.as_geojson()
+        return JsonResponse(data, safe=False, json_dumps_params={"ensure_ascii": False})
+
+
+class PlanSpecialViewSet(viewsets.ReadOnlyModelViewSet):
+    """
+    Périmètres de plan spécial
+    """
+
+    serializer_class = PlanSpecialSerializer
+    queryset = PlanSpecial.objects.order_by("identifiant_unique_ct").all()
+
+    @action(detail=False)
+    def download(self, request):
+        data = PlanSpecial.as_geojson()
+        return JsonResponse(data, safe=False, json_dumps_params={"ensure_ascii": False})

sitn/mixins.py

@@ -5,6 +5,21 @@
 from sitn.functions import JsonBuildObject
 
 
+class MultiSerializerMixin():
+    """
+    Include this mixin in a serializer to be able to select a different serializer per action
+    This is useful when you want to use viewsets but the main serializer is not performant
+      so you can provide a "Digest" serializer that will perform quick
+    """
+    serializers = {
+        'default': None,
+    }
+
+    def get_serializer_class(self):
+        return self.serializers.get(self.action,
+                                    self.serializers['default'])
+
+
 class GeoJSONModelMixin:
     """
     A mixin to add database GeoJSON serialization to a GeoDjango model.