adding tests. Need to correct config file to match uuids from test_data_helpers.

Is test_data_helpers needed ?

Author: MaxNumerique

src/opengeodeweb_viewer/config.py

@@ -43,7 +43,11 @@ def test_config(path):
     if not os.path.isdir(src_data):
         raise FileNotFoundError(f"Test data folder not found: {src_data}")
 
-    test_ids = ["123456789", "12345678"]
+    test_ids = [
+        "123456789",
+        "12345678",
+    ]  # needs to match IDs in test_data_helpers.py
+    print(f"Creating test data folders in {tmp_data_root}", flush=True)
     valid_exts = {".vtp", ".vti", ".vtu", ".vtm"}
 
     project_uuid = "test-project-uuid"

src/opengeodeweb_viewer/database/connection.py

@@ -0,0 +1,44 @@
+import os
+from typing import Optional
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, scoped_session
+from sqlalchemy.engine import Engine
+
+from opengeodeweb_microservice.database.data import Data
+from opengeodeweb_microservice.database.base import Base
+
+
+class DatabaseManager:
+    def __init__(self):
+        self._engine: Optional[Engine] = None
+        self._session_factory = None
+        self._scoped_session = None
+
+    def initialize(self, database_path: str):
+        if not database_path:
+            print("Warning: No database path provided")
+            return False
+
+        try:
+            self._engine = create_engine(f"sqlite:///{database_path}", echo=False)
+            self._session_factory = sessionmaker(bind=self._engine)
+            self._scoped_session = scoped_session(self._session_factory)
+            print(f"Database initialized at: {database_path}")
+            return True
+
+        except Exception as e:
+            print(f"Error initializing database: {e}")
+            return False
+
+    def get_session(self):
+        return self._scoped_session() if self._scoped_session else None
+
+    def close(self):
+        if self._scoped_session:
+            self._scoped_session.remove()
+        if self._engine:
+            self._engine.dispose()
+
+
+# Global database manager instance
+db_manager = DatabaseManager()

src/opengeodeweb_viewer/object/object_methods.py

@@ -13,22 +13,20 @@ class VtkObjectView(VtkView):
     def __init__(self):
         super().__init__()
 
-    def registerObject(self, id):
-        data = self.get_data_by_id(id)
-        if not data:
-            raise Exception(f"Data {id} not found in {self.DATA_FOLDER_PATH}")
+    def registerObject(self, data_id):
+        data = self.get_data(data_id)
 
         reader = vtk.vtkXMLGenericDataObjectReader()
         mapper = vtk.vtkDataSetMapper()
         mapper.SetInputConnection(reader.GetOutputPort())
         actor = vtk.vtkActor()
 
-        self.register_object(id, reader, {}, actor, mapper, {})
-
-        reader.SetFileName(
-            os.path.join(self.DATA_FOLDER_PATH, id, data["viewable_file_name"])
-        )
+        self.register_object(data_id, reader, {}, actor, mapper, {})
 
+        file_path = self.get_data_file_path(data_id)
+        if not os.path.exists(file_path):
+            raise Exception(f"Viewable file not found: {file_path}")
+        reader.SetFileName(file_path)
         actor.SetMapper(mapper)
         mapper.SetColorModeToMapScalars()
         mapper.SetResolveCoincidentTopologyLineOffsetParameters(1, -0.1)
@@ -42,19 +40,19 @@ def registerObject(self, id):
         renderWindow.Render()
         self.render()
 
-    def deregisterObject(self, id):
-        actor = self.get_object(id)["actor"]
+    def deregisterObject(self, data_id):
+        actor = self.get_object(data_id)["actor"]
         renderWindow = self.getView("-1")
         renderer = renderWindow.GetRenderers().GetFirstRenderer()
         renderer.RemoveActor(actor)
-        self.deregister_object(id)
+        self.deregister_object(data_id)
         self.render()
 
-    def applyTextures(self, id, textures):
+    def applyTextures(self, data_id, textures):
         textures_array = []
         images_reader_array = []
 
-        data = self.get_object(id)
+        data = self.get_object(data_id)
         mapper = data["mapper"]
         actor = data["actor"]
         reader = data["reader"]
@@ -69,9 +67,10 @@ 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)
+            texture_path = os.path.join(
+                self.DATA_FOLDER_PATH, data_id, texture_file_name
             )
