better

Author: BotellaA

src/opengeodeweb_back/routes/blueprint_routes.py

@@ -21,36 +21,25 @@
     name=blueprint_models.routes.name,
 )
 
-schemas_folder = os.path.join(os.path.dirname(__file__), "schemas")
-
-with open(
-    os.path.join(schemas_folder, "allowed_files.json"),
-    "r",
-) as file:
-    allowed_files_json: utils_functions.SchemaDict = json.load(file)
+schemas_dict = utils_functions.get_schemas_dict(
+    os.path.join(os.path.dirname(__file__), "schemas")
+)
 
 
 @routes.route(
-    allowed_files_json["route"],
-    methods=allowed_files_json["methods"],
+    schemas_dict["allowed_files"]["route"],
+    methods=schemas_dict["allowed_files"]["methods"],
 )
 def allowed_files() -> flask.Response:
-    utils_functions.validate_request(flask.request, allowed_files_json)
+    utils_functions.validate_request(flask.request, schemas_dict["allowed_files"])
     params = schemas.AllowedFiles(**flask.request.get_json())
     extensions = geode_functions.list_input_extensions(params.supported_feature)
     return flask.make_response({"extensions": extensions}, 200)
 
 
-with open(
-    os.path.join(schemas_folder, "upload_file.json"),
-    "r",
-) as file:
-    upload_file_json: utils_functions.SchemaDict = json.load(file)
-
-
 @routes.route(
-    upload_file_json["route"],
-    methods=upload_file_json["methods"],
+    schemas_dict["upload_file"]["route"],
+    methods=schemas_dict["upload_file"]["methods"],
 )
 def upload_file() -> flask.Response:
     if flask.request.method == "OPTIONS":
@@ -65,22 +54,15 @@ def upload_file() -> flask.Response:
     return flask.make_response({"message": "File uploaded"}, 201)
 
 
-with open(
-    os.path.join(schemas_folder, "allowed_objects.json"),
-    "r",
-) as file:
-    allowed_objects_json: utils_functions.SchemaDict = json.load(file)
-
-
 @routes.route(
-    allowed_objects_json["route"],
-    methods=allowed_objects_json["methods"],
+    schemas_dict["allowed_objects"]["route"],
+    methods=schemas_dict["allowed_objects"]["methods"],
 )
 def allowed_objects() -> flask.Response:
     if flask.request.method == "OPTIONS":
         return flask.make_response({}, 200)
 
-    utils_functions.validate_request(flask.request, allowed_objects_json)
+    utils_functions.validate_request(flask.request, schemas_dict["allowed_objects"])
     params = schemas.AllowedObjects(**flask.request.get_json())
     file_absolute_path = geode_functions.upload_file_path(params.filename)
     allowed_objects = geode_functions.list_geode_objects(
@@ -89,19 +71,12 @@ def allowed_objects() -> flask.Response:
     return flask.make_response({"allowed_objects": allowed_objects}, 200)
 
 
-with open(
-    os.path.join(schemas_folder, "missing_files.json"),
-    "r",
-) as file:
-    missing_files_json: utils_functions.SchemaDict = json.load(file)
-
-
 @routes.route(
-    missing_files_json["route"],
-    methods=missing_files_json["methods"],
+    schemas_dict["missing_files"]["route"],
+    methods=schemas_dict["missing_files"]["methods"],
 )
 def missing_files() -> flask.Response:
-    utils_functions.validate_request(flask.request, missing_files_json)
+    utils_functions.validate_request(flask.request, schemas_dict["missing_files"])
     params = schemas.MissingFiles(**flask.request.get_json())
     file_path = geode_functions.upload_file_path(params.filename)
 
@@ -136,19 +111,14 @@ def missing_files() -> flask.Response:
     )
 
 
-with open(
-    os.path.join(schemas_folder, "geographic_coordinate_systems.json"),
-    "r",
-) as file:
-    geographic_coordinate_systems_json: utils_functions.SchemaDict = json.load(file)
-
-
 @routes.route(
-    geographic_coordinate_systems_json["route"],
-    methods=geographic_coordinate_systems_json["methods"],
+    schemas_dict["geographic_coordinate_systems"]["route"],
+    methods=schemas_dict["geographic_coordinate_systems"]["methods"],
 )
 def crs_converter_geographic_coordinate_systems() -> flask.Response:
-    utils_functions.validate_request(flask.request, geographic_coordinate_systems_json)
+    utils_functions.validate_request(
+        flask.request, schemas_dict["geographic_coordinate_systems"]
+    )
     params = schemas.GeographicCoordinateSystems(**flask.request.get_json())
     infos = geode_functions.geographic_coordinate_systems(params.input_geode_object)
     crs_list = []
@@ -162,19 +132,12 @@ def crs_converter_geographic_coordinate_systems() -> flask.Response:
     return flask.make_response({"crs_list": crs_list}, 200)
 
 
