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
