refactor database : integrate sqlite database for object management

Author: MaxNumerique

src/opengeodeweb_viewer/config.py

@@ -7,11 +7,15 @@
 def default_config():
     os.environ["DEFAULT_HOST"] = "localhost"
     os.environ["DEFAULT_PORT"] = "1234"
+    os.environ["DATABASE_PATH"] = os.path.join(
+        os.environ.get("DATA_FOLDER_PATH", "/data/"), "project.db"
+    )
 
 
 def prod_config():
     default_config()
     os.environ["DATA_FOLDER_PATH"] = "/data/"
+    os.environ["DATABASE_PATH"] = os.path.join("/data/", "project.db")
 
 
 def dev_config():
@@ -24,6 +28,9 @@ def dev_config():
         )
     if not os.path.exists(os.environ.get("DATA_FOLDER_PATH")):
         os.mkdir(os.environ.get("DATA_FOLDER_PATH"))
+    os.environ["DATABASE_PATH"] = os.path.join(
+        os.environ.get("DATA_FOLDER_PATH"), "project.db"
+    )
 
 
 def test_config(path):

src/opengeodeweb_viewer/object/object_methods.py

@@ -5,19 +5,32 @@
 import vtk
 
 # Local application imports
+from opengeodeweb_viewer.utils_functions import get_schemas_dict, validate_schema
 from opengeodeweb_viewer.vtk_protocol import VtkView
 
 
 class VtkObjectView(VtkView):
     def __init__(self):
         super().__init__()
 
-    def registerObject(self, id, reader, filter, mapper):
-        data_info = self.get_data_info(id)
-        file_path = self.get_data_file_path(id, data_info.viewable_file_name)
+    def registerObject(self, id):
+        data = self.get_data_by_id(id)
+        if not data:
+            raise Exception(
+                f"Données avec l'ID {id} non trouvées dans la base de données"
+            )
+
+        reader = vtk.vtkXMLGenericDataObjectReader()
+        mapper = vtk.vtkDataSetMapper()
+        mapper.SetInputConnection(reader.GetOutputPort())
         actor = vtk.vtkActor()
-        self.register_object(id, reader, filter, actor, mapper, {})
-        reader.SetFileName(file_path)
+
+        self.register_object(id, reader, {}, actor, mapper, {})
+
+        reader.SetFileName(
+            os.path.join(self.DATA_FOLDER_PATH, id, data["viewable_file_name"])
+        )
+
         actor.SetMapper(mapper)
         mapper.SetColorModeToMapScalars()
         mapper.SetResolveCoincidentTopologyLineOffsetParameters(1, -0.1)
@@ -58,7 +71,9 @@ def applyTextures(self, id, textures):
 
             new_texture = vtk.vtkTexture()
             image_reader = vtk.vtkXMLImageDataReader()
-            image_reader.SetFileName(self.get_data_file_path(id, texture_file_name))
+            image_reader.SetFileName(
+                os.path.join(self.DATA_FOLDER_PATH, id, texture_file_name)
+            )
 
             shader_texture_name = f"VTK_TEXTURE_UNIT_{index}"
             polydata_mapper.MapDataArrayToMultiTextureAttribute(

src/opengeodeweb_viewer/rpc/generic/generic_protocols.py

@@ -27,13 +27,11 @@ def register(self, params):
             params, self.generic_schemas_dict["register"], self.generic_prefix
         )
         viewer_object = params["viewer_object"]
-        data_id = params["data_id"]
-        data_info = self.get_data_info(data_id)
-        register_params = {"id": data_id, "file_name": data_info.viewable_file_name}
+        params.pop("viewer_object", None)
         if viewer_object == "mesh":
-            self.mesh_protocols.registerMesh(register_params)
+            self.mesh_protocols.registerMesh(params)
         elif viewer_object == "model":
-            self.model_protocols.registerModel(register_params)
+            self.model_protocols.registerModel(params)
 
     @exportRpc(generic_prefix + generic_schemas_dict["deregister"]["rpc"])
     def deregister(self, params):

src/opengeodeweb_viewer/rpc/generic/schemas/register.json

@@ -13,11 +13,16 @@
     "id": {
       "type": "string",
       "minLength": 1
+    },
+    "file_name": {
+      "type": "string",
+      "minLength": 1
     }
   },
   "required": [
     "viewer_object",
-    "id"
+    "id",
+    "file_name"
   ],
   "additionalProperties": false
 }

src/opengeodeweb_viewer/rpc/mesh/mesh_protocols.py

@@ -22,14 +22,10 @@ def __init__(self):
     @exportRpc(mesh_prefix + mesh_schemas_dict["register"]["rpc"])
     def registerMesh(self, params):
         validate_schema(params, self.mesh_schemas_dict["register"], self.mesh_prefix)
-        id, file_name = params["id"], params["file_name"]
+        id = params["id"]
         try:
-            reader = vtk.vtkXMLGenericDataObjectReader()
-            filter = {}
-            mapper = vtk.vtkDataSetMapper()
-            mapper.SetInputConnection(reader.GetOutputPort())
-            self.registerObject(id, file_name, reader, filter, mapper)
-
+            self.registerObject(id)
+            reader = self.get_object(id)["reader"]
             data_object = reader.GetOutput()
             data_set = vtk.vtkDataSet.SafeDownCast(data_object)
             cell_types = vtk.vtkCellTypes()
@@ -52,6 +48,7 @@ def registerMesh(self, params):
             self.get_data_base()[id]["max_dimension"] = max_dimension
         except Exception as e:
             print("error : ", str(e), flush=True)
