Merge pull request #50 from Geode-solutions/feat/blueprint_routes

Feat/blueprint_routes

Author: JulienChampagnol

.gitignore

@@ -4,3 +4,4 @@ venv
 output
 __pycache__
 .vscode
+uploads

app.py

@@ -0,0 +1,54 @@
+""" Packages """
+import os
+
+import flask
+import flask_cors
+from werkzeug.exceptions import HTTPException
+
+from werkzeug.exceptions import HTTPException
+
+from src.opengeodeweb_back.routes import blueprint_routes
+
+
+""" Global config """
+app = flask.Flask(__name__)
+
+""" Config variables """
+FLASK_DEBUG = True if os.environ.get("FLASK_DEBUG", default=None) == "True" else False
+
+if FLASK_DEBUG == False:
+    app.config.from_object("config.ProdConfig")
+else:
+    app.config.from_object("config.DevConfig")
+
+
+PORT = int(app.config.get("PORT"))
+ORIGINS = app.config.get("ORIGINS")
+SSL = app.config.get("SSL")
+
+flask_cors.CORS(app, origins=ORIGINS)
+app.register_blueprint(
+    blueprint_routes.routes,
+    url_prefix="/",
+    name="blueprint_routes",
+)
+
+
+@app.errorhandler(HTTPException)
+def handle_exception(e):
+    response = e.get_response()
+    response.data = flask.json.dumps(
+        {
+            "code": e.code,
+            "name": e.name,
+            "description": e.description,
+        }
+    )
+    response.content_type = "application/json"
+    return response
+
+
+# ''' Main '''
+if __name__ == "__main__":
+    print(f"Python is running in {FLASK_DEBUG} mode")
+    app.run(debug=FLASK_DEBUG, host="0.0.0.0", port=PORT, ssl_context=SSL)

config.py

@@ -0,0 +1,29 @@
+""" Flask configuration """
+import os
+
+
+class Config(object):
+    FLASK_DEBUG = os.environ.get("FLASK_DEBUG", default=False)
+    ID = os.environ.get("ID", default=None)
+    PORT = "5000"
+    CORS_HEADERS = "Content-Type"
+    UPLOAD_FOLDER = "./uploads"
+    WORKFLOWS_DATA_FOLDER = "./data_workflows/"
+    LOCK_FOLDER = "./lock/"
+    TIME_FOLDER = "./time/"
+
+
+class ProdConfig(Config):
+    SSL = None
+    ORIGINS = ["*"]
+    MINUTES_BEFORE_TIMEOUT = "5"
+    SECONDS_BETWEEN_SHUTDOWNS = "150"
+    DATA_FOLDER = "/data/"
+
+
+class DevConfig(Config):
+    SSL = None
+    ORIGINS = "http://localhost:3000"
+    MINUTES_BEFORE_TIMEOUT = "1000"
+    SECONDS_BETWEEN_SHUTDOWNS = "60"
+    DATA_FOLDER = "./data/"

requirements.in

@@ -10,5 +10,6 @@ geode-explicit
 geode-implicit
 geode-common
 jsonschema
-flask[async]
+Flask[async]
+Flask-Cors
 werkzeug

requirements.txt

@@ -17,6 +17,10 @@ click==8.1.7
 colorama==0.4.6
     # via click
 flask[async]==3.0.0
+    # via
+    #   -r requirements.in
+    #   flask-cors
+flask-cors==4.0.0
     # via -r requirements.in
 geode-background==7.4.9
     # via

src/opengeodeweb_back/geode_functions.py

@@ -1,16 +1,15 @@
 # Standard library imports
-import base64
 import os
 import time
 import threading
 import uuid
+import zipfile
 
 # Third party imports
 import flask
 import opengeode_geosciences as og_gs
 import opengeode as og
 import pkg_resources
-import werkzeug
 from jsonschema import validate
 from jsonschema.exceptions import ValidationError
 