-with open(
-    os.path.join(schemas_folder, "inspect_file.json"),
-    "r",
-) as file:
-    inspect_file_json: utils_functions.SchemaDict = json.load(file)
-
-
 @routes.route(
-    inspect_file_json["route"],
-    methods=inspect_file_json["methods"],
+    schemas_dict["inspect_file"]["route"],
+    methods=schemas_dict["inspect_file"]["methods"],
 )
 def inspect_file() -> flask.Response:
-    utils_functions.validate_request(flask.request, inspect_file_json)
+    utils_functions.validate_request(flask.request, schemas_dict["inspect_file"])
     params = schemas.InspectFile(**flask.request.get_json())
     file_path = geode_functions.upload_file_path(params.filename)
     data = geode_functions.load(params.input_geode_object, file_path)
@@ -183,22 +146,13 @@ def inspect_file() -> flask.Response:
     return flask.make_response({"inspection_result": inspection_result}, 200)
 
 
-with open(
-    os.path.join(schemas_folder, "geode_objects_and_output_extensions.json"),
-    "r",
-) as file:
-    geode_objects_and_output_extensions_json: utils_functions.SchemaDict = json.load(
-        file
-    )
-
-
 @routes.route(
-    geode_objects_and_output_extensions_json["route"],
-    methods=geode_objects_and_output_extensions_json["methods"],
+    schemas_dict["geode_objects_and_output_extensions"]["route"],
+    methods=schemas_dict["geode_objects_and_output_extensions"]["methods"],
 )
 def geode_objects_and_output_extensions() -> flask.Response:
     utils_functions.validate_request(
-        flask.request, geode_objects_and_output_extensions_json
+        flask.request, schemas_dict["geode_objects_and_output_extensions"]
     )
     params = schemas.GeodeObjectsAndOutputExtensions(**flask.request.get_json())
     file_path = geode_functions.upload_file_path(params.filename)
@@ -215,19 +169,12 @@ def geode_objects_and_output_extensions() -> flask.Response:
     )
 
 
-with open(
-    os.path.join(schemas_folder, "save_viewable_file.json"),
-    "r",
-) as file:
-    save_viewable_file_json: utils_functions.SchemaDict = json.load(file)
-
-
 @routes.route(
-    save_viewable_file_json["route"],
-    methods=save_viewable_file_json["methods"],
+    schemas_dict["save_viewable_file"]["route"],
+    methods=schemas_dict["save_viewable_file"]["methods"],
 )
 def save_viewable_file() -> flask.Response:
-    utils_functions.validate_request(flask.request, save_viewable_file_json)
+    utils_functions.validate_request(flask.request, schemas_dict["save_viewable_file"])
     params = schemas.SaveViewableFile(**flask.request.get_json())
     return flask.make_response(
         utils_functions.generate_native_viewable_and_light_viewable_from_file(
@@ -238,35 +185,26 @@ def save_viewable_file() -> flask.Response:
     )
 
 
-with open(os.path.join(schemas_folder, "texture_coordinates.json"), "r") as file:
-    texture_coordinates_json: utils_functions.SchemaDict = json.load(file)
-
-
 @routes.route(
-    texture_coordinates_json["route"],
-    methods=texture_coordinates_json["methods"],
+    schemas_dict["texture_coordinates"]["route"],
+    methods=schemas_dict["texture_coordinates"]["methods"],
 )
 def texture_coordinates() -> flask.Response:
-    utils_functions.validate_request(flask.request, texture_coordinates_json)
+    utils_functions.validate_request(flask.request, schemas_dict["texture_coordinates"])
     params = schemas.TextureCoordinates(**flask.request.get_json())
     data = geode_functions.load_data(params.id)
     texture_coordinates = data.texture_manager().texture_names()
     return flask.make_response({"texture_coordinates": texture_coordinates}, 200)
 
 
-with open(
-    os.path.join(schemas_folder, "vertex_attribute_names.json"),
-    "r",
-) as file:
-    vertex_attribute_names_json: utils_functions.SchemaDict = json.load(file)
-
-
 @routes.route(
-    vertex_attribute_names_json["route"],
-    methods=vertex_attribute_names_json["methods"],
+    schemas_dict["vertex_attribute_names"]["route"],
+    methods=schemas_dict["vertex_attribute_names"]["methods"],
 )
 def vertex_attribute_names() -> flask.Response:
-    utils_functions.validate_request(flask.request, vertex_attribute_names_json)
+    utils_functions.validate_request(
+        flask.request, schemas_dict["vertex_attribute_names"]
+    )
     params = schemas.VertexAttributeNames(**flask.request.get_json())
     data = geode_functions.load_data(params.id)
     vertex_attribute_names = data.vertex_attribute_manager().attribute_names()
@@ -278,19 +216,14 @@ def vertex_attribute_names() -> flask.Response:
     )
 
 
-with open(
-    os.path.join(schemas_folder, "polygon_attribute_names.json"),
-    "r",
-) as file:
-    polygon_attribute_names_json: utils_functions.SchemaDict = json.load(file)
-
-
 @routes.route(
-    polygon_attribute_names_json["route"],
-    methods=polygon_attribute_names_json["methods"],
+    schemas_dict["polygon_attribute_names"]["route"],
+    methods=schemas_dict["polygon_attribute_names"]["methods"],
 )
 def polygon_attribute_names() -> flask.Response:
