keep v1 in a separate module

Author: aperrin66

geospaas_rest_api/v1/__init__.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class GeospaasRestApiConfig(AppConfig):
+    name = 'geospaas_rest_api_v1'

geospaas_rest_api/v1/apps.py

@@ -0,0 +1,111 @@
+"""
+Custom filters for the REST API
+"""
+import re
+import datetime
+
+import dateutil.parser
+from django.contrib.gis.geos import GEOSGeometry
+from django.db.models import Value
+from django.db.models.functions import Concat
+from django.template import loader
+
+from rest_framework.exceptions import ValidationError
+from rest_framework.filters import BaseFilterBackend
+
+
+class DatasetFilter(BaseFilterBackend):
+    """
+    Enables filtering of Datasets based on date, location and source
+    """
+
+    DATE_PARAM = 'date'
+    LOCATION_PARAM = 'zone'
+    SOURCE_PARAM = 'source'
+
+    BROWSABLE_TEMPLATE = 'geospaas_rest_api/search.html'
+
+    RANGE_MATCHER = re.compile(r'^\(([^()]+),([^()]+)\)$')
+
+    def filter_queryset(self, request, queryset, view):
+        """
+        Filter the queryset based on request arguments
+        """
+        filtered_queryset = queryset
+        if self.DATE_PARAM in request.query_params and request.query_params[self.DATE_PARAM]:
+            range_match = self.RANGE_MATCHER.match(request.query_params[self.DATE_PARAM])
+            try:
+                if range_match:
+                    date_range = [dateutil.parser.parse(date) for date in range_match.groups()]
+                else:
+                    date_range = [dateutil.parser.parse(request.query_params[self.DATE_PARAM]),] * 2
+            except dateutil.parser.ParserError:
+                raise ValidationError("Wrong date format", code=400)
+
+            # If the timezone is not specified, UTC is assumed
+            for i, date in enumerate(date_range):
+                if not date.tzinfo:
+                    date_range[i] = date.replace(tzinfo=datetime.timezone.utc)
+
+            if date_range[0] > date_range[1]:
+                raise ValidationError(
+                    detail="The first date in the range should be inferior to the second one",
+                    code=400)
+
+            filtered_queryset = filtered_queryset.filter(
+                time_coverage_start__lte=date_range[1], time_coverage_end__gte=date_range[0])
+        if self.SOURCE_PARAM in request.query_params and request.query_params[self.SOURCE_PARAM]:
+            source_keyword = request.query_params[self.SOURCE_PARAM]
+            filtered_queryset = filtered_queryset.annotate(source_search_name=Concat(
+                'source__platform__short_name', Value('_'), 'source__instrument__short_name'
+            )).filter(source_search_name__icontains=source_keyword)
+        if self.LOCATION_PARAM in request.query_params and \
+                request.query_params[self.LOCATION_PARAM]:
+            zone = GEOSGeometry(request.query_params[self.LOCATION_PARAM])
+            filtered_queryset = filtered_queryset.filter(
+                geographic_location__geometry__intersects=zone
+            )
+        return filtered_queryset
+
+    def to_html(self, request, queryset, view):  # pylint: disable=unused-argument
+        """
+        Enables filtering in the browsable API
+        """
+        if self.DATE_PARAM in request.query_params:
+            date_term = request.query_params[self.DATE_PARAM]
+        else:
+            date_term = ''
+
+        if self.LOCATION_PARAM in request.query_params:
+            location_term = request.query_params[self.LOCATION_PARAM]
+        else:
+            location_term = ''
+
+        if self.SOURCE_PARAM in request.query_params:
+            source_term = request.query_params[self.SOURCE_PARAM]
+        else:
+            source_term = ''
+
+        context = {
+            'params': [self.DATE_PARAM, self.LOCATION_PARAM, self.SOURCE_PARAM],
+            'terms': [date_term, location_term, source_term]
+        }
+
+        template = loader.get_template(self.BROWSABLE_TEMPLATE)
+        return template.render(context)
+
+
+class DatasetURIFilter(BaseFilterBackend):
+    """
+    Enables filtering of DatasetURI based on Dataset ID
+    """
+
+    DATASET_PARAM = 'dataset'
+
+    def filter_queryset(self, request, queryset, view):
+        filtered_queryset = queryset
+        if self.DATASET_PARAM in request.query_params and request.query_params[self.DATASET_PARAM]:
+            filtered_queryset = filtered_queryset.filter(
+                dataset__id=request.query_params[self.DATASET_PARAM]
+            )
+        return filtered_queryset

geospaas_rest_api/v1/filters.py

