class TrekViewSet(api_viewsets.GeotrekViewset): filter_backends = (DjangoFilterBackend, api_filters.GeotrekQueryParamsFilter, api_filters.GeotrekInBBoxFilter, api_filters.GeotrekDistanceToPointFilter, api_filters.GeotrekPublishedFilter, api_filters.GeotrekTrekQueryParamsFilter) serializer_class = api_serializers.TrekListSerializer serializer_detail_class = api_serializers.TrekDetailSerializer queryset = trekking_models.Trek.objects.existing() \ .select_related('topo_object', 'difficulty', 'practice') \ .prefetch_related('topo_object__aggregations', 'themes', 'accessibilities', 'networks', 'attachments') \ .annotate(geom2d_transformed=Transform(F('geom'), settings.API_SRID), geom3d_transformed=Transform(F('geom_3d'), settings.API_SRID), length_2d_m=Length('geom'), length_3d_m=Length3D('geom_3d')) \ .order_by('pk') # Required for reliable pagination filterset_fields = ('difficulty', 'themes', 'networks', 'practice') @decorators.action(detail=False, methods=['get']) def practices(self, request, *args, **kwargs): return HttpResponseRedirect(reverse('apiv2:practice-list', args=args)) @decorators.action(detail=False, methods=['get']) def networks(self, request, *args, **kwargs): return HttpResponseRedirect(reverse('apiv2:network-list', args=args)) @decorators.action(detail=False, methods=['get']) def difficulties(self, request, *args, **kwargs): return HttpResponseRedirect(reverse('apiv2:difficulty-list', args=args))
def get_queryset(self): queryset = sensitivity_models.SensitiveArea.objects.existing() \ .filter(published=True) \ .select_related('species', 'structure') \ .prefetch_related('species__practices') \ .annotate(geom_type=GeometryType(F('geom'))) if 'bubble' in self.request.GET: queryset = queryset.annotate( geom_transformed=Transform(F('geom'), settings.API_SRID)) else: queryset = queryset.annotate(geom_transformed=Case( When(geom_type='POINT', then=Transform(Buffer(F('geom'), F('species__radius'), 4), settings.API_SRID)), When(geom_type='POLYGON', then=Transform(F('geom'), settings.API_SRID)), When(geom_type='MULTIPOLYGON', then=Transform(F('geom'), settings.API_SRID)), )) # Ensure smaller areas are at the end of the list, ie above bigger areas on the map # to ensure we can select every area in case of overlapping # Second sort key pk is required for reliable pagination queryset = queryset.annotate(area=Area('geom_transformed')).order_by( '-area', 'pk') return queryset
class POIViewSet(api_viewsets.GeotrekViewset): serializer_class = api_serializers.POIListSerializer serializer_detail_class = api_serializers.POIDetailSerializer queryset = trekking_models.POI.objects.existing() \ .select_related('topo_object', 'type', ) \ .prefetch_related('topo_object__aggregations', 'attachments') \ .annotate(geom2d_transformed=Transform(F('geom'), settings.API_SRID), geom3d_transformed=Transform(F('geom_3d'), settings.API_SRID)) \ .order_by('pk') # Required for reliable pagination filter_fields = ('type',) @decorators.list_route(methods=['get']) def all_types(self, request, *args, **kwargs): """ Get all POI types """ data = api_serializers.POITypeSerializer(trekking_models.POIType.objects.all(), many=True, context={'request': request}).data return response.Response(data) @decorators.list_route(methods=['get']) def used_types(self, request, *args, **kwargs): """ Get POI types used by POI instances """ data = api_serializers.POITypeSerializer( trekking_models.POIType.objects.filter(pk__in=trekking_models.POI.objects.existing() .values_list('type_id', flat=True)), many=True, context={'request': request}).data return response.Response(data)
def get_children(self, obj): children = obj.children.all().annotate( length_2d_m=Length('geom'), start_point=Transform(StartPoint('geom'), settings.API_SRID), end_point=Transform(EndPoint('geom'), settings.API_SRID)) serializer_children = TrekListSerializer( children, many=True, context={'root_pk': obj.pk}) return serializer_children.data
def get_steps(self, obj): qs = obj.children \ .select_related('topo_object', 'difficulty') \ .prefetch_related('topo_object__aggregations', 'themes', 'networks', 'attachments') \ .annotate(geom2d_transformed=Transform('geom', settings.API_SRID), geom3d_transformed=Transform('geom_3d', settings.API_SRID), length_2d_m=Length('geom'), length_3d_m=Length3D('geom_3d')) FinalClass = override_serializer( self.context.get('request').GET.get('format'), self.context.get('request').GET.get('dim'), TrekDetailSerializer) return FinalClass(qs, many=True).data
class PathViewSet(api_viewsets.GeotrekViewset): """ Use HTTP basic authentication to access this endpoint. """ serializer_class = api_serializers.PathListSerializer serializer_detail_class = api_serializers.PathListSerializer queryset = core_models.Path.objects.all() \ .select_related('comfort', 'source', 'stake') \ .prefetch_related('usages', 'networks') \ .annotate(geom2d_transformed=Transform('geom', settings.API_SRID), geom3d_transformed=Transform('geom_3d', settings.API_SRID), length_2d_m=Length('geom'), length_3d_m=Length3D('geom_3d'))
def topology_all_pois(cls, topology): if settings.TREKKING_TOPOLOGY_ENABLED: qs = cls.overlapping(topology) else: object_geom = topology.geom.transform(settings.SRID, clone=True).buffer(settings.TREK_POI_INTERSECTION_MARGIN) qs = cls.objects.existing().filter(geom__intersects=object_geom) if topology.geom.geom_type == 'LineString': qs = qs.annotate(locate=LineLocatePoint(Transform(Value(topology.geom.ewkt, output_field=models.GeometryField()), settings.SRID), Transform(F('geom'), settings.SRID))) qs = qs.order_by('locate') return qs
def get_queryset(self): queryset = sensitivity_models.SensitiveArea.objects.existing() \ .filter(published=True) \ .select_related('species', 'structure') \ .prefetch_related('species__practices') \ .annotate(geom_type=GeometryType(F('geom'))) if 'bubble' in self.request.GET: queryset = queryset.annotate(geom2d_transformed=Transform(F('geom'), settings.API_SRID)) else: queryset = queryset.annotate(geom2d_transformed=Case( When(geom_type='POINT', then=Transform(Buffer(F('geom'), F('species__radius'), 4), settings.API_SRID)), When(geom_type='POLYGON', then=Transform(F('geom'), settings.API_SRID)) )) return queryset
class SiteViewSet(api_viewsets.GeotrekGeometricViewset): filter_backends = api_viewsets.GeotrekGeometricViewset.filter_backends + ( api_filters.GeotrekSiteFilter, ) serializer_class = api_serializers.SiteSerializer queryset = outdoor_models.Site.objects \ .annotate(geom_transformed=Transform(F('geom'), settings.API_SRID)) \ .order_by('pk') # Required for reliable pagination
class TouristicContentViewSet(api_viewsets.GeotrekViewset): serializer_class = api_serializers.TouristicContentListSerializer serializer_detail_class = api_serializers.TouristicContentDetailSerializer queryset = tourism_models.TouristicContent.objects.existing()\ .select_related('category', 'reservation_system') \ .prefetch_related('source', 'themes', 'type1', 'type2') \ .annotate(geom2d_transformed=Transform(F('geom'), settings.API_SRID)) \ .order_by('pk') # Required for reliable pagination
def get_queryset(self): qs = SensitiveArea.objects.existing() qs = qs.filter(published=True) qs = qs.prefetch_related('species') qs = qs.annotate(geom_type=GeometryType(F('geom'))) qs = qs.annotate(geom2d_transformed=Case( When(geom_type='POINT', then=Transform(Buffer(F('geom'), F('species__radius'), 4), settings.API_SRID)), When(geom_type__in=('POLYGON', 'MULTIPOLYGON'), then=Transform(F('geom'), settings.API_SRID)) )) # Ensure smaller areas are at the end of the list, ie above bigger areas on the map # to ensure we can select every area in case of overlapping qs = qs.annotate(area=Area('geom2d_transformed')).order_by('-area') if 'practices' in self.request.GET: qs = qs.filter(species__practices__name__in=self.request.GET['practices'].split(',')) return qs
def get_queryset(self, *args, **kwargs): queryset = trekking_models.Trek.objects.existing()\ .select_related('topo_object') \ .prefetch_related('topo_object__aggregations', 'attachments') \ .order_by('pk').annotate(length_2d_m=Length('geom')) if not self.action == 'list': queryset = queryset.annotate( geom2d_transformed=Transform(F('geom'), settings.API_SRID)) if 'portal' in self.request.GET: queryset = queryset.filter( Q(portal__name__in=self.request.GET['portal'].split(',')) | Q(portal=None)) return queryset.annotate(start_point=Transform(StartPoint('geom'), settings.API_SRID), end_point=Transform(EndPoint('geom'), settings.API_SRID)).\ filter(Q(published=True) | Q(trek_parents__parent__published=True, trek_parents__parent__deleted=False)).distinct()
def get_queryset(self): qs = SensitiveArea.objects.existing() qs = qs.filter(published=True) qs = qs.prefetch_related('species') qs = qs.annotate(geom_type=GeometryType(F('geom'))) qs = qs.annotate(geom2d_transformed=Case( When(geom_type='POINT', then=Transform(Buffer(F('geom'), F('species__radius'), 4), settings.API_SRID)), When(geom_type='POLYGON', then=Transform(F('geom'), settings.API_SRID)))) if 'practices' in self.request.GET: qs = qs.filter(species__practices__name__in=self.request. GET['practices'].split(',')) return qs
def touristic_events(self, request, *args, **kwargs): trek = self.get_object() qs = trek.trek.touristic_events.filter(published=True).prefetch_related('attachments') \ .annotate(geom2d_transformed=Transform(F('geom'), settings.API_SRID)) \ .order_by('pk') data = api_serializers_tourism.TouristicEventListSerializer( qs, many=True, context={ 'trek_pk': trek.pk }).data return response.Response(data)
def get_queryset(self, *args, **kwargs): lang = self.request.LANGUAGE_CODE queryset = trekking_models.Trek.objects.existing()\ .select_related('topo_object') \ .prefetch_related('topo_object__aggregations', 'attachments') \ .order_by('pk').annotate(length_2d_m=Length('geom')) if not self.action == 'list': queryset = queryset.annotate( geom2d_transformed=Transform(F('geom'), settings.API_SRID)) if self.action == 'list': queryset = queryset.annotate(count_parents=Count('trek_parents')).\ exclude(Q(count_parents__gt=0) & Q(published=False)) if 'portal' in self.request.GET: queryset = queryset.filter( Q(portal__name=self.request.GET['portal']) | Q(portal=None)) return queryset.annotate(start_point=Transform(StartPoint('geom'), settings.API_SRID), end_point=Transform(EndPoint('geom'), settings.API_SRID)). \ filter(Q(**{'published_{lang}'.format(lang=lang): True}) | Q(**{'trek_parents__parent__published_{lang}'.format(lang=lang): True, 'trek_parents__parent__deleted': False})).distinct()
def get_queryset(self): pk = self.kwargs['pk'] dive = get_object_or_404(Dive.objects.existing(), pk=pk) if not dive.is_public: raise Http404 qs = dive.published_sensitive_areas qs = qs.prefetch_related('species') qs = qs.annotate(geom_type=GeometryType(F('geom'))) qs = qs.annotate(geom2d_transformed=Case( When(geom_type='POINT', then=Transform(Buffer(F('geom'), F('species__radius'), 4), settings.API_SRID)), When(geom_type='POLYGON', then=Transform(F('geom'), settings.API_SRID)) )) # Ensure smaller areas are at the end of the list, ie above bigger areas on the map # to ensure we can select every area in case of overlapping qs = qs.annotate(area=Area('geom2d_transformed')).order_by('-area') if 'practices' in self.request.GET: qs = qs.filter(species__practices__name__in=self.request.GET['practices'].split(',')) return qs
def pois(self, request, *args, **kwargs): trek = self.get_object() qs = trek.pois.filter(published=True).select_related('topo_object', 'type', )\ .prefetch_related('topo_object__aggregations', 'attachments') \ .annotate(geom2d_transformed=Transform(F('geom'), settings.API_SRID)) \ .order_by('pk') data = api_serializers_trekking.POIListSerializer(qs, many=True, context={ 'trek_pk': trek.pk }).data return response.Response(data)
class PathViewSet(api_viewsets.GeotrekGeometricViewset): """ Use HTTP basic authentication to access this endpoint. """ permission_classes = [IsAuthenticated] serializer_class = api_serializers.PathSerializer queryset = core_models.Path.objects.all() \ .select_related('comfort', 'source', 'stake') \ .prefetch_related('usages', 'networks') \ .annotate(geom3d_transformed=Transform(F('geom_3d'), settings.API_SRID), length_2d_m=Length('geom'), length_3d_m=Length3D('geom_3d')) \ .order_by('pk') # Required for reliable pagination
def get_queryset(self): pk = self.kwargs['pk'] try: trek = Trek.objects.existing().get(pk=pk) except Trek.DoesNotExist: raise Http404 if not trek.is_public: raise Http404 qs = trek.published_sensitive_areas qs = qs.prefetch_related('species') qs = qs.annotate(geom_type=GeometryType(F('geom'))) qs = qs.annotate(geom2d_transformed=Case( When(geom_type='POINT', then=Transform(Buffer(F('geom'), F('species__radius'), 4), settings.API_SRID)), When(geom_type='POLYGON', then=Transform(F('geom'), settings.API_SRID)))) if 'practices' in self.request.GET: qs = qs.filter(species__practices__name__in=self.request. GET['practices'].split(',')) return qs
class TrekViewSet(api_viewsets.GeotrekViewset): serializer_class = api_serializers.TrekListSerializer serializer_detail_class = api_serializers.TrekDetailSerializer queryset = trekking_models.Trek.objects.existing() \ .select_related('topo_object', 'difficulty', 'practice') \ .prefetch_related('topo_object__aggregations', 'themes', 'networks', 'attachments') \ .annotate(geom2d_transformed=Transform('geom', settings.API_SRID), geom3d_transformed=Transform('geom_3d', settings.API_SRID), length_2d_m=Length('geom'), length_3d_m=Length3D('geom_3d')) filter_fields = ('difficulty', 'themes', 'networks', 'practice') @decorators.list_route(methods=['get']) def all_practices(self, request, *args, **kwargs): """ Get all practices list """ data = api_serializers.TrekPracticeSerializer( trekking_models.Practice.objects.all(), many=True, context={ 'request': request }).data return response.Response(data) @decorators.list_route(methods=['get']) def used_practices(self, request, *args, **kwargs): """ Get practices used by Trek instances """ data = api_serializers.TrekPracticeSerializer( trekking_models.Practice.objects.filter( pk__in=trekking_models.Trek.objects.existing().values_list( 'practice_id', flat=True)), many=True, context={ 'request': request }).data return response.Response(data) @decorators.list_route(methods=['get']) def all_themes(self, request, *args, **kwargs): """ Get all themes list """ data = api_serializers.TrekThemeSerializer( trekking_models.Theme.objects.all(), many=True, context={ 'request': request }).data return response.Response(data) @decorators.list_route(methods=['get']) def used_themes(self, request, *args, **kwargs): """ Get themes used by Trek instances """ data = api_serializers.TrekThemeSerializer( trekking_models.Theme.objects.filter( pk__in=trekking_models.Trek.objects.existing().values_list( 'themes', flat=True)), many=True, context={ 'request': request }).data return response.Response(data) @decorators.list_route(methods=['get']) def all_networks(self, request, *args, **kwargs): """ Get all networks list """ data = api_serializers.TrekNetworkSerializer( trekking_models.TrekNetwork.objects.all(), many=True, context={ 'request': request }).data return response.Response(data) @decorators.list_route(methods=['get']) def used_networks(self, request, *args, **kwargs): """ Get networks used by Trek instances """ data = api_serializers.TrekNetworkSerializer( trekking_models.TrekNetwork.objects.filter( pk__in=trekking_models.Trek.objects.existing().values_list( 'networks', flat=True)), many=True, context={ 'request': request }).data return response.Response(data) @decorators.list_route(methods=['get']) def all_difficulties(self, request, *args, **kwargs): """ Get all difficulties list """ qs = trekking_models.DifficultyLevel.objects.all() data = api_serializers.DifficultySerializer(qs, many=True, context={ 'request': request }).data return response.Response(data) @decorators.list_route(methods=['get']) def used_difficulties(self, request, *args, **kwargs): """ Get difficulties used by Trek instances """ data = api_serializers.DifficultySerializer( trekking_models.DifficultyLevel.objects.filter( pk__in=trekking_models.Trek.objects.existing().values_list( 'difficulty_id', flat=True)), many=True, context={ 'request': request }).data return response.Response(data)
def get_parents(self, obj): parents = obj.parents.all().annotate(length_2d_m=Length('geom'), start_point=Transform(StartPoint('geom'), settings.API_SRID), end_point=Transform(EndPoint('geom'), settings.API_SRID)) serializer_parents = TrekListSerializer(parents, many=True) return serializer_parents.data