-    utils_functions.validate_request(flask.request, polygon_attribute_names_json)
+    utils_functions.validate_request(
+        flask.request, schemas_dict["polygon_attribute_names"]
+    )
     params = schemas.PolygonAttributeNames(**flask.request.get_json())
     data = geode_functions.load_data(params.id)
     polygon_attribute_names = data.polygon_attribute_manager().attribute_names()
@@ -302,19 +235,14 @@ def polygon_attribute_names() -> flask.Response:
     )
 
 
-with open(
-    os.path.join(schemas_folder, "polyhedron_attribute_names.json"),
-    "r",
-) as file:
-    polyhedron_attribute_names_json: utils_functions.SchemaDict = json.load(file)
-
-
 @routes.route(
-    polyhedron_attribute_names_json["route"],
-    methods=polyhedron_attribute_names_json["methods"],
+    schemas_dict["polyhedron_attribute_names"]["route"],
+    methods=schemas_dict["polyhedron_attribute_names"]["methods"],
 )
 def polyhedron_attribute_names() -> flask.Response:
-    utils_functions.validate_request(flask.request, polyhedron_attribute_names_json)
+    utils_functions.validate_request(
+        flask.request, schemas_dict["polyhedron_attribute_names"]
+    )
     params = schemas.PolyhedronAttributeNames(**flask.request.get_json())
     data = geode_functions.load_data(params.id)
     polyhedron_attribute_names = data.polyhedron_attribute_manager().attribute_names()
@@ -326,31 +254,17 @@ def polyhedron_attribute_names() -> flask.Response:
     )
 
 
-with open(
-    os.path.join(schemas_folder, "ping.json"),
-    "r",
-) as file:
-    ping_json: utils_functions.SchemaDict = json.load(file)
-
-
 @routes.route(
-    ping_json["route"],
-    methods=ping_json["methods"],
+    schemas_dict["ping"]["route"],
+    methods=schemas_dict["ping"]["methods"],
 )
 def ping() -> flask.Response:
-    utils_functions.validate_request(flask.request, ping_json)
+    utils_functions.validate_request(flask.request, schemas_dict["ping"])
     flask.current_app.config.update(LAST_PING_TIME=time.time())
     return flask.make_response({"message": "Flask server is running"}, 200)
 
 
-with open(
-    os.path.join(schemas_folder, "kill.json"),
-    "r",
-) as file:
-    kill_json: utils_functions.SchemaDict = json.load(file)
-
-
-@routes.route(kill_json["route"], methods=kill_json["methods"])
+@routes.route(schemas_dict["kill"]["route"], methods=schemas_dict["kill"]["methods"])
 def kill() -> flask.Response:
     print("Manual server kill, shutting down...", flush=True)
     os._exit(0)

src/opengeodeweb_back/routes/create/blueprint_create.py

@@ -12,19 +12,19 @@
 from . import schemas
 
 routes = flask.Blueprint("create", __name__, url_prefix="/create")
-schemas_folder = os.path.join(os.path.dirname(__file__), "schemas")
+schemas_dict = utils_functions.get_schemas_dict(
+    os.path.join(os.path.dirname(__file__), "schemas")
+)
 
 
-# Load schemas
-with open(os.path.join(schemas_folder, "create_point.json"), "r") as file:
-    create_point_json: utils_functions.SchemaDict = json.load(file)
-
-
-@routes.route(create_point_json["route"], methods=create_point_json["methods"])
+@routes.route(
+    schemas_dict["create_point"]["route"],
+    methods=schemas_dict["create_point"]["methods"],
+)
 def create_point() -> flask.Response:
     """Endpoint to create a single point in 3D space."""
     print(f"create_point : {flask.request=}", flush=True)
-    utils_functions.validate_request(flask.request, create_point_json)
+    utils_functions.validate_request(flask.request, schemas_dict["create_point"])
     params = schemas.CreatePoint(**flask.request.get_json())
 
     # Create the point
@@ -42,16 +42,13 @@ def create_point() -> flask.Response:
     return flask.make_response(result, 200)
 
 
-# Load schema for AOI creation
-with open(os.path.join(schemas_folder, "create_aoi.json"), "r") as file:
-    create_aoi_json: utils_functions.SchemaDict = json.load(file)
-
-
-@routes.route(create_aoi_json["route"], methods=create_aoi_json["methods"])
+@routes.route(
+    schemas_dict["create_aoi"]["route"], methods=schemas_dict["create_aoi"]["methods"]
+)
 def create_aoi() -> flask.Response:
     """Endpoint to create an Area of Interest (AOI) as an EdgedCurve3D."""
     print(f"create_aoi : {flask.request=}", flush=True)
-    utils_functions.validate_request(flask.request, create_aoi_json)
+    utils_functions.validate_request(flask.request, schemas_dict["create_aoi"])
     params = schemas.CreateAoi(**flask.request.get_json())
 
     # Create the edged curve