@geode/opengeodeweb-front 9.12.2-rc.1 → 9.12.2-rc.2

package/internal_stores/model/surfaces.js

@@ -1,58 +1,92 @@
+// Third party imports
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
-const surfaces_schemas = viewer_schemas.opengeodeweb_viewer.model.surfaces
 
-export function useSurfacesStyle() {
-  /** State **/
+// Local constants
+const model_surfaces_schemas = viewer_schemas.opengeodeweb_viewer.model.surfaces
+
+export function useModelSurfacesStyle() {
   const dataStyleStore = useDataStyleStore()
   const dataBaseStore = useDataBaseStore()
 
-  /** Getters **/
-  function surfaceVisibility(id, surface_id) {
-    return dataStyleStore.styles[id].surfaces[surface_id].visibility
+  function modelSurfaceStyle(id, surface_id) {
+    if (!dataStyleStore.getStyle(id).surfaces[surface_id]) {
+      dataStyleStore.getStyle(id).surfaces[surface_id] = {}
+    }
+    return dataStyleStore.getStyle(id).surfaces[surface_id]
   }
 
-  /** Actions **/
-  function setSurfaceVisibility(id, surface_ids, visibility) {
+  function modelSurfaceVisibility(id, surface_id) {
+    return modelSurfaceStyle(id, surface_id).visibility
+  }
+  function saveModelSurfaceVisibility(id, surface_id, visibility) {
+    modelSurfaceStyle(id, surface_id).visibility = visibility
+  }
+  function setModelSurfacesVisibility(id, surface_ids, visibility) {
     const surface_flat_indexes = dataBaseStore.getFlatIndexes(id, surface_ids)
     return viewer_call(
       {
-        schema: surfaces_schemas.visibility,
+        schema: model_surfaces_schemas.visibility,
         params: { id, block_ids: surface_flat_indexes, visibility },
       },
       {
         response_function: () => {
           for (const surface_id of surface_ids) {
-            if (!dataStyleStore.styles[id].surfaces[surface_id])
-              dataStyleStore.styles[id].surfaces[surface_id] = {}
-            dataStyleStore.styles[id].surfaces[surface_id].visibility =
-              visibility
+            saveModelSurfaceVisibility(id, surface_id, visibility)
           }
-          console.log("setSurfaceVisibility", surface_ids, visibility)
+          console.log(
+            setModelSurfacesVisibility.name,
+            { id },
+            { surface_ids },
+            modelSurfaceVisibility(id, surface_ids[0]),
+          )
         },
       },
     )
   }
+  function modelSurfaceColor(id, surface_id) {
+    return modelSurfaceStyle(id, surface_id).color
+  }
+  function saveModelSurfaceColor(id, surface_id, color) {
+    modelSurfaceStyle(id, surface_id).color = color
+  }
 
-  function setSurfacesDefaultStyle(id) {
-    const surface_ids = dataBaseStore.getSurfacesUuids(id)
-    setSurfaceVisibility(
-      id,
-      surface_ids,
-      dataStyleStore.styles[id].surfaces.visibility,
+  function setModelSurfacesColor(id, surface_ids, color) {
+    const surface_flat_indexes = dataBaseStore.getFlatIndexes(id, surface_ids)
+    return viewer_call(
+      {
+        schema: model_surfaces_schemas.color,
+        params: { id, block_ids: surface_flat_indexes, color },
+      },
+      {
+        response_function: () => {
+          for (const surface_id of surface_ids) {
+            saveModelSurfaceColor(id, surface_id, color)
+          }
+          console.log(
+            setModelSurfacesColor.name,
+            { id },
+            { surface_ids },
+            JSON.stringify(modelSurfaceColor(id, surface_ids[0])),
+          )
+        },
+      },
     )
   }
 
-  function applySurfacesStyle(id) {
-    const surfaces = dataStyleStore.styles[id].surfaces
-    for (const [surface_id, style] of Object.entries(surfaces)) {
-      setSurfaceVisibility(id, [surface_id], style.visibility)
-    }
+  function applyModelSurfacesStyle(id) {
+    const style = dataStyleStore.getStyle(id).surfaces
+    const surface_ids = dataBaseStore.getSurfacesUuids(id)
+    return Promise.all([
+      setModelSurfacesVisibility(id, surface_ids, style.visibility),
+      setModelSurfacesColor(id, surface_ids, style.color),
+    ])
   }
 
   return {
-    surfaceVisibility,
-    setSurfacesDefaultStyle,
-    setSurfaceVisibility,
-    applySurfacesStyle,
+    modelSurfaceVisibility,
+    modelSurfaceColor,
+    setModelSurfacesVisibility,
+    setModelSurfacesColor,
+    applyModelSurfacesStyle,
   }
 }

package/package.json

@@ -40,7 +40,7 @@
   },
   "description": "OpenSource Vue/Nuxt/Pinia/Vuetify framework for web applications",
   "type": "module",
-  "version": "9.12.2-rc.1",
+  "version": "9.12.2-rc.2",
   "main": "./nuxt.config.js",
   "dependencies": {
     "@geode/opengeodeweb-back": "next",

package/stores/data_base.js

@@ -1,10 +1,12 @@
+// Third party imports
 import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
 
-export const useDataBaseStore = defineStore("dataBase", () => {
-  const treeview_store = useTreeviewStore()
-  const hybridViewerStore = useHybridViewerStore()
+// Local constants
+const back_model_schemas = back_schemas.opengeodeweb_back.models
+const viewer_generic_schemas = viewer_schemas.opengeodeweb_viewer.generic
 
+export const useDataBaseStore = defineStore("dataBase", () => {
   const db = reactive({})
 
   function itemMetaDatas(id) {
@@ -41,7 +43,7 @@ export const useDataBaseStore = defineStore("dataBase", () => {
 
   async function registerObject(id) {
     return viewer_call({
-      schema: viewer_schemas.opengeodeweb_viewer.generic.register,
+      schema: viewer_generic_schemas.register,
       params: { id },
     })
   }
@@ -58,50 +60,34 @@ export const useDataBaseStore = defineStore("dataBase", () => {
     },
   ) {
     db[id] = value
-
-    if (value.object_type === "model") {
-      await fetchMeshComponents(id)
-      await fetchUuidToFlatIndexDict(id)
-    }
-    treeview_store.addItem(
-      value.geode_object,
-      value.displayed_name,
-      id,
-      value.object_type,
-    )
-
-    hybridViewerStore.addItem(id, value.vtk_js)
   }
 
   async function fetchMeshComponents(id) {
-    await api_fetch(
+    return api_fetch(
       {
-        schema: back_schemas.opengeodeweb_back.models.mesh_components,
+        schema: back_model_schemas.mesh_components,
         params: {
           id,
         },
       },
       {
         response_function: async (response) => {
-          if (response._data?.uuid_dict) {
-            db[id].mesh_components = response._data.uuid_dict
-          }
+          db[id].mesh_components = response._data.uuid_dict
         },
       },
     )
   }
 
   async function fetchUuidToFlatIndexDict(id) {
-    await api_fetch(
+    console.log("fetchUuidToFlatIndexDict", id)
+    return api_fetch(
       {
-        schema: back_schemas.opengeodeweb_back.models.vtm_component_indices,
+        schema: back_model_schemas.vtm_component_indices,
         params: { id },
       },
       {
         response_function: async (response) => {
-          if (response._data?.uuid_to_flat_index) {
-            db[id]["uuid_to_flat_index"] = response._data.uuid_to_flat_index
-          }
+          db[id]["uuid_to_flat_index"] = response._data.uuid_to_flat_index
         },
       },
     )
@@ -127,11 +113,11 @@ export const useDataBaseStore = defineStore("dataBase", () => {
 
   function getFlatIndexes(id, mesh_component_ids) {
     const { uuid_to_flat_index } = itemMetaDatas(id)
-
-    const flat_indexes = mesh_component_ids.map(
-      (mesh_component_id) => uuid_to_flat_index[mesh_component_id] || null,
-    )
-    return flat_indexes.filter((index) => index !== null)
+    const flat_indexes = []
+    for (const mesh_component_id of mesh_component_ids) {
+      flat_indexes.push(uuid_to_flat_index[mesh_component_id])
+    }
+    return flat_indexes
   }
 
   return {

package/stores/data_style.js

@@ -3,58 +3,46 @@ import useMeshStyle from "../internal_stores/mesh/index.js"
 import useModelStyle from "../internal_stores/model/index.js"
 
 export const useDataStyleStore = defineStore("dataStyle", () => {
-  /** States **/
   const dataStyleState = useDataStyleState()
   const meshStyleStore = useMeshStyle()
   const modelStyleStore = useModelStyle()
   const dataBaseStore = useDataBaseStore()
 
-  /** Actions **/
-  function addDataStyle(id, geode_object, object_type) {
+  function addDataStyle(id, geode_object) {
     dataStyleState.styles[id] = getDefaultStyle(geode_object)
-    const promise_array = []
-    if (object_type === "mesh") {
-      promise_array.push(meshStyleStore.applyMeshDefaultStyle(id))
-    } else if (object_type === "model") {
-      promise_array.push(modelStyleStore.setMeshComponentsDefaultStyle(id))
-      promise_array.push(modelStyleStore.applyModelDefaultStyle(id))
-    } else {
-      throw new Error("Unknown object type")
-    }
-    return Promise.all(promise_array)
   }
 
   function setVisibility(id, visibility) {
+    console.log(
+      "dataBaseStore.itemMetaDatas(id)",
+      dataBaseStore.itemMetaDatas(id),
+    )
     const object_type = dataBaseStore.itemMetaDatas(id).object_type
     if (object_type === "mesh") {
       return Promise.all([meshStyleStore.setMeshVisibility(id, visibility)])
     } else if (object_type === "model") {
       return Promise.all([modelStyleStore.setModelVisibility(id, visibility)])
     }
+    throw new Error("Unknown object_type")
   }
 
-  function setModelEdgesVisibility(id, visibility) {
-    modelStyleStore.setModelMeshComponentVisibility(
-      id,
-      "Edge",
-      null,
-      visibility,
-    )
-  }
-
-  function modelEdgesVisibility(id) {
-    return modelStyleStore.modelMeshComponentVisibility(id, "Edge", null)
+  function applyDefaultStyle(id) {
+    const { object_type } = dataBaseStore.itemMetaDatas(id)
+    if (object_type === "mesh") {
+      return meshStyleStore.applyMeshStyle(id)
+    } else if (object_type === "model") {
+      return modelStyleStore.applyModelStyle(id)
+    } else {
+      throw new Error("Unknown object_type: " + object_type)
+    }
   }
 
   return {
     ...dataStyleState,
-    addDataStyle,
-    setVisibility,
-    setModelEdgesVisibility,
-    modelEdgesVisibility,
     ...meshStyleStore,
     ...modelStyleStore,
+    addDataStyle,
+    applyDefaultStyle,
+    setVisibility,
   }
 })
-
-export default useDataStyleStore

package/stores/hybrid_viewer.js

@@ -8,7 +8,8 @@ import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schem
 import Status from "@ogw_f/utils/status.js"
 
 export const useHybridViewerStore = defineStore("hybridViewer", () => {
-  const viewer_store = useViewerStore()
+  const viewerStore = useViewerStore()
+  const dataBaseStore = useDataBaseStore()
   const db = reactive({})
   const status = ref(Status.NOT_CREATED)
   const camera_options = reactive({})
@@ -32,8 +33,8 @@ export const useHybridViewerStore = defineStore("hybridViewer", () => {
     imageStyle.transition = "opacity 0.1s ease-in"
     imageStyle.zIndex = 1
 
-    await viewer_store.ws_connect()
-    viewStream = viewer_store.client.getImageStream().createViewStream("-1")
+    await viewerStore.ws_connect()
+    viewStream = viewerStore.client.getImageStream().createViewStream("-1")
     viewStream.onImageReady((e) => {
       if (is_moving.value) return
       const webGLRenderWindow =
@@ -46,11 +47,16 @@ export const useHybridViewerStore = defineStore("hybridViewer", () => {
     status.value = Status.CREATED
   }
 
-  async function addItem(id, value) {
+  async function addItem(id) {
+    if (!genericRenderWindow.value) {
+      return
+    }
+    const value = dataBaseStore.db[id]
+    console.log("hybridViewerStore.addItem", { value })
     const reader = vtkXMLPolyDataReader.newInstance()
     const textEncoder = new TextEncoder()
     await reader.parseAsArrayBuffer(
-      textEncoder.encode(value.binary_light_viewable),
+      textEncoder.encode(value.vtk_js.binary_light_viewable),
     )
     const polydata = reader.getOutputData(0)
     const mapper = vtkMapper.newInstance()
@@ -166,7 +172,7 @@ export const useHybridViewerStore = defineStore("hybridViewer", () => {
 
   async function resize(width, height) {
     if (
-      viewer_store.status !== Status.CONNECTED ||
+      viewerStore.status !== Status.CONNECTED ||
       status.value !== Status.CREATED
     ) {
       return

package/stores/treeview.js

@@ -1,7 +1,7 @@
 export const useTreeviewStore = defineStore("treeview", () => {
   const dataStyleStore = useDataStyleStore()
+  const dataBaseStore = useDataBaseStore()
 
-  /** State **/
   const items = ref([])
   const selection = ref([])
   const components_selection = ref([])
@@ -11,9 +11,8 @@ export const useTreeviewStore = defineStore("treeview", () => {
   const isTreeCollection = ref(false)
   const selectedTree = ref(null)
 
-  /** Functions **/
+  // /** Functions **/
   function addItem(geodeObject, displayed_name, id, object_type) {
-    dataStyleStore.addDataStyle(id, geodeObject, object_type)
     const child = { title: displayed_name, id, object_type }
 
     for (let i = 0; i < items.value.length; i++) {

package/tests/integration/microservices/viewer/requirements.txt

@@ -5,4 +5,4 @@
 #    pip-compile --output-file=tests/integration/microservices/viewer/requirements.txt tests/integration/microservices/viewer/requirements.in
 #
 
-opengeodeweb-viewer==1.*,>=1.11.7
+opengeodeweb-viewer==1.*,>=1.11.8rc1

package/tests/integration/setup.js

@@ -7,16 +7,13 @@ import { WebSocket } from "ws"
 import { setActivePinia } from "pinia"
 import { createTestingPinia } from "@pinia/testing"
 import { afterAll, beforeAll, expect, vi } from "vitest"
-import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
 
 // Local imports
-import { useDataStyleStore } from "~/stores/data_style"
-import { useDataBaseStore } from "~/stores/data_base"
 import { useGeodeStore } from "~/stores/geode"
 import { useViewerStore } from "~/stores/viewer"
 import { useInfraStore } from "~/stores/infra"
-import { api_fetch } from "~/composables/api_fetch"
 import { appMode } from "~/utils/app_mode"
+import { importFile } from "~/utils/file_import_workflow"
 import Status from "~/utils/status"
 import {
   executable_name,
@@ -24,23 +21,24 @@ import {
   run_back,
   run_viewer,
 } from "~/utils/local"
-import { getCurrentFolders, cleanupCreatedFolders } from "./utils.js"
 
-async function setupIntegrationTests(file_name, geode_object, object_type) {
+// Local constants
+const data_folder = path.join("tests", "integration", "data")
+
+async function setupIntegrationTests(file_name, geode_object) {
   const pinia = createTestingPinia({
     stubActions: false,
     createSpy: vi.fn,
   })
   setActivePinia(pinia)
-  const dataStyleStore = useDataStyleStore()
-  const dataBaseStore = useDataBaseStore()
   const geodeStore = useGeodeStore()
-  const viewerStore = useViewerStore()
+  const hybridViewerStore = useHybridViewerStore()
   const infraStore = useInfraStore()
+  const viewerStore = useViewerStore()
   infraStore.app_mode = appMode.BROWSER
 
   const microservices_path = path.join("tests", "integration", "microservices")
-  const project_folder_path = path.join(__dirname, "data", uuidv4())
+  const project_folder_path = path.join(data_folder, uuidv4())
   const upload_folder_path = path.join(__dirname, "data", "uploads")
   const back_path = executable_path(path.join(microservices_path, "back"))
   const back_name = executable_name("opengeodeweb-back")
@@ -57,23 +55,19 @@ async function setupIntegrationTests(file_name, geode_object, object_type) {
   ])
   console.log("back_port", back_port)
   console.log("viewer_port", viewer_port)
+
   geodeStore.default_local_port = back_port
   viewerStore.default_local_port = viewer_port
+  console.log("after ports")
   await viewerStore.ws_connect()
+  // await hybridViewerStore.initHybridViewer()
+  console.log("after hybridViewerStore.initHybridViewer")
 
-  const response = await api_fetch({
-    schema: back_schemas.opengeodeweb_back.save_viewable_file,
-    params: {
-      input_geode_object: geode_object,
-      filename: file_name,
-    },
-  })
-
-  const id = response.data._value.id
-  await dataBaseStore.registerObject(id)
-  await dataStyleStore.addDataStyle(id, geode_object, object_type)
+  // await viewerStore.ws_connect()
+  const id = await importFile(file_name, geode_object)
   expect(viewerStore.status).toBe(Status.CONNECTED)
-  return { id, back_port, viewer_port }
+  console.log("end of setupIntegrationTests")
+  return { id, back_port, viewer_port, project_folder_path }
 }
 
 const mockLockRequest = vi.fn().mockImplementation(async (name, callback) => {
@@ -87,21 +81,12 @@ vi.stubGlobal("navigator", {
   },
 })
 
-let foldersBeforeTests = new Set()
-
-const data_folder = path.join("tests", "integration", "data")
 beforeAll(() => {
   global.WebSocket = WebSocket
-  foldersBeforeTests = getCurrentFolders(data_folder)
-  console.log("foldersBeforeTests", foldersBeforeTests)
 })
 
 afterAll(() => {
-  console.log("afterAll")
   delete global.WebSocket
-  setTimeout(() => {
-    cleanupCreatedFolders(data_folder, foldersBeforeTests)
-  }, 2000)
 })
 
 export { setupIntegrationTests }

package/tests/integration/stores/data_style/mesh/edges.nuxt.test.js

@@ -1,5 +1,3 @@
-// Node.js imports
-
 // Third party imports
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
@@ -9,25 +7,30 @@ import Status from "~/utils/status"
 import * as composables from "~/composables/viewer_call"
 import { useDataStyleStore } from "~/stores/data_style"
 import { useViewerStore } from "~/stores/viewer"
+import { delete_folder_recursive, kill_back, kill_viewer } from "~/utils/local"
 import { setupIntegrationTests } from "../../../setup.js"
 
 // Local constants
 const mesh_edges_schemas = viewer_schemas.opengeodeweb_viewer.mesh.edges
-let id, back_port, viewer_port
 const file_name = "test.og_edc2d"
 const geode_object = "EdgedCurve2D"
-const object_type = "mesh"
+
+let id, back_port, viewer_port, project_folder_path
 
 beforeEach(async () => {
-  ;({ id, back_port, viewer_port } = await setupIntegrationTests(
-    file_name,
-    geode_object,
-    object_type,
-  ))
-}, 20000)
+  ;({ id, back_port, viewer_port, project_folder_path } =
+    await setupIntegrationTests(file_name, geode_object))
+}, 25000)
 
 afterEach(async () => {
+  console.log(
+    "afterEach mesh edges kill",
+    back_port,
+    viewer_port,
+    project_folder_path,
+  )
   await Promise.all([kill_back(back_port), kill_viewer(viewer_port)])
+  delete_folder_recursive(project_folder_path)
 })
 
 describe("Mesh edges", () => {
@@ -35,8 +38,19 @@ describe("Mesh edges", () => {
     test("Visibility true", async () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
-      await dataStyleStore.setMeshEdgesVisibility(id, true)
-      expect(dataStyleStore.meshEdgesVisibility(id)).toBe(true)
+      const visibility = true
+      const spy = vi.spyOn(composables, "viewer_call")
+      await dataStyleStore.setMeshEdgesVisibility(id, visibility)
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: mesh_edges_schemas.visibility,
+          params: { id, visibility },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      )
+      expect(dataStyleStore.meshEdgesVisibility(id)).toBe(visibility)
       expect(viewerStore.status).toBe(Status.CONNECTED)
     })
   })
@@ -55,7 +69,7 @@ describe("Mesh edges", () => {
     })
   })
   describe("Edges color", () => {
-    test("test red", async () => {
+    test("Color red", async () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
       const color = { r: 255, g: 0, b: 0 }

package/tests/integration/stores/data_style/mesh/index.nuxt.test.js

@@ -0,0 +1,66 @@
+// Third party imports
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
+
+// Local imports
+import Status from "~/utils/status"
+import * as composables from "~/composables/viewer_call"
+import { useDataStyleStore } from "~/stores/data_style"
+import { useViewerStore } from "~/stores/viewer"
+import { delete_folder_recursive, kill_back, kill_viewer } from "~/utils/local"
+import { setupIntegrationTests } from "../../../setup.js"
+
+// Local constants
+const mesh_schemas = viewer_schemas.opengeodeweb_viewer.mesh
+const file_name = "test.og_rgd3d"
+const geode_object = "RegularGrid3D"
+
+let id, back_port, viewer_port, project_folder_path
+
+beforeEach(async () => {
+  ;({ id, back_port, viewer_port, project_folder_path } =
+    await setupIntegrationTests(file_name, geode_object))
+}, 20000)
+
+afterEach(async () => {
+  console.log(
+    "afterEach mesh index kill",
+    back_port,
+    viewer_port,
+    project_folder_path,
+  )
+  await Promise.all([kill_back(back_port), kill_viewer(viewer_port)])
+  delete_folder_recursive(project_folder_path)
+})
+
+describe("Mesh", () => {
+  describe("Mesh visibility", () => {
+    test("Visibility true", async () => {
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      const visibility = true
+      const spy = vi.spyOn(composables, "viewer_call")
+      await dataStyleStore.setMeshVisibility(id, visibility)
+      expect(spy).toHaveBeenCalledWith(
+        {
+          schema: mesh_schemas.visibility,
+          params: { id, visibility },
+        },
+        {
+          response_function: expect.any(Function),
+        },
+      )
+      expect(dataStyleStore.meshVisibility(id)).toBe(visibility)
+      expect(viewerStore.status).toBe(Status.CONNECTED)
+    })
+  })
+
+  describe("Apply mesh default style", () => {
+    test("test", async () => {
+      const dataStyleStore = useDataStyleStore()
+      const viewerStore = useViewerStore()
+      await dataStyleStore.applyMeshStyle(id)
+      expect(viewerStore.status).toBe(Status.CONNECTED)
+    })
+  })
+})