database integration. using id from database of OGW-Microservice's database

rm filename from register json schema
new functions for data_file_path get_data_info, get_data_file_path, load_data

Author: MaxNumerique

src/opengeodeweb_viewer/config.py

@@ -48,7 +48,7 @@ def test_config(path):
         *test_ids,
         uploads_directory,
         structure_directory,
-    ]:  # create directories for tests
+    ]:
         os.makedirs(
             (
                 os.path.join(tmp_data_root, directory)

src/opengeodeweb_viewer/object/object_methods.py

@@ -5,18 +5,19 @@
 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, file_name, reader, filter, mapper):
+    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)
         actor = vtk.vtkActor()
         self.register_object(id, reader, filter, actor, mapper, {})
-        reader.SetFileName(os.path.join(self.DATA_FOLDER_PATH, id, file_name))
+        reader.SetFileName(file_path)
         actor.SetMapper(mapper)
         mapper.SetColorModeToMapScalars()
         mapper.SetResolveCoincidentTopologyLineOffsetParameters(1, -0.1)
@@ -57,9 +58,7 @@ def applyTextures(self, id, textures):
 
             new_texture = vtk.vtkTexture()
             image_reader = vtk.vtkXMLImageDataReader()
-            image_reader.SetFileName(
-                os.path.join(self.DATA_FOLDER_PATH, id, texture_file_name)
-            )
+            image_reader.SetFileName(self.get_data_file_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,11 +27,13 @@ def register(self, params):
             params, self.generic_schemas_dict["register"], self.generic_prefix
         )
         viewer_object = params["viewer_object"]
-        params.pop("viewer_object", None)
+        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}
         if viewer_object == "mesh":
-            self.mesh_protocols.registerMesh(params)
+            self.mesh_protocols.registerMesh(register_params)
         elif viewer_object == "model":
-            self.model_protocols.registerModel(params)
+            self.model_protocols.registerModel(register_params)
 
     @exportRpc(generic_prefix + generic_schemas_dict["deregister"]["rpc"])
     def deregister(self, params):

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

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

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

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

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, file_name = params["id"], params["file_name"]
+        id = params["id"]
         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, file_name, reader, filter, mapper)
+            self.registerObject(id, 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,15 +5,10 @@
     "id": {
       "type": "string",
       "minLength": 1
-    },
-    "file_name": {
-      "type": "string",
-      "minLength": 1
     }
   },
   "required": [
-    "id",
-    "file_name"
+    "id"
   ],
   "additionalProperties": false
 }

src/opengeodeweb_viewer/rpc/viewer/viewer_protocols.py

@@ -112,7 +112,6 @@ 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

@@ -6,15 +6,50 @@
 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")
+        if not self.DATA_FOLDER_PATH:
+            raise ValueError("DATA_FOLDER_PATH environment variable not set")
         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")