id and data infos set by database

Author: MaxNumerique

src/opengeodeweb_back/app_config.py

@@ -4,6 +4,7 @@
 
 # Third party imports
 # Local application imports
+from .database import DATABASE_FILENAME
 
 
 class Config(object):
@@ -25,7 +26,7 @@ class ProdConfig(Config):
     SECONDS_BETWEEN_SHUTDOWNS = "10"
     DATA_FOLDER_PATH = "/data"
     SQLALCHEMY_DATABASE_URI = f"sqlite:///{os.path.abspath(
-        os.path.join(DATA_FOLDER_PATH, 'db.sqlite3')
+        os.path.join(DATA_FOLDER_PATH, DATABASE_FILENAME)
         )}"
 
 
@@ -37,5 +38,5 @@ class DevConfig(Config):
     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, 'db.sqlite3'
+        BASE_DIR, DATA_FOLDER_PATH, DATABASE_FILENAME
         )}"

src/opengeodeweb_back/data.py

@@ -1,15 +1,33 @@
 from sqlalchemy import String, JSON
-from .database import db
+from .database import database
+import uuid
 
 
-class Data(db.Model):
+class Data(database.Model):
     __tablename__ = "datas"
 
-    id = db.Column(String, primary_key=True)
-    name = db.Column(String, nullable=False)
-    native_file_name = db.Column(String, nullable=False)
-    viewable_file_name = db.Column(String, nullable=False)
-    light_viewable = db.Column(String, nullable=True)
-    geode_object = db.Column(String, nullable=False)
-    input_file = db.Column(JSON, nullable=True)
-    additional_files = db.Column(JSON, nullable=True)
+    id = database.Column(
+        String, 
+        primary_key=True, 
+        default=lambda: str(uuid.uuid4()).replace("-", "")
+    )
+    name = database.Column(String, nullable=False)
+    native_file_name = database.Column(String, nullable=False)
+    viewable_file_name = database.Column(String, nullable=False)
+    light_viewable = database.Column(String, nullable=True)
+    geode_object = database.Column(String, nullable=False)
+    input_file = database.Column(JSON, nullable=True)
+    additional_files = database.Column(JSON, nullable=True)
+
+    @staticmethod
+    def create(name, geode_object, input_file, additional_files=[]):
+        data_entry = Data(
+            name=name,
+            geode_object=geode_object,
+            input_file=input_file,
+            additional_files=additional_files,
+        )
+        
+        database.session.add(data_entry)
+        database.session.flush()
+        return data_entry

src/opengeodeweb_back/database.py

@@ -1,10 +1,12 @@
 from flask_sqlalchemy import SQLAlchemy
 
-db = SQLAlchemy()
+DATABASE_FILENAME = "project.db"
+
+database = SQLAlchemy()
 
 
 def initialize_database(app):
-    db.init_app(app)
+    database.init_app(app)
     with app.app_context():
-        db.create_all()
-    return db
+        database.create_all()
+    return database

src/opengeodeweb_back/utils_functions.py

@@ -2,7 +2,6 @@
 import os
 import threading
 import time
-import uuid
 import zipfile
 
 # Third party imports
@@ -15,7 +14,7 @@
 # Local application imports
 from . import geode_functions
 from .data import Data
-from .database import db
+from .database import database
 
 
 def increment_request_counter(current_app):
@@ -147,17 +146,23 @@ def handle_exception(e):
     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, data, input_file, additional_files=None
 ):
+    data_entry = Data.create(
+        name=data.name(),
+        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,
@@ -172,42 +177,35 @@ def save_all_viewables_and_return_info(
     )
     with open(saved_light_viewable_file_path, "rb") as f:
         binary_light_viewable = f.read()
-
-    data_entry = Data(
-        id=generated_id,
-        name=data.name(),
-        native_file_name=os.path.basename(saved_native_file_path[0]),
-        viewable_file_name=os.path.basename(saved_viewable_file_path),
-        light_viewable=os.path.basename(saved_light_viewable_file_path),
-        geode_object=geode_object,
-        input_file=additional_files or [],
-        additional_files=additional_files or [],
-    )
-
-    db.session.add(data_entry)
-    db.session.commit()
+    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),
+        "name": data_entry.name,
+        "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.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
-    )
+    return save_all_viewables_and_return_info(geode_object, data)
 
 
 def generate_native_viewable_and_light_viewable_from_file(geode_object, input_filename):
-    generated_id, data_path = create_unique_data_folder()
+    temp_data_entry = Data.create_and_get_id(
+        name="temp",
+        geode_object=geode_object
+    )
+    
+    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(
@@ -230,12 +228,13 @@ 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_data(geode_object, temp_data_entry.id, input_filename)
+
+    database.session.delete(temp_data_entry)
+    database.session.flush()
 
     return save_all_viewables_and_return_info(
         geode_object,
         data,
-        generated_id,
-        data_path,
         additional_files=additional_files_copied,
     )

tests/test_utils_functions.py

@@ -5,9 +5,10 @@
 # Third party imports
 import flask
 import shutil
+import uuid
 
 # Local application imports
-from src.opengeodeweb_back.database import db
+from src.opengeodeweb_back.database import database
 from src.opengeodeweb_back.data import Data
 from src.opengeodeweb_back import geode_functions, utils_functions
 
@@ -74,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)
 
@@ -99,35 +100,37 @@ def test_save_all_viewables_and_return_info(client):
 
         geode_object = "BRep"
         data = geode_functions.load(geode_object, "./tests/data/test.og_brep")
-        folder_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, folder_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 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"] == additional_files
+        assert result["input_files"] == input_file  
 
         db_entry = Data.query.get(result["id"])
         assert db_entry is not None
         assert db_entry.name == data.name()
-        assert db_entry.native_file_name == os.path.basename(result["native_file_name"])
-        assert db_entry.viewable_file_name == os.path.basename(
-            result["viewable_file_name"]
-        )
-        assert db_entry.light_viewable == os.path.basename(db_entry.light_viewable)
+        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 == additional_files
+        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_generate_native_viewable_and_light_viewable_from_object(client):
     app = client.application