Continue refactoring of API #1405 in remaining files (#1842)

* Refactor landing_page api to new style

* Refactor openapi view to new style

* Refactor remaining core api views

* Update tests which reference core apis

* Refactor get_config_ from admin api to new style

* Refactor remaining admin api views to new style

* Remove reference to api function which does not exist

This is necessary for subsequent refactorings

* Remove now unsed api helper code

* Remove APIRequest.with_data

* Update APIRequest documentation

Author: totycro

pygeoapi/admin.py

@@ -35,19 +35,21 @@
 
 """Integration module for Django"""
 
-from typing import Tuple, Dict, Mapping, Optional, Union
+from typing import Optional, Union
 
 from django.conf import settings
 from django.http import HttpRequest, HttpResponse
 
 from pygeoapi.api import API, APIRequest, apply_gzip
+import pygeoapi.api as core_api
 import pygeoapi.api.coverages as coverages_api
 import pygeoapi.api.environmental_data_retrieval as edr_api
 import pygeoapi.api.itemtypes as itemtypes_api
 import pygeoapi.api.maps as maps_api
 import pygeoapi.api.processes as processes_api
 import pygeoapi.api.stac as stac_api
 import pygeoapi.api.tiles as tiles_api
+import pygeoapi.admin as admin_api
 
 
 def landing_page(request: HttpRequest) -> HttpResponse:
@@ -59,10 +61,7 @@ def landing_page(request: HttpRequest) -> HttpResponse:
     :returns: Django HTTP Response
     """
 
-    response_ = _feed_response(request, 'landing_page')
-    response = _to_django_response(*response_)
-
-    return response
+    return execute_from_django(core_api.landing_page, request)
 
 
 def openapi(request: HttpRequest) -> HttpResponse:
@@ -74,10 +73,7 @@ def openapi(request: HttpRequest) -> HttpResponse:
     :returns: Django HTTP Response
     """
 
-    response_ = _feed_response(request, 'openapi_')
-    response = _to_django_response(*response_)
-
-    return response
+    return execute_from_django(core_api.openapi_, request)
 
 
 def conformance(request: HttpRequest) -> HttpResponse:
@@ -88,11 +84,7 @@ def conformance(request: HttpRequest) -> HttpResponse:
 
     :returns: Django HTTP Response
     """
-
-    response_ = _feed_response(request, 'conformance')
-    response = _to_django_response(*response_)
-
-    return response
+    return execute_from_django(core_api.conformance, request)
 
 
 def tilematrixsets(request: HttpRequest,
@@ -126,9 +118,8 @@ def collections(request: HttpRequest,
     :returns: Django HTTP Response
     """
 
