127 lines
4.3 KiB
Python
127 lines
4.3 KiB
Python
import mimetypes
|
|
import os
|
|
from collections import OrderedDict
|
|
|
|
from django.conf import settings
|
|
from django.core.files import File
|
|
from django.http import HttpResponse
|
|
from rest_framework.decorators import detail_route
|
|
from rest_framework.response import Response
|
|
from rest_framework.viewsets import ReadOnlyModelViewSet, ViewSet
|
|
|
|
from c3nav.mapdata.models import GEOMETRY_MAPITEM_TYPES, Level, Package, Source
|
|
from c3nav.mapdata.permissions import filter_queryset_by_package_access
|
|
from c3nav.mapdata.serializers.main import LevelSerializer, PackageSerializer, SourceSerializer
|
|
|
|
|
|
class GeometryTypeViewSet(ViewSet):
|
|
"""
|
|
Lists all geometry types.
|
|
"""
|
|
|
|
def list(self, request):
|
|
return Response([
|
|
OrderedDict((
|
|
('name', name),
|
|
('title', str(mapitemtype._meta.verbose_name)),
|
|
('title_plural', str(mapitemtype._meta.verbose_name_plural)),
|
|
)) for name, mapitemtype in GEOMETRY_MAPITEM_TYPES.items()
|
|
])
|
|
|
|
|
|
class GeometryViewSet(ViewSet):
|
|
"""
|
|
List all geometries.
|
|
You can filter by adding one or more level, package, type or name GET parameters.
|
|
"""
|
|
|
|
def list(self, request):
|
|
types = request.GET.getlist('type')
|
|
valid_types = list(GEOMETRY_MAPITEM_TYPES.keys())
|
|
if not types:
|
|
types = valid_types
|
|
else:
|
|
types = [t for t in types if t in valid_types]
|
|
|
|
levels = request.GET.getlist('level')
|
|
packages = request.GET.getlist('package')
|
|
names = request.GET.getlist('name')
|
|
|
|
results = []
|
|
for t in types:
|
|
mapitemtype = GEOMETRY_MAPITEM_TYPES[t]
|
|
queryset = mapitemtype.objects.all()
|
|
if packages:
|
|
queryset = queryset.filter(package__name__in=packages)
|
|
if levels:
|
|
if hasattr(mapitemtype, 'level'):
|
|
queryset = queryset.filter(level__name__in=levels)
|
|
elif hasattr(mapitemtype, 'levels'):
|
|
queryset = queryset.filter(levels__name__in=levels)
|
|
else:
|
|
queryset = queryset.none()
|
|
if names:
|
|
queryset = queryset.filter(name__in=names)
|
|
queryset = filter_queryset_by_package_access(request, queryset)
|
|
queryset = queryset.order_by('name')
|
|
print(mapitemtype)
|
|
for field_name in ('package', 'level', 'levels', 'crop_to_level', 'elevator'):
|
|
if hasattr(mapitemtype, field_name):
|
|
print(field_name)
|
|
queryset = queryset.prefetch_related(field_name)
|
|
results.extend(sum((obj.to_geojson() for obj in queryset), []))
|
|
return Response(results)
|
|
|
|
|
|
class PackageViewSet(ReadOnlyModelViewSet):
|
|
"""
|
|
Retrieve packages the map consists of.
|
|
"""
|
|
queryset = Package.objects.all()
|
|
serializer_class = PackageSerializer
|
|
lookup_field = 'name'
|
|
lookup_value_regex = '[^/]+'
|
|
filter_fields = ('name', 'depends')
|
|
ordering_fields = ('name',)
|
|
ordering = ('name',)
|
|
search_fields = ('name',)
|
|
|
|
|
|
class LevelViewSet(ReadOnlyModelViewSet):
|
|
"""
|
|
List and retrieve levels.
|
|
"""
|
|
queryset = Level.objects.all()
|
|
serializer_class = LevelSerializer
|
|
lookup_field = 'name'
|
|
lookup_value_regex = '[^/]+'
|
|
filter_fields = ('altitude', 'package')
|
|
ordering_fields = ('altitude', 'package')
|
|
ordering = ('altitude',)
|
|
search_fields = ('name',)
|
|
|
|
|
|
class SourceViewSet(ReadOnlyModelViewSet):
|
|
"""
|
|
List and retrieve source images (to use as a drafts).
|
|
"""
|
|
queryset = Source.objects.all()
|
|
serializer_class = SourceSerializer
|
|
lookup_field = 'name'
|
|
lookup_value_regex = '[^/]+'
|
|
filter_fields = ('package',)
|
|
ordering_fields = ('name', 'package')
|
|
ordering = ('name',)
|
|
search_fields = ('name',)
|
|
|
|
def get_queryset(self):
|
|
return filter_queryset_by_package_access(self.request, super().get_queryset())
|
|
|
|
@detail_route(methods=['get'])
|
|
def image(self, request, name=None):
|
|
source = self.get_object()
|
|
response = HttpResponse(content_type=mimetypes.guess_type(source.name)[0])
|
|
image_path = os.path.join(settings.MAP_ROOT, source.package.directory, 'sources', source.name)
|
|
for chunk in File(open(image_path, 'rb')).chunks():
|
|
response.write(chunk)
|
|
return response
|