OpenGeodeWeb-Back 5.10.0rc6__tar.gz → 5.10.0rc9__tar.gz

{opengeodeweb_back-5.10.0rc6/src/OpenGeodeWeb_Back.egg-info → opengeodeweb_back-5.10.0rc9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenGeodeWeb-Back
-Version: 5.10.0rc6
+Version: 5.10.0rc9
 Summary: OpenGeodeWeb-Back is an open source framework that proposes handy python functions and wrappers for the OpenGeode ecosystem
 Author-email: Geode-solutions <team-web@geode-solutions.com>
 Project-URL: Homepage, https://github.com/Geode-solutions/OpenGeodeWeb-Back
@@ -17,8 +17,10 @@ Requires-Dist: click==8.2.1
 Requires-Dist: fastjsonschema==2.16.2
 Requires-Dist: flask[async]==3.0.3
 Requires-Dist: flask-cors==6.0.1
+Requires-Dist: flask-sqlalchemy==3.1.1
 Requires-Dist: geode-common==33.9.0
 Requires-Dist: geode-viewables==3.2.0
+Requires-Dist: greenlet==3.2.4
 Requires-Dist: itsdangerous==2.2.0
 Requires-Dist: jinja2==3.1.6
 Requires-Dist: markupsafe==3.0.2
@@ -27,6 +29,8 @@ Requires-Dist: opengeode-geosciences==9.2.2
 Requires-Dist: opengeode-geosciencesio==5.7.2
 Requires-Dist: opengeode-inspector==6.7.0
 Requires-Dist: opengeode-io==7.3.2
+Requires-Dist: sqlalchemy==2.0.43
+Requires-Dist: typing-extensions==4.15.0
 Requires-Dist: werkzeug==3.0.3
 Dynamic: license-file
 

{opengeodeweb_back-5.10.0rc6 → opengeodeweb_back-5.10.0rc9}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "OpenGeodeWeb-Back"
-version = "5.10.0-rc.6"
+version = "5.10.0-rc.9"
 dynamic = ["dependencies"]
 authors = [
   { name="Geode-solutions", email="team-web@geode-solutions.com" },

{opengeodeweb_back-5.10.0rc6 → opengeodeweb_back-5.10.0rc9}/requirements.txt

@@ -17,12 +17,17 @@ flask[async]==3.0.3
     #   -r requirements.in
     #   flask
     #   flask-cors
+    #   flask-sqlalchemy
 flask-cors==6.0.1
     # via -r requirements.in
+flask-sqlalchemy==3.1.1
+    # via -r requirements.in
 geode-common==33.9.0
     # via geode-viewables
 geode-viewables==3.2.0
     # via -r requirements.in
+greenlet==3.2.4
+    # via sqlalchemy
 itsdangerous==2.2.0
     # via flask
 jinja2==3.1.6
@@ -54,6 +59,10 @@ opengeode-io==7.3.2
     #   -r requirements.in
     #   geode-viewables
     #   opengeode-geosciencesio
+sqlalchemy==2.0.43
+    # via flask-sqlalchemy
+typing-extensions==4.15.0
+    # via sqlalchemy
 werkzeug==3.0.3
     # via
     #   -r requirements.in

{opengeodeweb_back-5.10.0rc6 → opengeodeweb_back-5.10.0rc9/src/OpenGeodeWeb_Back.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenGeodeWeb-Back
-Version: 5.10.0rc6
+Version: 5.10.0rc9
 Summary: OpenGeodeWeb-Back is an open source framework that proposes handy python functions and wrappers for the OpenGeode ecosystem
 Author-email: Geode-solutions <team-web@geode-solutions.com>
 Project-URL: Homepage, https://github.com/Geode-solutions/OpenGeodeWeb-Back
@@ -17,8 +17,10 @@ Requires-Dist: click==8.2.1
 Requires-Dist: fastjsonschema==2.16.2
 Requires-Dist: flask[async]==3.0.3
 Requires-Dist: flask-cors==6.0.1
+Requires-Dist: flask-sqlalchemy==3.1.1
 Requires-Dist: geode-common==33.9.0
 Requires-Dist: geode-viewables==3.2.0
+Requires-Dist: greenlet==3.2.4
 Requires-Dist: itsdangerous==2.2.0
 Requires-Dist: jinja2==3.1.6
 Requires-Dist: markupsafe==3.0.2
@@ -27,6 +29,8 @@ Requires-Dist: opengeode-geosciences==9.2.2
 Requires-Dist: opengeode-geosciencesio==5.7.2
 Requires-Dist: opengeode-inspector==6.7.0
 Requires-Dist: opengeode-io==7.3.2
+Requires-Dist: sqlalchemy==2.0.43
+Requires-Dist: typing-extensions==4.15.0
 Requires-Dist: werkzeug==3.0.3
 Dynamic: license-file
 

{opengeodeweb_back-5.10.0rc6 → opengeodeweb_back-5.10.0rc9}/src/OpenGeodeWeb_Back.egg-info/SOURCES.txt

@@ -9,6 +9,8 @@ src/OpenGeodeWeb_Back.egg-info/requires.txt
 src/OpenGeodeWeb_Back.egg-info/top_level.txt
 src/opengeodeweb_back/__init__.py
 src/opengeodeweb_back/app_config.py
+src/opengeodeweb_back/data.py
+src/opengeodeweb_back/database.py
 src/opengeodeweb_back/geode_functions.py
 src/opengeodeweb_back/geode_objects.py
 src/opengeodeweb_back/test_utils.py

{opengeodeweb_back-5.10.0rc6 → opengeodeweb_back-5.10.0rc9}/src/OpenGeodeWeb_Back.egg-info/requires.txt

@@ -4,8 +4,10 @@ click==8.2.1
 fastjsonschema==2.16.2
 flask[async]==3.0.3
 flask-cors==6.0.1
+flask-sqlalchemy==3.1.1
 geode-common==33.9.0
 geode-viewables==3.2.0
+greenlet==3.2.4
 itsdangerous==2.2.0
 jinja2==3.1.6
 markupsafe==3.0.2
@@ -14,4 +16,6 @@ opengeode-geosciences==9.2.2
 opengeode-geosciencesio==5.7.2
 opengeode-inspector==6.7.0
 opengeode-io==7.3.2
+sqlalchemy==2.0.43
+typing-extensions==4.15.0
 werkzeug==3.0.3

{opengeodeweb_back-5.10.0rc6 → opengeodeweb_back-5.10.0rc9}/src/opengeodeweb_back/app_config.py

@@ -4,6 +4,7 @@ import time
 
 # Third party imports
 # Local application imports
+from .database import DATABASE_FILENAME
 
 
 class Config(object):
@@ -15,6 +16,7 @@ class Config(object):
     REQUEST_COUNTER = 0
     LAST_REQUEST_TIME = time.time()
     LAST_PING_TIME = time.time()
+    SQLALCHEMY_TRACK_MODIFICATIONS = False
 
 
 class ProdConfig(Config):
@@ -22,7 +24,10 @@ class ProdConfig(Config):
     ORIGINS = ""
     MINUTES_BEFORE_TIMEOUT = "1"
     SECONDS_BETWEEN_SHUTDOWNS = "10"
-    DATA_FOLDER_PATH = "/data/"
+    DATA_FOLDER_PATH = "/data"
+    SQLALCHEMY_DATABASE_URI = f"sqlite:///{os.path.abspath(
+        os.path.join(DATA_FOLDER_PATH, DATABASE_FILENAME)
+        )}"
 
 
 class DevConfig(Config):
@@ -30,4 +35,8 @@ class DevConfig(Config):
     ORIGINS = "*"
     MINUTES_BEFORE_TIMEOUT = "1"
     SECONDS_BETWEEN_SHUTDOWNS = "10"
-    DATA_FOLDER_PATH = "./data/"
+    BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+    DATA_FOLDER_PATH = os.path.join(BASE_DIR, "data")
+    SQLALCHEMY_DATABASE_URI = f"sqlite:///{os.path.join(
+        BASE_DIR, DATA_FOLDER_PATH, DATABASE_FILENAME
+        )}"