@@ -0,0 +1,9 @@
+from rest_framework.pagination import CursorPagination
+
+class PKOrderedCursorPagination(CursorPagination):
+    """
+    Cursor pagination can be used to improve response time
+    by removing the elements count from all responses.
+    """
+    ordering = 'pk'
+    page_size = 100

geospaas_rest_api/v1/pagination.py

@@ -0,0 +1,16 @@
+
+import os
+import sys
+
+import django
+from django.conf import settings
+from django.test.utils import get_runner
+
+if __name__ == "__main__":
+    os.environ['DJANGO_SETTINGS_MODULE'] = 'geospaas_rest_api.v1.tests.settings'
+    django.setup()
+    test_case = f".{sys.argv[1]}" if len(sys.argv) >= 2 else ''
+    TestRunner = get_runner(settings)
+    test_runner = TestRunner(verbosity=1, interactive=False)
+    failures = test_runner.run_tests(["geospaas_rest_api.v1.tests" + test_case])
+    sys.exit(bool(failures))

geospaas_rest_api/v1/runtests.py

@@ -0,0 +1,149 @@
+"""
+Serializers for the GeoSPaaS REST API
+"""
+import django_celery_results.models
+import geospaas.catalog.models
+import geospaas.vocabularies.models
+import rest_framework.serializers
+
+import geospaas_rest_api.models as models
+
+
+class JobSerializer(rest_framework.serializers.Serializer):
+    """Serializer for Job objects"""
+
+    jobs = {
+        'download': models.DownloadJob,
+        'convert': models.ConvertJob
+    }
+
+    # Actual Job fields
+    id = rest_framework.serializers.IntegerField(read_only=True)
+    task_id = rest_framework.serializers.CharField(read_only=True)
+    date_created = rest_framework.serializers.DateTimeField(read_only=True)
+
+    # Fields used to launch jobs
+    action = rest_framework.serializers.ChoiceField(choices=list(jobs.keys()),
+                                                    required=True, write_only=True,
+                                                    help_text="Action to perform")
+    parameters = rest_framework.serializers.DictField(write_only=True,
+                                                      help_text="Parameters for the action")
+
+    def to_representation(self, instance):
+        """Generate a representation of the job"""
+        representation = super().to_representation(instance)
+
+        current_result, finished = instance.get_current_task_result()
+        representation['status'] = current_result.state
+
+        if finished:
+            representation['date_done'] = current_result.date_done
+            if current_result.state == 'SUCCESS':
+                representation['result'] = current_result.result
+
+        return representation
+
+    def update(self, instance, validated_data):
+        """Does nothing. Update of already created tasks is only done by the Celery worker"""
+
+    def create(self, validated_data):
+        """Launches a long-running task, and returns the corresponding AsyncResult"""
+        # This might need to be modified if the first task of a Job requires more arguments
+        job = self.jobs[validated_data['action']].run((validated_data['parameters']['dataset_id'],))
+        job.save()
+        return job
+
+    def validate(self, attrs):
+        """Validates the request data"""
+        # No need to check for the presence of 'action' and 'parameters',
+        # because fields are checked before this method comes into play
+        attrs['parameters'] = self.jobs[attrs['action']].check_parameters(
+            attrs['parameters']
+        )
+        return attrs
+
+
+class TaskResultSerializer(rest_framework.serializers.ModelSerializer):
+    """Serializer for TaskResult objects"""
+    class Meta:
+        model = django_celery_results.models.TaskResult
+        fields = '__all__'
+
+
+class GeographicLocationSerializer(rest_framework.serializers.ModelSerializer):
+    """Serializer for GeographicLocation objects"""
+    class Meta:
+        model = geospaas.catalog.models.GeographicLocation
+        fields = '__all__'
+
+
+class SourceSerializer(rest_framework.serializers.ModelSerializer):
+    """Serializer for Source objects"""
+    class Meta:
+        model = geospaas.catalog.models.Source
+        fields = '__all__'
+
+
+class InstrumentSerializer(rest_framework.serializers.ModelSerializer):
+    """Serializer for Instrument objects"""
+    class Meta:
+        model = geospaas.vocabularies.models.Instrument
+        fields = '__all__'
+
+
+class PlatformSerializer(rest_framework.serializers.ModelSerializer):
+    """Serializer for Source objects"""
+    class Meta:
+        model = geospaas.vocabularies.models.Platform
+        fields = '__all__'
+
+
+class PersonnelSerializer(rest_framework.serializers.ModelSerializer):
+    """Serializer for Personnel objects"""
+    class Meta:
+        model = geospaas.catalog.models.Personnel
+        fields = '__all__'
+
+
+class RoleSerializer(rest_framework.serializers.ModelSerializer):
+    """Serializer for Role objects"""
+    class Meta:
+        model = geospaas.catalog.models.Role
+        fields = '__all__'
+
+
+class DatasetSerializer(rest_framework.serializers.ModelSerializer):
+    """Serializer for Dataset objects"""
+    class Meta:
+        model = geospaas.catalog.models.Dataset
+        fields = '__all__'
+
+
+class ParameterSerializer(rest_framework.serializers.ModelSerializer):
+    """
+    Serializer for Parameter objects
+    """
+    class Meta:
+        model = geospaas.vocabularies.models.Parameter
+        fields = '__all__'
+
+
+class DatasetURISerializer(rest_framework.serializers.ModelSerializer):
+    """Serializer for DatasetURI objects"""
+    class Meta:
+        model = geospaas.catalog.models.DatasetURI
+        fields = '__all__'
+
+
+class DatasetRelationshipSerializer(rest_framework.serializers.ModelSerializer):
+    """Serializer for DatasetRelationship objects"""
+    class Meta:
+        model = geospaas.catalog.models.DatasetRelationship
+        fields = '__all__'
+
+
+class DataCenterSerializer(rest_framework.serializers.ModelSerializer):
+    """Serializer for DataCenter objects"""
+    class Meta:
+        model = geospaas.vocabularies.models.DataCenter
+        fields = '__all__'