+            image_reader.SetFileName(texture_path)
 
             shader_texture_name = f"VTK_TEXTURE_UNIT_{index}"
             polydata_mapper.MapDataArrayToMultiTextureAttribute(
@@ -99,84 +98,84 @@ def applyTextures(self, id, textures):
 
         self.render()
 
-    def SetVisibility(self, id, visibility):
-        actor = self.get_object(id)["actor"]
+    def SetVisibility(self, data_id, visibility):
+        actor = self.get_object(data_id)["actor"]
         actor.SetVisibility(visibility)
         self.render()
 
-    def SetOpacity(self, id, opacity):
-        actor = self.get_object(id)["actor"]
+    def SetOpacity(self, data_id, opacity):
+        actor = self.get_object(data_id)["actor"]
         actor.GetProperty().SetOpacity(opacity)
         self.render()
 
-    def SetColor(self, id, red, green, blue):
-        mapper = self.get_object(id)["mapper"]
+    def SetColor(self, data_id, red, green, blue):
+        mapper = self.get_object(data_id)["mapper"]
         mapper.ScalarVisibilityOff()
-        actor = self.get_object(id)["actor"]
+        actor = self.get_object(data_id)["actor"]
         actor.GetProperty().SetColor([red / 255, green / 255, blue / 255])
         self.render()
 
-    def SetEdgesVisibility(self, id, visibility):
-        actor = self.get_object(id)["actor"]
-        max_dimension = self.get_object(id)["max_dimension"]
+    def SetEdgesVisibility(self, data_id, visibility):
+        actor = self.get_object(data_id)["actor"]
+        max_dimension = self.get_object(data_id)["max_dimension"]
         if max_dimension == "edges":
-            self.SetVisibility(id, visibility)
+            self.SetVisibility(data_id, visibility)
         else:
             actor.GetProperty().SetEdgeVisibility(visibility)
         self.render()
 
-    def SetEdgesWidth(self, id, width):
-        actor = self.get_object(id)["actor"]
+    def SetEdgesWidth(self, data_id, width):
+        actor = self.get_object(data_id)["actor"]
         actor.GetProperty().SetEdgeWidth(width)
         self.render()
 
-    def SetEdgesColor(self, id, red, green, blue):
-        actor = self.get_object(id)["actor"]
-        max_dimension = self.get_object(id)["max_dimension"]
+    def SetEdgesColor(self, data_id, red, green, blue):
+        actor = self.get_object(data_id)["actor"]
+        max_dimension = self.get_object(data_id)["max_dimension"]
         if max_dimension == "edges":
-            self.SetColor(id, red, green, blue)
+            self.SetColor(data_id, red, green, blue)
         else:
             actor.GetProperty().SetEdgeColor([red / 255, green / 255, blue / 255])
         self.render()
 
-    def SetPointsVisibility(self, id, visibility):
-        actor = self.get_object(id)["actor"]
-        max_dimension = self.get_object(id)["max_dimension"]
+    def SetPointsVisibility(self, data_id, visibility):
+        actor = self.get_object(data_id)["actor"]
+        max_dimension = self.get_object(data_id)["max_dimension"]
         if max_dimension == "points":
-            self.SetVisibility(id, visibility)
+            self.SetVisibility(data_id, visibility)
         else:
             actor.GetProperty().SetVertexVisibility(visibility)
             actor.GetProperty().SetEdgeVisibility(visibility)
         self.render()
 
-    def SetPointsSize(self, id, size):
-        actor = self.get_object(id)["actor"]
+    def SetPointsSize(self, data_id, size):
+        actor = self.get_object(data_id)["actor"]
         actor.GetProperty().SetPointSize(size)
         self.render()
 
-    def SetPointsColor(self, id, red, green, blue):
-        actor = self.get_object(id)["actor"]
-        max_dimension = self.get_object(id)["max_dimension"]
+    def SetPointsColor(self, data_id, red, green, blue):
+        actor = self.get_object(data_id)["actor"]
+        max_dimension = self.get_object(data_id)["max_dimension"]
         if max_dimension == "points":
-            self.SetColor(id, red, green, blue)
+            self.SetColor(data_id, red, green, blue)
         else:
             actor.GetProperty().SetVertexColor([red / 255, green / 255, blue / 255])
         self.render()
 
-    def SetBlocksVisibility(self, id, block_ids, visibility):
-        mapper = self.get_object(id)["mapper"]
+    def SetBlocksVisibility(self, data_id, block_ids, visibility):
+        mapper = self.get_object(data_id)["mapper"]
         for block_id in block_ids:
             mapper.SetBlockVisibility(block_id, visibility)
         self.render()
 
-    def SetBlocksColor(self, id, block_ids, red, green, blue):
-        mapper = self.get_object(id)["mapper"]
+    def SetBlocksColor(self, data_id, block_ids, red, green, blue):
+        mapper = self.get_object(data_id)["mapper"]
         for block_id in block_ids:
             mapper.SetBlockColor(block_id, [red / 255, green / 255, blue / 255])
         self.render()
 
-    def clearColors(self, id):
-        db = self.get_object(id)
+    def clearColors(self, data_id):
+        db = self.get_object(data_id)
         mapper = db["mapper"]
         reader = db["reader"]
         reader.GetOutput().GetPointData().SetActiveScalars("")

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/mesh_protocols.py

@@ -22,10 +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 = params["id"]
+        data_id = params["id"]
         try:
-            self.registerObject(id)
-            reader = self.get_object(id)["reader"]
+            self.registerObject(data_id)
+            reader = self.get_object(data_id)["reader"]
             data_object = reader.GetOutput()
             data_set = vtk.vtkDataSet.SafeDownCast(data_object)
             cell_types = vtk.vtkCellTypes()
@@ -45,63 +45,63 @@ def registerMesh(self, params):
                 max_dimension = "polygons"
             elif max_id >= 7:
                 max_dimension = "polyhedra"
-            self.get_data_base()[id]["max_dimension"] = max_dimension
+            self.get_data_base()[data_id]["max_dimension"] = max_dimension
         except Exception as e:
-            print("error : ", str(e), flush=True)
+            print(f"Error registering mesh {data_id}: {str(e)}", flush=True)
             raise
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["deregister"]["rpc"])
     def deregisterMesh(self, params):
         validate_schema(params, self.mesh_schemas_dict["deregister"], self.mesh_prefix)