opengeodeweb_back-5.10.0rc9/src/opengeodeweb_back/data.py

@@ -0,0 +1,45 @@
+from sqlalchemy import String, JSON
+from sqlalchemy.orm import Mapped, mapped_column
+from .database import database, Base
+import uuid
+
+
+class Data(Base):
+    __tablename__ = "datas"
+
+    id: Mapped[str] = mapped_column(
+        String, primary_key=True, default=lambda: str(uuid.uuid4()).replace("-", "")
+    )
+    native_file_name: Mapped[str] = mapped_column(String, nullable=False)
+    viewable_file_name: Mapped[str] = mapped_column(String, nullable=False)
+    geode_object: Mapped[str] = mapped_column(String, nullable=False)
+
+    light_viewable: Mapped[str | None] = mapped_column(String, nullable=True)
+    input_file: Mapped[str | None] = mapped_column(String, nullable=True)
+    additional_files: Mapped[list[str] | None] = mapped_column(JSON, nullable=True)
+
+    @staticmethod
+    def create(
+        geode_object: str,
+        input_file: str | None = None,
+        additional_files: list[str] | None = None,
+    ) -> "Data":
+        input_file = input_file if input_file is not None else ""
+        additional_files = additional_files if additional_files is not None else []
+
+        data_entry = Data(
+            geode_object=geode_object,
+            input_file=input_file,
+            additional_files=additional_files,
+            native_file_name="",
+            viewable_file_name="",
+            light_viewable=None,
+        )
+
+        database.session.add(data_entry)
+        database.session.flush()
+        return data_entry
+
+    @staticmethod
+    def get(data_id: str) -> "Data | None":
+        return database.session.get(Data, data_id)

opengeodeweb_back-5.10.0rc9/src/opengeodeweb_back/database.py

@@ -0,0 +1,19 @@
+from flask import Flask
+from flask_sqlalchemy import SQLAlchemy
+from sqlalchemy.orm import DeclarativeBase
+
+DATABASE_FILENAME = "project.db"
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+database = SQLAlchemy(model_class=Base)
+
+
+def initialize_database(app: Flask) -> SQLAlchemy:
+    database.init_app(app)
+    with app.app_context():
+        database.create_all()
+    return database

{opengeodeweb_back-5.10.0rc6 → opengeodeweb_back-5.10.0rc9}/src/opengeodeweb_back/geode_functions.py

@@ -6,10 +6,13 @@ import opengeode_geosciences as og_gs  # type: ignore
 import opengeode as og  # type: ignore
 import werkzeug
 import flask
+from typing import Any
 
 # Local application imports
 from .geode_objects import geode_objects_dict
 from . import utils_functions
+from .data import Data
+from .database import database
 
 
 def geode_object_value(geode_object: str):
@@ -45,21 +48,32 @@ def load(geode_object: str, file_absolute_path: str):
     return geode_object_value(geode_object)["load"](file_absolute_path)
 
 
-def data_file_path(data_id: str, filename: str) -> str:
+def data_file_path(data_id: str, filename: str = "") -> str:
     data_folder_path = flask.current_app.config["DATA_FOLDER_PATH"]