-    response_ = _feed_response(request, 'describe_collections', collection_id)
-
-    return _to_django_response(*response_)
+    return execute_from_django(core_api.describe_collections, request,
+                               collection_id)
 
 
 def collection_schema(request: HttpRequest,
@@ -142,7 +133,7 @@ def collection_schema(request: HttpRequest,
     :returns: Django HTTP Response
     """
 
-    return execute_from_django(itemtypes_api.get_collection_schema, request,
+    return execute_from_django(core_api.get_collection_schema, request,
                                collection_id)
 
 
@@ -484,13 +475,13 @@ def admin_config(request: HttpRequest) -> HttpResponse:
     """
 
     if request.method == 'GET':
-        return _feed_response(request, 'get_admin_config')
+        return execute_from_django(admin_api.get_config_, request)
 
     elif request.method == 'PUT':
-        return _feed_response(request, 'put_admin_config')
+        return execute_from_django(admin_api.put_config, request)
 
     elif request.method == 'PATCH':
-        return _feed_response(request, 'patch_admin_config')
+        return execute_from_django(admin_api.patch_config, request)
 
 
 def admin_config_resources(request: HttpRequest) -> HttpResponse:
@@ -501,10 +492,10 @@ def admin_config_resources(request: HttpRequest) -> HttpResponse:
     """
 
     if request.method == 'GET':
-        return _feed_response(request, 'get_admin_config_resources')
+        return execute_from_django(admin_api.get_resources, request)
 
     elif request.method == 'POST':
-        return _feed_response(request, 'put_admin_config_resources')
+        return execute_from_django(admin_api.put_resource, request)
 
 
 def admin_config_resource(request: HttpRequest,
@@ -516,36 +507,20 @@ def admin_config_resource(request: HttpRequest,
     """
 
     if request.method == 'GET':
-        return _feed_response(request, 'put_admin_config_resource',
-                              resource_id)
+        return execute_from_django(admin_api.get_resource, request,
+                                   resource_id)
 
     elif request.method == 'DELETE':
-        return _feed_response(request, 'delete_admin_config_resource',
-                              resource_id)
+        return execute_from_django(admin_api.delete_resource, request,
+                                   resource_id)
 
     elif request.method == 'PUT':
-        return _feed_response(request, 'put_admin_config_resource',
-                              resource_id)
+        return execute_from_django(admin_api.put_resource, request,
+                                   resource_id)
 
     elif request.method == 'PATCH':
-        return _feed_response(request, 'patch_admin_config_resource',
-                              resource_id)
-
-
-# TODO: remove this when all views have been refactored
-def _feed_response(request: HttpRequest, api_definition: str,
-                   *args, **kwargs) -> Tuple[Dict, int, str]:
-    """Use pygeoapi api to process the input request"""
-
-    if 'admin' in api_definition and settings.PYGEOAPI_CONFIG['server'].get('admin'):  # noqa
-        from pygeoapi.admin import Admin
-        api_ = Admin(settings.PYGEOAPI_CONFIG, settings.OPENAPI_DOCUMENT)
-    else:
-        api_ = API(settings.PYGEOAPI_CONFIG, settings.OPENAPI_DOCUMENT)
-
-    api = getattr(api_, api_definition)
-
-    return api(request, *args, **kwargs)
+        return execute_from_django(admin_api.patch_resource, request,
+                                   resource_id)
 
 
 def execute_from_django(api_function, request: HttpRequest, *args,
@@ -567,15 +542,8 @@ def execute_from_django(api_function, request: HttpRequest, *args,
         headers, status, content = api_function(api_, api_request, *args)
         content = apply_gzip(headers, content)
 
-    return _to_django_response(headers, status, content)
-
-
-# TODO: inline this to execute_from_django after refactoring
-def _to_django_response(headers: Mapping, status_code: int,
-                        content: Union[str, bytes]) -> HttpResponse:
-    """Convert API payload to a django response"""
-
-    response = HttpResponse(content, status=status_code)
+    # Convert API payload to a django response
+    response = HttpResponse(content, status=status)
 
     for key, value in headers.items():
         response[key] = value

pygeoapi/api/__init__.py

@@ -38,13 +38,15 @@
                    send_from_directory, Response, Request)
 
 from pygeoapi.api import API, APIRequest, apply_gzip
+import pygeoapi.api as core_api
 import pygeoapi.api.coverages as coverages_api
 import pygeoapi.api.environmental_data_retrieval as edr_api
 import pygeoapi.api.itemtypes as itemtypes_api
 import pygeoapi.api.maps as maps_api
 import pygeoapi.api.processes as processes_api
 import pygeoapi.api.stac as stac_api
 import pygeoapi.api.tiles as tiles_api
+import pygeoapi.admin as admin_api
 from pygeoapi.openapi import load_openapi_document
 from pygeoapi.config import get_config
 from pygeoapi.util import get_mimetype, get_api_rules
@@ -118,50 +120,39 @@ def schemas(path):
                                    mimetype=get_mimetype(basename_))
 
 
-# TODO: inline in execute_from_flask when all views have been refactored
-def get_response(result: tuple):
-    """
-    Creates a Flask Response object and updates matching headers.
-
-    :param result: The result of the API call.
-                   This should be a tuple of (headers, status, content).
-
-    :returns: A Response instance
-    """
-
-    headers, status, content = result
-    response = make_response(content, status)
-
-    if headers:
-        response.headers = headers
-    return response
-
-
 def execute_from_flask(api_function, request: Request, *args,
-                       skip_valid_check=False) -> Response:
+                       skip_valid_check=False,
+                       alternative_api=None
+                       ) -> Response:
     """
     Executes API function from Flask
 
     :param api_function: API function
     :param request: request object
     :param *args: variable length additional arguments
     :param skip_validity_check: bool
+    :param alternative_api: specify custom api instance such as Admin
 
     :returns: A Response instance
     """
 
-    api_request = APIRequest.from_flask(request, api_.locales)
+    actual_api = api_ if alternative_api is None else alternative_api
+
+    api_request = APIRequest.from_flask(request, actual_api.locales)
 
     content: Union[str, bytes]
 
     if not skip_valid_check and not api_request.is_valid():
-        headers, status, content = api_.get_format_exception(api_request)
+        headers, status, content = actual_api.get_format_exception(api_request)
     else:
-        headers, status, content = api_function(api_, api_request, *args)
+        headers, status, content = api_function(actual_api, api_request, *args)
         content = apply_gzip(headers, content)
-        # handle jsonld too?
 
-    return get_response((headers, status, content))
+    response = make_response(content, status)
+
+    if headers:
+        response.headers = headers
+    return response
 
 
 @BLUEPRINT.route('/')
@@ -171,7 +162,7 @@ def landing_page():
 
     :returns: HTTP response
     """
-    return get_response(api_.landing_page(request))
+    return execute_from_flask(core_api.landing_page, request)
 
 
 @BLUEPRINT.route('/openapi')
@@ -182,7 +173,7 @@ def openapi():
     :returns: HTTP response
     """
 
-    return get_response(api_.openapi_(request))
+    return execute_from_flask(core_api.openapi_, request)
 
 
 @BLUEPRINT.route('/conformance')
@@ -193,7 +184,7 @@ def conformance():
     :returns: HTTP response
     """
 
-    return get_response(api_.conformance(request))
+    return execute_from_flask(core_api.conformance, request)
 
 
 @BLUEPRINT.route('/TileMatrixSets/<tileMatrixSetId>')
@@ -232,7 +223,8 @@ def collections(collection_id=None):
     :returns: HTTP response
     """
 
-    return get_response(api_.describe_collections(request, collection_id))
+    return execute_from_flask(core_api.describe_collections, request,
+                              collection_id)
 
 
 @BLUEPRINT.route('/collections/<path:collection_id>/schema')
@@ -245,7 +237,8 @@ def collection_schema(collection_id):
     :returns: HTTP response
     """
 
-    return get_response(api_.get_collection_schema(request, collection_id))
+    return execute_from_flask(core_api.get_collection_schema, request,
+                              collection_id)
 
 
 @BLUEPRINT.route('/collections/<path:collection_id>/queryables')
@@ -466,23 +459,6 @@ def get_job_result(job_id=None):
     return execute_from_flask(processes_api.get_job_result, request, job_id)
 
 
-@BLUEPRINT.route('/jobs/<job_id>/results/<resource>',
-                 methods=['GET'])
-def get_job_result_resource(job_id, resource):
-    """
-    OGC API - Processes job result resource endpoint
-
-    :param job_id: job identifier
-    :param resource: job resource
-
-    :returns: HTTP response
-    """
-
-    # TODO: this does not seem to exist?
-    return get_response(api_.get_job_result_resource(
-        request, job_id, resource))
-
-
 @BLUEPRINT.route('/collections/<path:collection_id>/position')
 @BLUEPRINT.route('/collections/<path:collection_id>/area')
 @BLUEPRINT.route('/collections/<path:collection_id>/cube')
@@ -556,13 +532,16 @@ def admin_config():
     """
 
     if request.method == 'GET':
-        return get_response(admin_.get_config(request))
+        return execute_from_flask(admin_api.get_config_, request,
+                                  alternative_api=admin_)
 
     elif request.method == 'PUT':
-        return get_response(admin_.put_config(request))
+        return execute_from_flask(admin_api.put_config, request,
+                                  alternative_api=admin_)
 
     elif request.method == 'PATCH':
-        return get_response(admin_.patch_config(request))
+        return execute_from_flask(admin_api.patch_config, request,
+                                  alternative_api=admin_)
 
 
 @ADMIN_BLUEPRINT.route('/admin/config/resources', methods=['GET', 'POST'])
@@ -574,10 +553,12 @@ def admin_config_resources():
     """
 
     if request.method == 'GET':
-        return get_response(admin_.get_resources(request))
+        return execute_from_flask(admin_api.get_resources, request,
+                                  alternative_api=admin_)
 
     elif request.method == 'POST':
-        return get_response(admin_.post_resource(request))
+        return execute_from_flask(admin_api.post_resource, request,
+                                  alternative_api=admin_)
 
 
 @ADMIN_BLUEPRINT.route(
@@ -591,16 +572,24 @@ def admin_config_resource(resource_id):
     """
 
     if request.method == 'GET':
-        return get_response(admin_.get_resource(request, resource_id))
+        return execute_from_flask(admin_api.get_resource, request,
+                                  resource_id,
+                                  alternative_api=admin_)
 
     elif request.method == 'DELETE':
-        return get_response(admin_.delete_resource(request, resource_id))
+        return execute_from_flask(admin_api.delete_resource, request,
+                                  resource_id,
+                                  alternative_api=admin_)
 
     elif request.method == 'PUT':
-        return get_response(admin_.put_resource(request, resource_id))
+        return execute_from_flask(admin_api.put_resource, request,
+                                  resource_id,
+                                  alternative_api=admin_)
 
     elif request.method == 'PATCH':
-        return get_response(admin_.patch_resource(request, resource_id))
+        return execute_from_flask(admin_api.patch_resource, request,
+                                  resource_id,
+                                  alternative_api=admin_)
 
 
 APP.register_blueprint(BLUEPRINT)