+            raise
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["deregister"]["rpc"])
     def deregisterMesh(self, params):

src/opengeodeweb_viewer/rpc/model/model_protocols.py

@@ -23,7 +23,7 @@ def __init__(self):
     @exportRpc(model_prefix + model_schemas_dict["register"]["rpc"])
     def registerModel(self, params):
         validate_schema(params, self.model_schemas_dict["register"], self.model_prefix)
-        id = params["id"]
+        id, file_name = params["id"], params["file_name"]
         try:
             reader = vtk.vtkXMLMultiBlockDataReader()
             filter = vtk.vtkGeometryFilter()
@@ -32,7 +32,7 @@ def registerModel(self, params):
             mapper.SetInputConnection(filter.GetOutputPort())
             attributes = vtkCompositeDataDisplayAttributes()
             mapper.SetCompositeDataDisplayAttributes(attributes)
-            self.registerObject(id, reader, filter, mapper)
+            self.registerObject(id, file_name, reader, filter, mapper)
             self.get_object(id)["max_dimension"] = "default"
         except Exception as e:
             print("error : ", str(e), flush=True)

src/opengeodeweb_viewer/rpc/model/schemas/register.json

@@ -5,10 +5,15 @@
     "id": {
       "type": "string",
       "minLength": 1
+    },
+    "file_name": {
+      "type": "string",
+      "minLength": 1
     }
   },
   "required": [
-    "id"
+    "id",
+    "file_name"
   ],
   "additionalProperties": false
 }

src/opengeodeweb_viewer/rpc/viewer/viewer_protocols.py

@@ -112,6 +112,7 @@ def takeScreenshot(self, params):
         validate_schema(
             params, self.viewer_schemas_dict["take_screenshot"], self.viewer_prefix
         )
+
         filename, output_extension, include_background = (
             params["filename"],
             params["output_extension"],

src/opengeodeweb_viewer/vtk_protocol.py

@@ -1,56 +1,50 @@
 # Standard library imports
 import os
+import sqlite3
 
 # Third party imports
 import vtk
 from vtk.web import protocols as vtk_protocols
 
 # Local application imports
-from opengeodeweb_microservice.database.data import Data
-from opengeodeweb_microservice.database.connection import get_session
 
 
 class VtkView(vtk_protocols.vtkWebProtocol):
     def __init__(self):
         super().__init__()
         self.DATA_FOLDER_PATH = os.getenv("DATA_FOLDER_PATH")
+        # self.DATABASE_PATH = os.getenv("DATABASE_PATH")
         self.DataReader = vtk.vtkXMLPolyDataReader()
         self.ImageReader = vtk.vtkXMLImageDataReader()
 
-    def get_data_info(self, id: str) -> Data:
-        data_entry = Data.get(id)
-        if not data_entry:
-            raise ValueError(f"Data with id {id} not found")
-        return data_entry
-
-    def get_data_file_path(self, id: str, filename: str = "") -> str:
-        data_entry = self.get_data_info(id)
-        if filename:
-            return os.path.join(self.DATA_FOLDER_PATH, id, filename)
-        return os.path.join(self.DATA_FOLDER_PATH, id, data_entry.native_file_name)
-
-    def load_data(self, id: str):
-        data_entry = self.get_data_info(id)
-        file_path = self.get_data_file_path(id, data_entry.native_file_name)
-
-        # if not os.path.exists(file_path):
-        #     raise FileNotFoundError(f"File not found at {file_path}")
-
-        if file_path.endswith(".vtp"):
-            reader = vtk.vtkXMLPolyDataReader()
-        elif file_path.endswith(".vti"):
-            reader = vtk.vtkXMLImageDataReader()
-        elif file_path.endswith(".vtu"):
-            reader = vtk.vtkXMLUnstructuredGridReader()
-        else:
-            raise ValueError(f"Unsupported file extension for {file_path}")
-
-        reader.SetFileName(file_path)
-        return reader, data_entry.geode_object
-
     def get_data_base(self):
         return self.getSharedObject("db")
 
+    def get_db_connection(self):
+        conn = sqlite3.connect(self.DATA_FOLDER_PATH)
+        conn.row_factory = sqlite3.Row
+        return conn
+
+    def get_data_by_id(self, data_id):
+        conn = self.get_db_connection()
+        try:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM data WHERE id = ?", (data_id,))
+            data = cursor.fetchone()
+            return dict(data) if data else None
+        finally:
+            conn.close()
+
+    def get_all_data(self):
+        conn = self.get_db_connection()
+        try:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM data")
+            data = cursor.fetchall()
+            return [dict(row) for row in data]
+        finally:
+            conn.close()
+
     def get_renderer(self):
         return self.getSharedObject("renderer")
 

src/opengeodeweb_viewer/vtkw_server.py

@@ -57,11 +57,20 @@ def add_arguments(parser):
             default=os.environ.get("DATA_FOLDER_PATH"),
             help="Path to the folder where data is stored",
         )
+        # parser.add_argument(
+        #     "--database_path",
+        #     default=os.environ.get("DATABASE_PATH"),
+        #     help="Path to the SQLite database file",
+        # )
 
     @staticmethod
     def configure(args):
         # Standard args
         _Server.authKey = args.authKey
+        # if args.data_folder_path:
+        #     os.environ["DATA_FOLDER_PATH"] = args.data_folder_path
+        # if args.database_path:
+        #     os.environ["DATABASE_PATH"] = args.database_path
 
     def initialize(self):
         # Bring used components