-    return os.path.join(
-        data_folder_path,
-        data_id,
-        werkzeug.utils.secure_filename(filename),
-    )
+    if filename:
+        return os.path.join(data_folder_path, data_id, filename)
+    return os.path.join(data_folder_path, data_id)
+
+
+def load_data(data_id: str) -> Any:
+    data_entry = Data.get(data_id)
+    if not data_entry:
+        flask.abort(404, f"Data with id {data_id} not found")
+
+    file_absolute_path = data_file_path(data_id, data_entry.native_file_name)
+    return load(data_entry.geode_object, file_absolute_path)
+
 
+def get_data_info(data_id: str) -> Data:
+    from .data import Data
 
-def load_data(geode_object: str, data_id: str, filename: str):
-    file_absolute_path = data_file_path(data_id, filename)
-    return load(geode_object, file_absolute_path)
+    data_entry = Data.get(data_id)
+    if not data_entry:
+        flask.abort(404, f"Data with id {data_id} not found")
+    return data_entry
 
 
-def upload_file_path(filename):
+def upload_file_path(filename: str) -> str:
     upload_folder = flask.current_app.config["UPLOAD_FOLDER"]
     secure_filename = werkzeug.utils.secure_filename(filename)
     return os.path.abspath(os.path.join(upload_folder, secure_filename))

{opengeodeweb_back-5.10.0rc6 → opengeodeweb_back-5.10.0rc9}/src/opengeodeweb_back/routes/blueprint_routes.py

