refactor api views inter their respecting apps

src/c3nav/mapdata/api.py

@@ -0,0 +1,93 @@
+import mimetypes
+import os
+
+from django.conf import settings
+from django.core.files import File
+from django.http import Http404, HttpResponse
+from rest_framework.decorators import detail_route
+from rest_framework.response import Response
+from rest_framework.viewsets import ModelViewSet, ReadOnlyModelViewSet, ViewSet
+
+from .cache import AccessCachedViewSetMixin, CachedViewSetMixin
+from .models import FEATURE_TYPES, Feature, Level, Package, Source
+from .permissions import filter_source_queryset
+from .serializers import FeatureSerializer, FeatureTypeSerializer, LevelSerializer, PackageSerializer, SourceSerializer
+
+
+class LevelViewSet(CachedViewSetMixin, ReadOnlyModelViewSet):
+    """
+    Returns a list of all levels on the map.
+    """
+    queryset = Level.objects.all()
+    serializer_class = LevelSerializer
+    lookup_value_regex = '[^/]+'
+    filter_fields = ('altitude', 'package')
+    ordering_fields = ('altitude', 'package')
+    ordering = ('altitude',)
+    search_fields = ('name',)
+
+
+class PackageViewSet(AccessCachedViewSetMixin, ReadOnlyModelViewSet):
+    """
+    Returns a list of all packages the map consists of.
+    """
+    queryset = Package.objects.all()
+    serializer_class = PackageSerializer
+    lookup_value_regex = '[^/]+'
+    filter_fields = ('name', 'depends')
+    ordering_fields = ('name',)
+    ordering = ('name',)
+    search_fields = ('name',)
+
+
+class SourceViewSet(AccessCachedViewSetMixin, ReadOnlyModelViewSet):
+    """
+    Returns a list of source images (to use as a drafts).
+    Call /sources/{name}/image to get the image.
+    """
+    queryset = Source.objects.all()
+    serializer_class = SourceSerializer
+    lookup_value_regex = '[^/]+'
+    filter_fields = ('package',)
+    ordering_fields = ('name', 'package')
+    ordering = ('name',)
+    search_fields = ('name',)
+
+    def get_queryset(self):
+        return filter_source_queryset(self.request, super().get_queryset())
+
+    @detail_route(methods=['get'])
+    def image(self, request, pk=None, version=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
+
+
+class FeatureTypeViewSet(ViewSet):
+    """
+    Get Feature types
+    """
+    def list(self, request, version=None):
+        serializer = FeatureTypeSerializer(FEATURE_TYPES.values(), many=True, context={'request': request})
+        return Response(serializer.data)
+
+    def retrieve(self, request, pk=None, version=None):
+        if pk not in FEATURE_TYPES:
+            raise Http404
+        serializer = FeatureTypeSerializer(FEATURE_TYPES[pk], context={'request': request})
+        return Response(serializer.data)
+
+
+ParentModelViewSet = ModelViewSet if settings.DIRECT_EDITING else ReadOnlyModelViewSet
+
+
+class FeatureViewSet(ParentModelViewSet):
+    """
+    Get all Map Features including ones that are only part of the current session
+    """
+    queryset = Feature.objects.all()
+    serializer_class = FeatureSerializer
+    lookup_value_regex = '[^/]+'

src/c3nav/mapdata/cache.py

@@ -0,0 +1,43 @@
+import base64
+
+from django.core.cache import cache
+from django.template.response import SimpleTemplateResponse
+from django.utils.cache import patch_vary_headers
+
+from .permissions import get_unlocked_packages
+
+
+class CachedViewSetMixin:
+    def get_cache_key(self, request):
+        cache_key = ('api__' + ('OPTIONS' if request.method == 'OPTIONS' else 'GET') + '_' +
+                     base64.b64encode(self.get_cache_params(request).encode()).decode() + '_' +
+                     request.path + '?' + request.META['QUERY_STRING'])
+        return cache_key
+
+    def get_cache_params(self, request):
+        return request.META.get('HTTP_ACCEPT', '')
+
+    def dispatch(self, request, *args, **kwargs):
+        do_cache = request.method in ('GET', 'HEAD', 'OPTIONS')
+        if do_cache:
+            cache_key = self.get_cache_key(request)
+            if cache_key in cache:
+                return cache.get(cache_key)
+        response = super().dispatch(request, *args, **kwargs)
+        patch_vary_headers(response, ['Cookie'])
+        if do_cache:
+            if isinstance(response, SimpleTemplateResponse):
+                response.render()
+            cache.set(cache_key, response, 60)
+        return response
+
+    @property
+    def default_response_headers(self):
+        headers = super().default_response_headers
+        headers['Vary'] += ', Cookie'
+        return headers
+
+
+class AccessCachedViewSetMixin(CachedViewSetMixin):
+    def get_cache_params(self, request):
+        return super().get_cache_params(request)+'___'+'___'.join(get_unlocked_packages(request))

src/c3nav/mapdata/models/package.py

@@ -1,5 +1,6 @@
 from collections import OrderedDict
 
+from django.conf import settings
 from django.db import models
 from django.utils.translation import ugettext_lazy as _
 
@@ -55,6 +56,10 @@ class Package(models.Model):
     def package(self):
         return self
 
+    @property
+    def public(self):
+        return self.name in settings.PUBLIC_PACKAGES
+
     @property
     def bounds(self):
         if self.bottom is None:

src/c3nav/mapdata/permissions.py

@@ -0,0 +1,26 @@
+from django.conf import settings
+from django.utils.translation import ugettext_lazy as _
+from rest_framework.exceptions import PermissionDenied
+from rest_framework.permissions import BasePermission
+
+from .models import Source
+
+
+def get_unlocked_packages(request):
+    return set(settings.PUBLIC_PACKAGES) | set(request.session.get('unlocked_packages', ()))
+
+
+def can_access_package(request, package):
+    return settings.DEBUG or package.name in get_unlocked_packages(request)
+
+
+def filter_source_queryset(request, queryset):
+    return queryset if settings.DEBUG else queryset.filter(package__name__in=get_unlocked_packages(request))
+
+
+class LockedMapFeatures(BasePermission):
+    def has_object_permission(self, request, view, obj):
+        if isinstance(obj, Source):
+            if not can_access_package(request, obj.package):
+                raise PermissionDenied(_('This Source belongs to a package you don\'t have access to.'))
+        return True

src/c3nav/mapdata/serializers.py

@@ -0,0 +1,62 @@
+from django.utils.translation import ugettext_lazy as _
+from rest_framework import serializers
+from rest_framework.exceptions import ValidationError
+from shapely.geometry import mapping, shape
+
+from .models import Feature, Level, Package, Source
+from .utils import sort_geojson
+
+
+class GeometryField(serializers.DictField):
+    """
+    shapely geometry objects serialized using GeoJSON
+    """
+    default_error_messages = {
+        'invalid': _('Invalid GeoJSON.')
+    }
+
+    def to_representation(self, obj):
+        geojson = sort_geojson(mapping(obj))
+        return super().to_representation(geojson)
+
+    def to_internal_value(self, data):
+        geojson = super().to_internal_value(data)
+        try:
+            return shape(geojson)
+        except:
+            raise ValidationError(_('Invalid GeoJSON.'))
+
+
+class LevelSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Level
+        fields = ('name', 'altitude', 'package')
+
+
+class PackageSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Package
+        fields = ('name', 'home_repo', 'commit_id', 'depends', 'bounds', 'public')
+        readonly_fields = ('commit_id', )
+
+
+class SourceSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Source
+        fields = ('name', 'package', 'bounds')
+
+
+class FeatureTypeSerializer(serializers.Serializer):
+    name = serializers.CharField()
+    title = serializers.CharField()
+    title_plural = serializers.CharField()
+    geomtype = serializers.CharField()
+    color = serializers.CharField()
+
+
+class FeatureSerializer(serializers.ModelSerializer):
+    geometry = GeometryField()
+
+    class Meta:
+        model = Feature
+        fields = ('name', 'package', 'feature_type', 'geometry')