-        id = params["id"]
-        self.deregisterObject(id)
+        data_id = params["id"]
+        self.deregisterObject(data_id)
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["visibility"]["rpc"])
     def SetMeshVisibility(self, params):
         validate_schema(params, self.mesh_schemas_dict["visibility"], self.mesh_prefix)
-        id, visibility = params["id"], params["visibility"]
-        self.SetVisibility(id, visibility)
+        data_id, visibility = params["id"], params["visibility"]
+        self.SetVisibility(data_id, visibility)
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["opacity"]["rpc"])
     def setMeshOpacity(self, params):
         validate_schema(params, self.mesh_schemas_dict["opacity"], self.mesh_prefix)
-        id, opacity = params["id"], params["opacity"]
-        self.SetOpacity(id, opacity)
+        data_id, opacity = params["id"], params["opacity"]
+        self.SetOpacity(data_id, opacity)
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["color"]["rpc"])
     def setMeshColor(self, params):
         validate_schema(params, self.mesh_schemas_dict["color"], self.mesh_prefix)
-        id, red, green, blue = (
+        data_id, red, green, blue = (
             params["id"],
             params["color"]["r"],
             params["color"]["g"],
             params["color"]["b"],
         )
-        self.SetColor(id, red, green, blue)
+        self.SetColor(data_id, red, green, blue)
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["apply_textures"]["rpc"])
     def meshApplyTextures(self, params):
         validate_schema(
             params, self.mesh_schemas_dict["apply_textures"], self.mesh_prefix
         )
-        id, textures = params["id"], params["textures"]
-        self.applyTextures(id, textures)
+        data_id, textures = params["id"], params["textures"]
+        self.applyTextures(data_id, textures)
 
-    def displayAttributeOnVertices(self, id, name):
-        reader = self.get_object(id)["reader"]
+    def displayAttributeOnVertices(self, data_id, name):
+        reader = self.get_object(data_id)["reader"]
         points = reader.GetOutput().GetPointData()
         points.SetActiveScalars(name)
-        mapper = self.get_object(id)["mapper"]
+        mapper = self.get_object(data_id)["mapper"]
         mapper.ScalarVisibilityOn()
         mapper.SetScalarModeToUsePointData()
         mapper.SetScalarRange(points.GetScalars().GetRange())
         self.render()
 
-    def displayAttributeOnCells(self, id, name):
-        reader = self.get_object(id)["reader"]
+    def displayAttributeOnCells(self, data_id, name):
+        reader = self.get_object(data_id)["reader"]
         cells = reader.GetOutput().GetCellData()
         cells.SetActiveScalars(name)
-        mapper = self.get_object(id)["mapper"]
+        mapper = self.get_object(data_id)["mapper"]
         mapper.ScalarVisibilityOn()
         mapper.SetScalarModeToUseCellData()
         mapper.SetScalarRange(cells.GetScalars().GetRange())