@@ -53,7 +53,7 @@ with open(
 def allowed_files():
     utils_functions.validate_request(flask.request, allowed_files_json)
     extensions = geode_functions.list_input_extensions(
-        flask.request.json["supported_feature"]
+        flask.request.get_json()["supported_feature"]
     )
     return flask.make_response({"extensions": extensions}, 200)
 
@@ -99,10 +99,10 @@ def allowed_objects():
 
     utils_functions.validate_request(flask.request, allowed_objects_json)
     file_absolute_path = geode_functions.upload_file_path(
-        flask.request.json["filename"]
+        flask.request.get_json()["filename"]
     )
     allowed_objects = geode_functions.list_geode_objects(
-        file_absolute_path, flask.request.json["supported_feature"]
+        file_absolute_path, flask.request.get_json()["supported_feature"]
     )
     return flask.make_response({"allowed_objects": allowed_objects}, 200)
 
@@ -120,10 +120,10 @@ with open(
 )
 def missing_files():
     utils_functions.validate_request(flask.request, missing_files_json)
-    file_path = geode_functions.upload_file_path(flask.request.json["filename"])
+    file_path = geode_functions.upload_file_path(flask.request.get_json()["filename"])
 
     additional_files = geode_functions.additional_files(
-        flask.request.json["input_geode_object"],
+        flask.request.get_json()["input_geode_object"],
         file_path,
     )
 
@@ -167,7 +167,7 @@ with open(
 def crs_converter_geographic_coordinate_systems():
     utils_functions.validate_request(flask.request, geographic_coordinate_systems_json)
     infos = geode_functions.geographic_coordinate_systems(
-        flask.request.json["input_geode_object"]
+        flask.request.get_json()["input_geode_object"]
     )
     crs_list = []
     for info in infos:
@@ -194,10 +194,12 @@ with open(
 def inspect_file():
     utils_functions.validate_request(flask.request, inspect_file_json)
 
-    file_path = geode_functions.upload_file_path(flask.request.json["filename"])
-    data = geode_functions.load(flask.request.json["input_geode_object"], file_path)
+    file_path = geode_functions.upload_file_path(flask.request.get_json()["filename"])
+    data = geode_functions.load(
+        flask.request.get_json()["input_geode_object"], file_path
+    )
     class_inspector = geode_functions.inspect(
-        flask.request.json["input_geode_object"], data
+        flask.request.get_json()["input_geode_object"], data
     )
     inspection_result = geode_functions.get_inspector_children(class_inspector)
     return flask.make_response({"inspection_result": inspection_result}, 200)
@@ -218,14 +220,14 @@ def geode_objects_and_output_extensions():
     utils_functions.validate_request(
         flask.request, geode_objects_and_output_extensions_json
     )
-    file_path = geode_functions.upload_file_path(flask.request.json["filename"])
+    file_path = geode_functions.upload_file_path(flask.request.get_json()["filename"])
     data = geode_functions.load(
-        flask.request.json["input_geode_object"],
+        flask.request.get_json()["input_geode_object"],
         file_path,
     )
     geode_objects_and_output_extensions = (
         geode_functions.geode_objects_output_extensions(
-            flask.request.json["input_geode_object"], data
+            flask.request.get_json()["input_geode_object"], data
         )
     )
     return flask.make_response(
@@ -249,8 +251,8 @@ def save_viewable_file():
     utils_functions.validate_request(flask.request, save_viewable_file_json)
     return flask.make_response(
         utils_functions.generate_native_viewable_and_light_viewable_from_file(
-            geode_object=flask.request.json["input_geode_object"],
-            input_filename=flask.request.json["filename"],
+            geode_object=flask.request.get_json()["input_geode_object"],
+            input_filename=flask.request.get_json()["filename"],
         ),
         200,
     )
@@ -263,10 +265,10 @@ with open(os.path.join(schemas, "create_point.json"), "r") as file:
 @routes.route(create_point_json["route"], methods=create_point_json["methods"])
 def create_point():
     utils_functions.validate_request(flask.request, create_point_json)
-    title = flask.request.json["title"]
-    x = flask.request.json["x"]
-    y = flask.request.json["y"]
-    z = flask.request.json["z"]
+    title = flask.request.get_json()["title"]
+    x = flask.request.get_json()["x"]
+    y = flask.request.get_json()["y"]
+    z = flask.request.get_json()["z"]
     class_ = geode_functions.geode_object_class("PointSet3D")
     PointSet3D = class_.create()
     builder = geode_functions.create_builder("PointSet3D", PointSet3D)
@@ -290,14 +292,8 @@ with open(os.path.join(schemas, "texture_coordinates.json"), "r") as file:
 )
 def texture_coordinates():
     utils_functions.validate_request(flask.request, texture_coordinates_json)
-    data = geode_functions.load_data(
-        flask.request.json["input_geode_object"],
-        flask.request.json["id"],
-        flask.request.json["filename"],
-    )
-
+    data = geode_functions.load_data(flask.request.get_json().get("id"))
     texture_coordinates = data.texture_manager().texture_names()
-
     return flask.make_response({"texture_coordinates": texture_coordinates}, 200)
 
 
@@ -314,14 +310,8 @@ with open(
 )
 def vertex_attribute_names():
     utils_functions.validate_request(flask.request, vertex_attribute_names_json)
-    data = geode_functions.load_data(
-        flask.request.json["input_geode_object"],
-        flask.request.json["id"],
-        flask.request.json["filename"],
-    )
-
+    data = geode_functions.load_data(flask.request.get_json().get("id"))
     vertex_attribute_names = data.vertex_attribute_manager().attribute_names()
-
     return flask.make_response(
         {
             "vertex_attribute_names": vertex_attribute_names,
@@ -343,14 +333,8 @@ with open(
 )
 def polygon_attribute_names():
     utils_functions.validate_request(flask.request, polygon_attribute_names_json)
-    data = geode_functions.load_data(
-        flask.request.json["input_geode_object"],
-        flask.request.json["id"],
-        flask.request.json["filename"],
-    )
-
+    data = geode_functions.load_data(flask.request.get_json().get("id"))
     polygon_attribute_names = data.polygon_attribute_manager().attribute_names()
-
     return flask.make_response(
         {
             "polygon_attribute_names": polygon_attribute_names,
@@ -372,14 +356,8 @@ with open(
 )
 def polyhedron_attribute_names():
     utils_functions.validate_request(flask.request, polyhedron_attribute_names_json)
-    data = geode_functions.load_data(
-        flask.request.json["input_geode_object"],
-        flask.request.json["id"],
-        flask.request.json["filename"],
-    )
-
+    data = geode_functions.load_data(flask.request.get_json().get("id"))
     polyhedron_attribute_names = data.polyhedron_attribute_manager().attribute_names()
-
     return flask.make_response(
         {
             "polyhedron_attribute_names": polyhedron_attribute_names,

{opengeodeweb_back-5.10.0rc6 → opengeodeweb_back-5.10.0rc9}/src/opengeodeweb_back/routes/models/blueprint_models.py

@@ -20,7 +20,7 @@ def uuid_to_flat_index():
     utils_functions.validate_request(flask.request, vtm_component_indices_json)
 
     vtm_file_path = geode_functions.data_file_path(
-        flask.request.json["id"], "viewable.vtm"
+        flask.request.get_json().get("id"), "viewable.vtm"
     )
     tree = ET.parse(vtm_file_path)
     root = tree.find("vtkMultiBlockDataSet")
@@ -49,12 +49,6 @@ with open(os.path.join(schemas, "mesh_components.json"), "r") as file:
 @routes.route(mesh_components_json["route"], methods=mesh_components_json["methods"])
 def extract_uuids_endpoint():
     utils_functions.validate_request(flask.request, mesh_components_json)
-
-    model = geode_functions.load_data(
-        flask.request.json["geode_object"],
-        flask.request.json["id"],
-        flask.request.json["filename"],
-    )
-
+    model = geode_functions.load_data(flask.request.get_json().get("id"))
     uuid_dict = extract_model_uuids(model)
     return flask.make_response({"uuid_dict": uuid_dict}, 200)

{opengeodeweb_back-5.10.0rc6 → opengeodeweb_back-5.10.0rc9}/src/opengeodeweb_back/routes/models/schemas/mesh_components.json

@@ -8,20 +8,10 @@
     "id": {
       "type": "string",
       "minLength": 1      
-    },
-    "filename": {
-      "type": "string",
-      "minLength": 1
-    },
-    "geode_object": {
-      "type": "string",
-      "minLength": 1
     }
   },
   "required": [
-    "id",
-    "filename",
-    "geode_object"
+    "id"
   ],
   "additionalProperties": false
 }

{opengeodeweb_back-5.10.0rc6 → opengeodeweb_back-5.10.0rc9}/src/opengeodeweb_back/routes/schemas/polygon_attribute_names.json

@@ -5,22 +5,12 @@
   ],
   "type": "object",
   "properties": {
-    "input_geode_object": {
-      "type": "string",
-      "minLength": 1
-    },
-    "filename": {
-      "type": "string",
-      "minLength": 1
-    },
     "id": {
       "type": "string",
       "minLength": 1
     }
   },
   "required": [
-    "input_geode_object",
-    "filename",
     "id"
   ],
   "additionalProperties": false

{opengeodeweb_back-5.10.0rc6 → opengeodeweb_back-5.10.0rc9}/src/opengeodeweb_back/routes/schemas/polyhedron_attribute_names.json

@@ -5,22 +5,12 @@
   ],
   "type": "object",
   "properties": {
-    "input_geode_object": {
-      "type": "string",
-      "minLength": 1
-    },
-    "filename": {
-      "type": "string",
-      "minLength": 1
-    },
     "id": {
       "type": "string",
       "minLength": 1
     }
   },
   "required": [
-    "input_geode_object",
-    "filename",
     "id"
   ],
   "additionalProperties": false

{opengeodeweb_back-5.10.0rc6 → opengeodeweb_back-5.10.0rc9}/src/opengeodeweb_back/routes/schemas/texture_coordinates.json

@@ -5,23 +5,13 @@
   ],
   "type": "object",
   "properties": {
-    "input_geode_object": {
-      "type": "string",
-      "minLength": 1
-    },
-    "filename": {
-      "type": "string",
-      "minLength": 1
-    },
     "id": {
       "type": "string",
       "minLength": 1
     }
   },
   "required": [
-    "input_geode_object",
-    "id",
-    "filename"
+    "id"
   ],
   "additionalProperties": false
 }

{opengeodeweb_back-5.10.0rc6 → opengeodeweb_back-5.10.0rc9}/src/opengeodeweb_back/routes/schemas/vertex_attribute_names.json

@@ -5,22 +5,12 @@
   ],
   "type": "object",
   "properties": {
-    "input_geode_object": {
-      "type": "string",
-      "minLength": 1
-    },
-    "filename": {
-      "type": "string",
-      "minLength": 1
-    },
     "id": {
       "type": "string",
       "minLength": 1
     }
   },
   "required": [
-    "input_geode_object",
-    "filename",
     "id"
   ],
   "additionalProperties": false

{opengeodeweb_back-5.10.0rc6 → opengeodeweb_back-5.10.0rc9}/src/opengeodeweb_back/utils_functions.py

@@ -2,7 +2,6 @@
 import os
 import threading
 import time
-import uuid
 import zipfile
 from collections.abc import Callable
 from typing import Any
@@ -17,6 +16,8 @@ import werkzeug
 
 # Local application imports
 from . import geode_functions
+from .data import Data
+from .database import database
 
 
 def increment_request_counter(current_app: flask.Flask) -> None:
@@ -152,17 +153,28 @@ def handle_exception(exception: HTTPException) -> flask.Response:
     return response
 
 
-def create_unique_data_folder() -> tuple[str, str]:
+def create_data_folder_from_id(data_id: str) -> str:
     base_data_folder = flask.current_app.config["DATA_FOLDER_PATH"]
-    generated_id = str(uuid.uuid4()).replace("-", "")
-    data_path = os.path.join(base_data_folder, generated_id)
+    data_path = os.path.join(base_data_folder, data_id)
     os.makedirs(data_path, exist_ok=True)
-    return generated_id, data_path
+    return data_path
 
 
 def save_all_viewables_and_return_info(
-    geode_object, data, generated_id, data_path, additional_files=None
-):
+    geode_object: str,
+    data: Any,
+    input_file: str,
+    additional_files: list[str] | None = None,
+) -> dict[str, Any]:
+    if additional_files is None:
+        additional_files = []
+
+    data_entry = Data.create(
+        geode_object=geode_object,
+        input_file=input_file,
+        additional_files=additional_files,
+    )
+    data_path = create_data_folder_from_id(data_entry.id)
     saved_native_file_path = geode_functions.save(
         geode_object,
         data,
@@ -177,28 +189,40 @@ def save_all_viewables_and_return_info(
     )
     with open(saved_light_viewable_file_path, "rb") as f:
         binary_light_viewable = f.read()
+    data_entry.native_file_name = os.path.basename(saved_native_file_path[0])
+    data_entry.viewable_file_name = os.path.basename(saved_viewable_file_path)
+    data_entry.light_viewable = os.path.basename(saved_light_viewable_file_path)
+
+    database.session.commit()
 
     return {
-        "name": data.name(),
-        "native_file_name": os.path.basename(saved_native_file_path[0]),
-        "viewable_file_name": os.path.basename(saved_viewable_file_path),
-        "id": generated_id,
+        "native_file_name": data_entry.native_file_name,
+        "viewable_file_name": data_entry.viewable_file_name,
+        "id": data_entry.id,
         "object_type": geode_functions.get_object_type(geode_object),
         "binary_light_viewable": binary_light_viewable.decode("utf-8"),
-        "geode_object": geode_object,
-        "input_files": additional_files or [],
+        "geode_object": data_entry.geode_object,
+        "input_files": data_entry.input_file,
+        "additional_files": data_entry.additional_files,
     }
 
 
-def generate_native_viewable_and_light_viewable_from_object(geode_object, data):
-    generated_id, data_path = create_unique_data_folder()
-    return save_all_viewables_and_return_info(
-        geode_object, data, generated_id, data_path
-    )
+def generate_native_viewable_and_light_viewable_from_object(
+    geode_object: str, data: Any
+) -> dict[str, Any]:
+    return save_all_viewables_and_return_info(geode_object, data, input_file="")
 
 
-def generate_native_viewable_and_light_viewable_from_file(geode_object, input_filename):
-    generated_id, data_path = create_unique_data_folder()
+def generate_native_viewable_and_light_viewable_from_file(
+    geode_object: str, input_filename: str
+) -> dict[str, Any]:
+    temp_data_entry = Data.create(
+        geode_object=geode_object,
+        input_file=input_filename,
+        additional_files=[],
+    )
+
+    data_path = create_data_folder_from_id(temp_data_entry.id)
 
     full_input_filename = geode_functions.upload_file_path(input_filename)
     copied_full_path = os.path.join(
@@ -206,7 +230,7 @@ def generate_native_viewable_and_light_viewable_from_file(geode_object, input_fi
     )
     shutil.copy2(full_input_filename, copied_full_path)
 
-    additional_files_copied = []
+    additional_files_copied: list[str] = []
     additional = geode_functions.additional_files(geode_object, full_input_filename)
     for additional_file in additional.mandatory_files + additional.optional_files:
         if additional_file.is_missing:
@@ -221,12 +245,14 @@ def generate_native_viewable_and_light_viewable_from_file(geode_object, input_fi
         shutil.copy2(source_path, dest_path)
         additional_files_copied.append(additional_file.filename)
 
-    data = geode_functions.load_data(geode_object, generated_id, input_filename)
+    data = geode_functions.load(geode_object, copied_full_path)
+
+    database.session.delete(temp_data_entry)
+    database.session.flush()
 
     return save_all_viewables_and_return_info(
         geode_object,
         data,
-        generated_id,
-        data_path,
+        input_file=input_filename,
         additional_files=additional_files_copied,
     )

{opengeodeweb_back-5.10.0rc6 → opengeodeweb_back-5.10.0rc9}/tests/test_models_routes.py

@@ -3,6 +3,8 @@ import shutil
 import flask
 
 from src.opengeodeweb_back import geode_functions
+from src.opengeodeweb_back.data import Data
+from src.opengeodeweb_back.database import database
 
 
 def test_model_mesh_components(client, test_id):
@@ -28,14 +30,18 @@ def test_model_mesh_components(client, test_id):
 
 def test_extract_brep_uuids(client, test_id):
     route = "/models/mesh_components"
-
     brep_filename = "cube.og_brep"
-    json_data = {"id": test_id, "geode_object": "BRep", "filename": brep_filename}
 
     with client.application.app_context():
-        data_path = geode_functions.data_file_path(json_data["id"], brep_filename)
+        data_entry = Data.create(geode_object="BRep", input_file=brep_filename)
+        data_entry.native_file_name = brep_filename
+        database.session.commit()
+
+        data_path = geode_functions.data_file_path(data_entry.id, brep_filename)
         os.makedirs(os.path.dirname(data_path), exist_ok=True)
         shutil.copy(f"./tests/data/{brep_filename}", data_path)
+
+    json_data = {"id": data_entry.id}
     response = client.post(route, json=json_data)
 
     assert response.status_code == 200

{opengeodeweb_back-5.10.0rc6 → opengeodeweb_back-5.10.0rc9}/tests/test_routes.py

@@ -6,7 +6,9 @@ import shutil
 from werkzeug.datastructures import FileStorage
 
 # Local application imports
-from src.opengeodeweb_back import geode_functions, geode_objects, test_utils
+from src.opengeodeweb_back import geode_functions, test_utils
+from src.opengeodeweb_back.data import Data
+from src.opengeodeweb_back.database import database
 
 
 def test_allowed_files(client):
@@ -151,13 +153,11 @@ def test_save_viewable_file(client):
     # Normal test with filename 'corbi.og_brep'
     response = client.post(route, json=get_full_data())
     assert response.status_code == 200
-    name = response.json["name"]
-    assert type(name) is str
     native_file_name = response.json["native_file_name"]
     assert type(native_file_name) is str
     viewable_file_name = response.json["viewable_file_name"]
     assert type(viewable_file_name) is str
-    id = response.json["id"]
+    id = response.json.get("id")
     assert type(id) is str
     object_type = response.json["object_type"]
     assert type(object_type) is str
@@ -171,17 +171,18 @@ def test_save_viewable_file(client):
 
 def test_texture_coordinates(client, test_id):
     with client.application.app_context():
-        data_path = geode_functions.data_file_path(test_id, "hat.vtp")
+        data = Data.create(geode_object="PolygonalSurface3D", input_file="hat.vtp")
+        data.native_file_name = "hat.vtp"
+        database.session.commit()
+
+        data_path = geode_functions.data_file_path(data.id, "hat.vtp")
+        print(data_path)
         os.makedirs(os.path.dirname(data_path), exist_ok=True)
         shutil.copy("./tests/data/hat.vtp", data_path)
 
     response = client.post(
         "/texture_coordinates",
-        json={
-            "input_geode_object": "PolygonalSurface3D",
-            "id": test_id,
-            "filename": "hat.vtp",
-        },
+        json={"id": data.id},
     )
     assert response.status_code == 200
     texture_coordinates = response.json["texture_coordinates"]
@@ -192,119 +193,63 @@ def test_texture_coordinates(client, test_id):
 
 def test_vertex_attribute_names(client, test_id):
     route = f"/vertex_attribute_names"
-    for geode_object, value in geode_objects.geode_objects_dict().items():
-        if value["object_type"] == "mesh":
-            input_extensions = geode_functions.geode_object_input_extensions(
-                geode_object
-            )
-            if "elements" in value:
-                elements = geode_functions.get_elements(geode_object)
-                if "points" in elements:
-                    for input_extension in input_extensions:
-                        if (
-                            geode_functions.is_loadable(
-                                geode_object,
-                                os.path.join("./data", f"test.{input_extension}"),
-                            )
-                            > 0.0
-                        ):
-
-                            def get_full_data():
-                                return {
-                                    "input_geode_object": geode_object,
-                                    "id": test_id,
-                                    "filename": f"test.{input_extension}",
-                                }
-
-                            response = client.post(route, json=get_full_data())
-                            assert response.status_code == 200
-                            vertex_attribute_names = response.json[
-                                "vertex_attribute_names"
-                            ]
-                            assert type(vertex_attribute_names) is list
-                            for vertex_attribute_name in vertex_attribute_names:
-                                assert type(vertex_attribute_name) is str
 
-    # Test all params
-    test_utils.test_route_wrong_params(client, route, get_full_data)
+    with client.application.app_context():
+        data = Data.create(geode_object="PolygonalSurface3D", input_file="test.vtp")
+        data.native_file_name = "test.vtp"
+        database.session.commit()
+
+        data_path = geode_functions.data_file_path(data.id, "test.vtp")
+        os.makedirs(os.path.dirname(data_path), exist_ok=True)
+        if os.path.exists("./tests/data/hat.vtp"):
+            shutil.copy("./tests/data/hat.vtp", data_path)
+
+    response = client.post(route, json={"id": data.id})
+    assert response.status_code == 200
+    vertex_attribute_names = response.json["vertex_attribute_names"]
+    assert type(vertex_attribute_names) is list
+    for vertex_attribute_name in vertex_attribute_names:
+        assert type(vertex_attribute_name) is str
 
 
 def test_polygon_attribute_names(client, test_id):
     route = f"/polygon_attribute_names"
-    for geode_object, value in geode_objects.geode_objects_dict().items():
-        if value["object_type"] == "mesh":
-            input_extensions = geode_functions.geode_object_input_extensions(
-                geode_object
-            )
-            if "elements" in value:
-                elements = geode_functions.get_elements(geode_object)
-                if "polygons" in elements:
-                    for input_extension in input_extensions:
-                        if (
-                            geode_functions.is_loadable(
-                                geode_object,
-                                os.path.join("./data", f"test.{input_extension}"),
-                            )
-                            > 0.0
-                        ):
-
-                            def get_full_data():
-                                return {
-                                    "input_geode_object": geode_object,
-                                    "id": test_id,
-                                    "filename": f"test.{input_extension}",
-                                }
-
-                            response = client.post(route, json=get_full_data())
-                            assert response.status_code == 200
-                            polygon_attribute_names = response.json[
-                                "polygon_attribute_names"
-                            ]
-                            assert type(polygon_attribute_names) is list
-                            for polygon_attribute_name in polygon_attribute_names:
-                                assert type(polygon_attribute_name) is str
 
-    # Test all params
-    test_utils.test_route_wrong_params(client, route, get_full_data)
+    with client.application.app_context():
+        data = Data.create(geode_object="PolygonalSurface3D", input_file="test.vtp")
+        data.native_file_name = "test.vtp"
+        database.session.commit()
+
+        data_path = geode_functions.data_file_path(data.id, "test.vtp")
+        os.makedirs(os.path.dirname(data_path), exist_ok=True)
+    shutil.copy("./tests/data/test.vtp", data_path)
+
+    response = client.post(route, json={"id": data.id})
+    assert response.status_code == 200
+    polygon_attribute_names = response.json["polygon_attribute_names"]
+    assert type(polygon_attribute_names) is list
+    for polygon_attribute_name in polygon_attribute_names:
+        assert type(polygon_attribute_name) is str
 
 
 def test_polyhedron_attribute_names(client, test_id):
     route = f"/polyhedron_attribute_names"
-    for geode_object, value in geode_objects.geode_objects_dict().items():
-        if value["object_type"] == "mesh":
-            input_extensions = geode_functions.geode_object_input_extensions(
-                geode_object
-            )
-            if "elements" in value:
-                elements = geode_functions.get_elements(geode_object)
-                if "polyhedrons" in elements:
-                    for input_extension in input_extensions:
-                        if (
-                            geode_functions.is_loadable(
-                                geode_object,
-                                os.path.join("./data", f"test.{input_extension}"),
-                            )
-                            > 0.0
-                        ):
-
-                            def get_full_data():
-                                return {
-                                    "input_geode_object": geode_object,
-                                    "id": test_id,
-                                    "filename": f"test.{input_extension}",
-                                }
-
-                            response = client.post(route, json=get_full_data())
-                            assert response.status_code == 200
-                            polyhedron_attribute_names = response.json[
-                                "polyhedron_attribute_names"
-                            ]
-                            assert type(polyhedron_attribute_names) is list
-                            for polyhedron_attribute_name in polyhedron_attribute_names:
-                                assert type(polyhedron_attribute_name) is str
 
-    # Test all params
-    test_utils.test_route_wrong_params(client, route, get_full_data)
+    with client.application.app_context():
+        data = Data.create(geode_object="PolyhedralSolid3D", input_file="test.vtu")
+        data.native_file_name = "test.vtu"
+        database.session.commit()
+
+        data_path = geode_functions.data_file_path(data.id, "test.vtu")
+        os.makedirs(os.path.dirname(data_path), exist_ok=True)
+        shutil.copy("./tests/data/test.vtu", data_path)
+
+    response = client.post(route, json={"id": data.id})
+    assert response.status_code == 200
+    polyhedron_attribute_names = response.json["polyhedron_attribute_names"]
+    assert type(polyhedron_attribute_names) is list
+    for polyhedron_attribute_name in polyhedron_attribute_names:
+        assert type(polyhedron_attribute_name) is str
 
 
 def test_create_point(client):
@@ -316,8 +261,20 @@ def test_create_point(client):
     assert response.status_code == 200
     viewable_file_name = response.json["viewable_file_name"]
     assert type(viewable_file_name) is str
-    id = response.json["id"]
+    id = response.json.get("id")
     assert type(id) is str
 
     # Test all params
     test_utils.test_route_wrong_params(client, route, get_full_data)
+
+
+def test_database_uri_path(client):
+    app = client.application
+    with app.app_context():
+        base_dir = os.path.abspath(os.path.dirname(__file__))
+        expected_db_path = os.path.join(base_dir, "data", "project.db")
+        expected_uri = f"sqlite:///{expected_db_path}"
+
+        assert app.config["SQLALCHEMY_DATABASE_URI"] == expected_uri
+
+        assert os.path.exists(expected_db_path)

{opengeodeweb_back-5.10.0rc6 → opengeodeweb_back-5.10.0rc9}/tests/test_utils_functions.py

@@ -5,8 +5,11 @@ import os
 # Third party imports
 import flask
 import shutil
+import uuid
 
 # Local application imports
+from src.opengeodeweb_back.database import database
+from src.opengeodeweb_back.data import Data
 from src.opengeodeweb_back import geode_functions, utils_functions
 
 
@@ -72,15 +75,15 @@ def test_handle_exception(client):
     assert type(data["code"]) is int
 
 
-def test_create_unique_data_folder(client):
+def test_create_data_folder_from_id(client):
     app = client.application
     with app.app_context():
-        generated_id, data_path = utils_functions.create_unique_data_folder()
-        assert isinstance(generated_id, str)
-        assert re.fullmatch(r"[0-9a-f]{32}", generated_id)
+        test_id = str(uuid.uuid4()).replace("-", "")
+        data_path = utils_functions.create_data_folder_from_id(test_id)
+        assert isinstance(data_path, str)
         assert os.path.exists(data_path)
         assert data_path.startswith(flask.current_app.config["DATA_FOLDER_PATH"])
-        assert generated_id in data_path
+        assert test_id in data_path
         shutil.rmtree(data_path, ignore_errors=True)
         assert not os.path.exists(data_path)
 
@@ -88,24 +91,64 @@ def test_create_unique_data_folder(client):
 def test_save_all_viewables_and_return_info(client):
     app = client.application
     with app.app_context():
+        base_dir = os.path.abspath(os.path.dirname(__file__))
+        expected_db_path = os.path.join(base_dir, "data", "project.db")
+        expected_uri = f"sqlite:///{expected_db_path}"
+
+        assert app.config["SQLALCHEMY_DATABASE_URI"] == expected_uri
+        assert os.path.exists(expected_db_path)
+
         geode_object = "BRep"
         data = geode_functions.load(geode_object, "./tests/data/test.og_brep")
-        generated_id, data_path = utils_functions.create_unique_data_folder()
+        input_file = "test.og_brep"
         additional_files = ["additional_file.txt"]
 
         result = utils_functions.save_all_viewables_and_return_info(
-            geode_object, data, generated_id, data_path, additional_files
+            geode_object, data, input_file, additional_files
         )
 
-    assert isinstance(result, dict)
-    assert result["name"] == data.name()
-    assert result["native_file_name"].startswith("native.")
-    assert result["viewable_file_name"].endswith(".vtm")
-    assert re.match(r"[0-9a-f]{32}", result["id"])
-    assert isinstance(result["object_type"], str)
-    assert isinstance(result["binary_light_viewable"], str)
-    assert result["geode_object"] == geode_object
-    assert result["input_files"] == additional_files
+        assert isinstance(result, dict)
+        assert result["native_file_name"].startswith("native.")
+        assert result["viewable_file_name"].endswith(".vtm")
+        assert isinstance(result["id"], str)
+        assert len(result["id"]) == 32
+        assert re.match(r"[0-9a-f]{32}", result["id"])
+        assert isinstance(result["object_type"], str)
+        assert isinstance(result["binary_light_viewable"], str)
+        assert result["geode_object"] == geode_object
+        assert result["input_files"] == input_file
+
+        db_entry = Data.get(result["id"])
+        assert db_entry is not None
+        assert db_entry.native_file_name == result["native_file_name"]
+        assert db_entry.viewable_file_name == result["viewable_file_name"]
+        assert db_entry.geode_object == geode_object
+        assert db_entry.input_file == input_file
+        assert db_entry.additional_files == additional_files
+
+        expected_data_path = os.path.join(app.config["DATA_FOLDER_PATH"], result["id"])
+        assert os.path.exists(expected_data_path)
+
+
+def test_save_all_viewables_commits_to_db(client):
+    app = client.application
+    with app.app_context():
+        geode_object = "BRep"
+        data = geode_functions.load(geode_object, "./tests/data/test.og_brep")
+        input_file = "test.og_brep"
+        result = utils_functions.save_all_viewables_and_return_info(
+            geode_object, data, input_file
+        )
+        data_id = result["id"]
+        db_entry_before = Data.get(data_id)
+        assert db_entry_before is not None
+        assert db_entry_before.native_file_name == result["native_file_name"]
+        database.session.rollback()
+        db_entry_after = Data.get(data_id)
+        assert (
+            db_entry_after is not None
+        ), "database.session.commit() was not called - entry missing after rollback"
+        assert db_entry_after.native_file_name == result["native_file_name"]
 
 
 def test_generate_native_viewable_and_light_viewable_from_object(client):
@@ -121,7 +164,6 @@ def test_generate_native_viewable_and_light_viewable_from_object(client):
         )
 
     assert isinstance(result, dict)
-    assert isinstance(result["name"], str)
     assert isinstance(result["native_file_name"], str)
     assert result["native_file_name"].startswith("native.")
     assert isinstance(result["viewable_file_name"], str)
@@ -130,7 +172,7 @@ def test_generate_native_viewable_and_light_viewable_from_object(client):
     assert re.match(r"[0-9a-f]{32}", result["id"])
     assert isinstance(result["object_type"], str)
     assert isinstance(result["binary_light_viewable"], str)
-    assert result["input_files"] == []
+    assert result["input_files"] == ""
 
 
 def test_generate_native_viewable_and_light_viewable_from_file(client):
@@ -144,7 +186,6 @@ def test_generate_native_viewable_and_light_viewable_from_file(client):
         )
 
     assert isinstance(result, dict)
-    assert isinstance(result["name"], str)
     assert isinstance(result["native_file_name"], str)
     assert result["native_file_name"].startswith("native.")
     assert isinstance(result["viewable_file_name"], str)
@@ -153,4 +194,4 @@ def test_generate_native_viewable_and_light_viewable_from_file(client):
     assert re.match(r"[0-9a-f]{32}", result["id"])
     assert isinstance(result["object_type"], str)
     assert isinstance(result["binary_light_viewable"], str)
-    assert isinstance(result["input_files"], list)
+    assert isinstance(result["input_files"], str)