geospaas_rest_api/v1/serializers.py

@@ -0,0 +1,16 @@
+{% load i18n %}
+<form class="form-inline">
+  <div class="form-group">
+    <div class="input-group">
+      <h3>{% trans "Date" %}</h3>
+      <input type="text" class="form-control" style="width: 350px" name="{{ params.0 }}" value="{{ terms.0 }}">
+      <h3>{% trans "Location as a WKT POLYGON" %}</h3>
+      <input type="text" class="form-control" style="width: 350px" name="{{ params.1 }}" value="{{ terms.1 }}">
+      <h3>{% trans "Source" %}</h3>
+      <input type="text" class="form-control" style="width: 350px" name="{{ params.2 }}" value="{{ terms.2 }}">
+      <br/>
+      <br/>
+      <button class="btn btn-default" type="submit"><span class="glyphicon glyphicon-search" aria-hidden="true"></span> Search</button>
+    </div>
+  </div>
+</form>

geospaas_rest_api/v1/templates/geospaas_rest_api/search.html

@@ -0,0 +1,80 @@
+
+import os
+
+# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+
+# Quick-start development settings - unsuitable for production
+# See https://docs.djangoproject.com/en/1.11/howto/deployment/checklist/
+
+# SECURITY WARNING: keep the secret key used in production secret!
+SECRET_KEY = 'chu2p96if%&^09w6okqjwc-%+hmpc1t3@b&i8*+3nvdk!xpdb0'
+
+# SECURITY WARNING: don't run with debug turned on in production!
+
+# Application definition
+
+INSTALLED_APPS = [
+    'leaflet',
+    'django_forms_bootstrap',
+    'geospaas.catalog',
+    'geospaas.vocabularies',
+    'django.contrib.sessions',
+    'django.contrib.admin',
+    'django.contrib.staticfiles',
+    'django.contrib.auth',
+    'django.contrib.contenttypes',
+    'django.contrib.messages',
+    'geospaas_rest_api',
+    'geospaas_rest_api.v1',
+    'django_celery_results',
+]
+
+MIDDLEWARE = [
+    'django.middleware.security.SecurityMiddleware',
+    'django.contrib.sessions.middleware.SessionMiddleware',
+    'django.contrib.auth.middleware.AuthenticationMiddleware',
+    'django.contrib.messages.middleware.MessageMiddleware',
+]
+
+ROOT_URLCONF = 'geospaas_rest_api.v1.tests.urls'
+
+TEMPLATES = [
+    {
+        'BACKEND': 'django.template.backends.django.DjangoTemplates',
+        'DIRS': [],
+        'APP_DIRS': True,
+        'OPTIONS': {
+            'context_processors': [
+                'django.contrib.auth.context_processors.auth',
+                'django.contrib.messages.context_processors.messages',
+            ],
+        },
+    },
+]
+
+# Database
+# https://docs.djangoproject.com/en/1.11/ref/settings/#databases
+
+DATABASES = {
+    'default': {
+        'ENGINE': 'django.contrib.gis.db.backends.spatialite',
+        'NAME': os.path.join(BASE_DIR, 'geodjango.db'),
+    }
+}
+
+# Internationalization
+# https://docs.djangoproject.com/en/1.11/topics/i18n/
+
+TIME_ZONE = 'UTC'
+
+USE_TZ = True
+
+STATIC_URL = '/static/'
+
+STATICFILES_DIRS = [
+"/project/static",
+]
+
+CELERY_RESULT_BACKEND = 'django-db'