@@ -311,7 +310,7 @@ def send_file(upload_folder, saved_files, new_file_name):
         mimetype = "application/octet-binary"
     else:
         mimetype = "application/zip"
-        new_file_name = strict_file_name + ".zip"
+        new_file_name = os.path.splitext(new_file_name)[0] + ".zip"
         with zipfile.ZipFile(os.path.join(upload_folder, new_file_name), "w") as zipObj:
             for saved_file_path in saved_files:
                 zipObj.write(

src/opengeodeweb_back/routes/blueprint_routes.py

@@ -0,0 +1,178 @@
+# Standard library imports
+import json
+import os
+
+# Third party imports
+import flask
+import flask_cors
+from .. import geode_functions
+import werkzeug
+
+
+routes = flask.Blueprint("routes", __name__)
+flask_cors.CORS(routes)
+
+
+schemas = os.path.join(os.path.dirname(__file__), "schemas")
+
+with open(
+    os.path.join(schemas, "allowed_files.json"),
+    "r",
+) as file:
+    allowed_files_json = json.load(file)
+
+
+@routes.route(
+    allowed_files_json["route"],
+    methods=allowed_files_json["methods"],
+)
+def allowed_files():
+    geode_functions.validate_request(flask.request, allowed_files_json)
+    extensions = geode_functions.list_input_extensions(flask.request.json["key"])
+    return {"status": 200, "extensions": extensions}
+
+
+with open(
+    os.path.join(schemas, "upload_file.json"),
+    "r",
+) as file:
+    upload_file_json = json.load(file)
+
+
+@routes.route(
+    upload_file_json["route"],
+    methods=upload_file_json["methods"],
+)
+def upload_file():
+    if flask.request.method == "OPTIONS":
+        return flask.make_response({}, 200)
+
+    UPLOAD_FOLDER = flask.current_app.config["UPLOAD_FOLDER"]
+    if not os.path.exists(UPLOAD_FOLDER):
+        os.mkdir(UPLOAD_FOLDER)
+    file = flask.request.files["file"]
+    filename = werkzeug.utils.secure_filename(os.path.basename(file.filename))
+    file.save(os.path.join(UPLOAD_FOLDER, filename))
+    return flask.make_response({"message": "File uploaded"}, 201)
+
+
+with open(
+    os.path.join(schemas, "allowed_objects.json"),
+    "r",
+) as file:
+    allowed_objects_json = json.load(file)
+
+
+@routes.route(
+    allowed_objects_json["route"],
+    methods=allowed_objects_json["methods"],
+)
+def allowed_objects():
+    if flask.request.method == "OPTIONS":
+        return flask.make_response({}, 200)
+
+    UPLOAD_FOLDER = flask.current_app.config["UPLOAD_FOLDER"]
+    geode_functions.validate_request(flask.request, allowed_objects_json)
+    file_absolute_path = os.path.join(UPLOAD_FOLDER, flask.request.json["filename"])
+    allowed_objects = geode_functions.list_geode_objects(
+        file_absolute_path, flask.request.json["key"]
+    )
+    return flask.make_response({"allowed_objects": allowed_objects}, 200)
+
+
+with open(
+    os.path.join(schemas, "missing_files.json"),
+    "r",
+) as file:
+    missing_files_json = json.load(file)
+
+
+@routes.route(
+    missing_files_json["route"],
+    methods=missing_files_json["methods"],
+)
+def missing_files():
+    UPLOAD_FOLDER = flask.current_app.config["UPLOAD_FOLDER"]
+    geode_functions.validate_request(flask.request, missing_files_json)
+
+    missing_files = geode_functions.missing_files(
+        flask.request.json["input_geode_object"],
+        os.path.join(UPLOAD_FOLDER, flask.request.json["filename"]),
+    )
+    has_missing_files = missing_files.has_missing_files()
+
+    mandatory_files = []
+    for mandatory_file in missing_files.mandatory_files:
+        mandatory_files.append(os.path.basename(mandatory_file))
+
+    additional_files = []
+    for additional_file in missing_files.additional_files:
+        additional_files.append(os.path.basename(additional_file))
+
+    return flask.make_response(
+        {
+            "has_missing_files": has_missing_files,
+            "mandatory_files": mandatory_files,
+            "additional_files": additional_files,
+        },
+        200,
+    )
+
+
+with open(
+    os.path.join(schemas, "geographic_coordinate_systems.json"),
+    "r",
+) as file:
+    geographic_coordinate_systems_json = json.load(file)
+
+
+@routes.route(
+    geographic_coordinate_systems_json["route"],
+    methods=geographic_coordinate_systems_json["methods"],
+)
+def crs_converter_geographic_coordinate_systems():
+    geode_functions.validate_request(flask.request, geographic_coordinate_systems_json)
+    infos = geode_functions.geographic_coordinate_systems(
+        flask.request.json["input_geode_object"]
+    )
+    crs_list = []
+
+    for info in infos:
+        crs = {}
+        crs["name"] = info.name
+        crs["code"] = info.code
+        crs["authority"] = info.authority
+        crs_list.append(crs)
+
+    return flask.make_response({"crs_list": crs_list}, 200)
+
+
+with open(
+    os.path.join(schemas, "geode_objects_and_output_extensions.json"),
+    "r",
+) as file:
+    geode_objects_and_output_extensions_json = json.load(file)
+
+
+@routes.route(
+    geode_objects_and_output_extensions_json["route"],
+    methods=geode_objects_and_output_extensions_json["methods"],
+)
+def geode_objects_and_output_extensions():
+    UPLOAD_FOLDER = flask.current_app.config["UPLOAD_FOLDER"]
+    geode_functions.validate_request(
+        flask.request, geode_objects_and_output_extensions_json
+    )
+    data = geode_functions.load(
+        flask.request.json["input_geode_object"],
+        os.path.join(UPLOAD_FOLDER, flask.request.json["filename"]),
+    )
+    geode_objects_and_output_extensions = (
+        geode_functions.geode_objects_output_extensions(
+            flask.request.json["input_geode_object"], data
+        )
+    )
+    return flask.make_response(
+        {"geode_objects_and_output_extensions": geode_objects_and_output_extensions},
+        200,
+    )

src/opengeodeweb_back/routes/schemas/allowed_files.json

@@ -0,0 +1,20 @@
+{
+  "$id": "/allowed_files",
+  "route": "/allowed_files",
+  "methods": [
+    "POST"
+  ],
+  "type": "object",
+  "properties": {
+    "key": {
+      "type": [
+        "string",
+        "null"
+      ]
+    }
+  },
+  "required": [
+    "key"
+  ],
+  "additionalProperties": false
+}

src/opengeodeweb_back/routes/schemas/allowed_objects.json

@@ -0,0 +1,16 @@
+{
+  "$id": "/tools/allowed_objects",
+  "route": "/allowed_objects",
+  "methods": ["POST"],
+  "type": "object",
+  "properties": {
+    "filename": {
+      "type": "string"
+    },
+    "key": {
+      "type": ["string", "null"]
+    }
+  },
+  "required": ["filename", "key"],
+  "additionalProperties": false
+}

src/opengeodeweb_back/routes/schemas/geode_objects_and_output_extensions.json

@@ -0,0 +1,21 @@
+{
+  "$id": "/tools/geode_objects_and_output_extensions",
+  "route": "/geode_objects_and_output_extensions",
+  "methods": [
+    "POST"
+  ],
+  "type": "object",
+  "properties": {
+    "input_geode_object": {
+      "type": "string"
+    },
+    "filename": {
+      "type": "string"
+    }
+  },
+  "required": [
+    "input_geode_object",
+    "filename"
+  ],
+  "additionalProperties": false
+}