@geode/opengeodeweb-front 10.5.0 → 10.5.1

package/app/stores/data.js

@@ -1,15 +1,12 @@
 // Third party imports
-import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
-import { database } from "@ogw_internal/database/database.js"
 import { liveQuery } from "dexie"
 import { useObservable } from "@vueuse/rxjs"
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
 
 // Local imports
-import { useGeodeStore } from "@ogw_front/stores/geode"
+import { database } from "@ogw_internal/database/database.js"
 import { useViewerStore } from "@ogw_front/stores/viewer"
 
-const back_model_schemas = back_schemas.opengeodeweb_back.models
 const viewer_generic_schemas = viewer_schemas.opengeodeweb_viewer.generic
 
 export const useDataStore = defineStore("data", () => {
@@ -33,8 +30,10 @@ export const useDataStore = defineStore("data", () => {
     )
   }
 
-  async function formatedMeshComponents(id) {
-    const items = await database.model_components.where({ id }).toArray()
+  async function formatedMeshComponents(modelId) {
+    const items = await database.model_components
+      .where({ id: modelId })
+      .toArray()
     const componentTitles = {
       Corner: "Corners",
       Line: "Lines",
@@ -65,9 +64,9 @@ export const useDataStore = defineStore("data", () => {
       }))
   }
 
-  async function meshComponentType(id, geode_id) {
+  async function meshComponentType(modelId, geode_id) {
     const component = await database.model_components
-      .where({ id, geode_id })
+      .where({ id: modelId, geode_id })
       .first()
     return component?.type
   }
@@ -80,134 +79,118 @@ export const useDataStore = defineStore("data", () => {
     return await viewerStore.request(viewer_generic_schemas.deregister, { id })
   }
 
-  async function addItem(id, value) {
+  function addItem(new_item) {
     const itemData = {
-      ...value,
-      id,
-      name: value.name || id,
-      geode_object_type: value.geode_object_type,
-      visible: value.visible !== undefined ? value.visible : true,
-      created_at: value.created_at || new Date().toISOString(),
+      id: new_item.id,
+      name: new_item.name || new_item.id,
+      viewer_type: new_item.viewer_type,
+      geode_object_type: new_item.geode_object_type,
+      visible: true,
+      created_at: new Date().toISOString(),
+      binary_light_viewable: new_item.binary_light_viewable,
     }
-
-    const serializedData = structuredClone(itemData)
-    await database.data.put(serializedData)
-  }
-  async function deleteItem(id) {
-    await database.data.delete(id)
-    await deleteModelComponents(id)
-  }
-  async function updateItem(id, changes) {
-    await database.data.update(id, changes)
-  }
-
-  async function addModelComponents(id, values) {
-    if (!values || values.length === 0) {
-      console.debug("[addModelComponents] No components to add")
-      return
+    return database.data.put(itemData)
+  }
+
+  function addComponents(new_item) {
+    const allComponents = []
+    function addModelComponents(components) {
+      for (const component of components) {
+        allComponents.push({
+          id: new_item.id,
+          geode_id: component.geode_id,
+          type: component.type,
+          viewer_id: component.viewer_id,
+          name: component.name,
+        })
+      }
     }
+    addModelComponents(new_item.mesh_components)
+    addModelComponents(new_item.collection_components)
+    return database.model_components.bulkPut(allComponents)
+  }
 
-    const { mesh_components, collection_components } = values
-    const allComponents = [
-      ...(mesh_components || []),
-      ...(collection_components || []),
-    ]
-
+  function addComponentRelations(new_item) {
     const relations = []
-    for (const component of allComponents) {
-      component.id = id
-      component.created_at = new Date().toISOString()
-
+    function addModelComponentRelations(components, parent, type) {
+      for (const child of components) {
+        relations.push({
+          id: new_item.id,
+          parent,
+          child,
+          type,
+        })
+      }
+    }
+    for (const component of new_item.mesh_components) {
       if (component.boundaries) {
-        for (const boundary_id of component.boundaries) {
-          relations.push({
-            id,
-            parent: component.geode_id,
-            child: boundary_id,
-            type: "boundary",
-          })
-        }
-        delete component.boundaries
+        addModelComponentRelations(
+          component.boundaries,
+          component.geode_id,
+          "boundary",
+        )
       }
       if (component.internals) {
-        for (const internal_id of component.internals) {
-          relations.push({
-            id,
-            parent: component.geode_id,
-            child: internal_id,
-            type: "internal",
-          })
-        }
-        delete component.internals
+        addModelComponentRelations(
+          component.internals,
+          component.geode_id,
+          "internal",
+        )
       }
+    }
+    for (const component of new_item.collection_components) {
       if (component.items) {
-        for (const item_id of component.items) {
-          relations.push({
-            id,
-            parent: component.geode_id,
-            child: item_id,
-            type: "collection",
-          })
-        }
-        delete component.items
+        addModelComponentRelations(
+          component.items,
+          component.geode_id,
+          "collection",
+        )
       }
     }
+    return database.model_components_relation.bulkPut(relations)
+  }
 
-    const serializedComponents = structuredClone(allComponents)
-    const serializedRelations = structuredClone(relations)
-
-    await database.model_components.bulkAdd(serializedComponents)
-    if (serializedRelations.length > 0) {
-      await database.model_components_relation.bulkAdd(serializedRelations)
-    }
+  async function deleteItem(id) {
+    await database.data.delete(id)
+    await deleteModelComponents(id)
   }
 
-  async function deleteModelComponents(id) {
-    await database.model_components.where({ id }).delete()
-    await database.model_components_relation.where({ id }).delete()
+  async function updateItem(id, changes) {
+    await database.data.update(id, changes)
   }
 
-  async function fetchModelComponents(id) {
-    const geodeStore = useGeodeStore()
-    return await geodeStore.request(
-      back_model_schemas.model_components,
-      { id },
-      {
-        response_function: async (response) => {
-          await addModelComponents(id, response)
-        },
-      },
-    )
+  async function deleteModelComponents(modelId) {
+    await database.model_components.where({ id: modelId }).delete()
+    await database.model_components_relation.where({ id: modelId }).delete()
   }
 
-  async function getMeshComponentGeodeIds(id, component_type) {
+  async function getMeshComponentGeodeIds(modelId, component_type) {
     const components = await database.model_components
-      .where({ id, type: component_type })
+      .where({ id: modelId, type: component_type })
       .toArray()
     return components.map((component) => component.geode_id)
   }
 
-  async function getCornersGeodeIds(id) {
-    return await getMeshComponentGeodeIds(id, "Corner")
+  async function getCornersGeodeIds(modelId) {
+    return await getMeshComponentGeodeIds(modelId, "Corner")
   }
 
-  async function getLinesGeodeIds(id) {
-    return await getMeshComponentGeodeIds(id, "Line")
+  async function getLinesGeodeIds(modelId) {
+    return await getMeshComponentGeodeIds(modelId, "Line")
   }
 
-  async function getSurfacesGeodeIds(id) {
-    return await getMeshComponentGeodeIds(id, "Surface")
+  async function getSurfacesGeodeIds(modelId) {
+    return await getMeshComponentGeodeIds(modelId, "Surface")
   }
 
-  async function getBlocksGeodeIds(id) {
-    return await getMeshComponentGeodeIds(id, "Block")
+  async function getBlocksGeodeIds(modelId) {
+    return await getMeshComponentGeodeIds(modelId, "Block")
   }
 
-  async function getMeshComponentsViewerIds(id, meshComponentGeodeIds) {
+  async function getMeshComponentsViewerIds(modelId, meshComponentGeodeIds) {
     const components = await database.model_components
-      .where("id")
-      .equals(id)
-      .and((component) => meshComponentGeodeIds.includes(component.geode_id))
+      .where("[id+geode_id]")
+      .anyOf(meshComponentGeodeIds.map((geode_id) => [modelId, geode_id]))
       .toArray()
     return components.map((component) => component.viewer_id)
   }
@@ -234,9 +217,10 @@ export const useDataStore = defineStore("data", () => {
     registerObject,
     deregisterObject,
     addItem,
+    addComponents,
+    addComponentRelations,
     deleteItem,
     updateItem,
-    fetchModelComponents,
     getCornersGeodeIds,
     getLinesGeodeIds,
     getSurfacesGeodeIds,

package/app/stores/data_style.js

@@ -1,4 +1,3 @@
-import { database } from "@ogw_internal/database/database.js"
 import { getDefaultStyle } from "@ogw_front/utils/default_styles"
 import { useDataStore } from "@ogw_front/stores/data"
 import { useDataStyleStateStore } from "@ogw_internal/stores/data_style/state"
@@ -16,7 +15,7 @@ export const useDataStyleStore = defineStore("dataStyle", () => {
   }
 
   async function setVisibility(id, visibility) {
-    const item = await database.data.get(id)
+    const item = await dataStore.item(id)
     const viewer_type = item?.viewer_type
     if (!viewer_type) {
       throw new Error(`Item not found or not loaded: ${id}`)
@@ -32,12 +31,11 @@ export const useDataStyleStore = defineStore("dataStyle", () => {
   }
 
   async function applyDefaultStyle(id) {
-    const item = await database.data.get(id)
+    const item = await dataStore.item(id)
     const viewer_type = item?.viewer_type
     if (!viewer_type) {
       throw new Error(`Item not found or not loaded: ${id}`)
     }
-
     if (viewer_type === "mesh") {
       return meshStyleStore.applyMeshStyle(id)
     }

package/app/stores/hybrid_viewer.js

@@ -6,7 +6,7 @@ import { newInstance as vtkMapper } from "@kitware/vtk.js/Rendering/Core/Mapper"
 import { newInstance as vtkXMLPolyDataReader } from "@kitware/vtk.js/IO/XML/XMLPolyDataReader"
 
 import { Status } from "@ogw_front/utils/status"
-import { database } from "@ogw_internal/database/database.js"
+import { useDataStore } from "@ogw_front/stores/data"
 import { useViewerStore } from "@ogw_front/stores/viewer"
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
 
@@ -26,6 +26,7 @@ const ACTOR_COLOR = [
 const WHEEL_TIME_OUT_MS = 600
 
 export const useHybridViewerStore = defineStore("hybridViewer", () => {
+  const dataStore = useDataStore()
   const viewerStore = useViewerStore()
   const hybridDb = reactive({})
   const status = ref(Status.NOT_CREATED)
@@ -69,7 +70,7 @@ export const useHybridViewerStore = defineStore("hybridViewer", () => {
     if (!genericRenderWindow.value) {
       return
     }
-    const value = await database.data.get(id)
+    const value = await dataStore.item(id)
     console.log("hybridViewerStore.addItem", { value })
     const reader = vtkXMLPolyDataReader()
     const textEncoder = new TextEncoder()

package/app/utils/file_import_workflow.js

@@ -8,8 +8,11 @@ import { useGeodeStore } from "@ogw_front/stores/geode"
 import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer"
 import { useTreeviewStore } from "@ogw_front/stores/treeview"
 
+const SECOND = 1000
+
 async function importWorkflow(files) {
   console.log("importWorkflow", { files })
+  const start = Date.now()
   const promise_array = []
   for (const file of files) {
     const { filename, geode_object_type } = file
@@ -19,6 +22,7 @@ async function importWorkflow(files) {
   const results = await Promise.all(promise_array)
   const hybridViewerStore = useHybridViewerStore()
   hybridViewerStore.remoteRender()
+  console.log("importWorkflow completed in", (Date.now() - start) / SECOND)
   return results
 }
 
@@ -34,26 +38,45 @@ async function importItem(item) {
   const dataStyleStore = useDataStyleStore()
   const hybridViewerStore = useHybridViewerStore()
   const treeviewStore = useTreeviewStore()
-  await dataStore.registerObject(item.id)
-  await dataStore.addItem(item.id, {
-    ...item,
-  })
-
-  await treeviewStore.addItem(
+  const registerTask = dataStore.registerObject(item.id)
+  const addDataTask = dataStore.addItem(item)
+  console.log({ dataStore })
+  const addDataComponentsTask =
+    item.viewer_type === "model"
+      ? dataStore.addComponents(item)
+      : Promise.resolve()
+  const addDataRelationsTask =
+    item.viewer_type === "model"
+      ? dataStore.addComponentRelations(item)
+      : Promise.resolve()
+  const addTreeviewTask = treeviewStore.addItem(
     item.geode_object_type,
     item.name,
     item.id,
     item.viewer_type,
   )
-
-  await hybridViewerStore.addItem(item.id)
-  await dataStyleStore.addDataStyle(item.id, item.geode_object_type)
-
-  if (item.viewer_type === "model") {
-    await dataStore.fetchModelComponents(item.id)
-  }
-
-  await dataStyleStore.applyDefaultStyle(item.id)
+  const addStyleTask = dataStyleStore.addDataStyle(
+    item.id,
+    item.geode_object_type,
+  )
+  const addViewerTask = addDataTask.then(() =>
+    hybridViewerStore.addItem(item.id),
+  )
+  const applyStyleTask = Promise.all([
+    registerTask,
+    addDataComponentsTask,
+    addStyleTask,
+  ]).then(() => dataStyleStore.applyDefaultStyle(item.id))
+  await Promise.all([
+    registerTask,
+    addDataTask,
+    addDataComponentsTask,
+    addTreeviewTask,
+    addStyleTask,
+    addDataRelationsTask,
+    addViewerTask,
+    applyStyleTask,
+  ])
   return item.id
 }
 

package/internal/database/database.js

@@ -1,8 +1,8 @@
 import { Dexie } from "dexie"
 import { ExtendedDatabase } from "./extended_database"
-import { dataTable } from "./tables/data_table"
-import { modelComponentsTable } from "./tables/model_components"
+import { dataTable } from "./tables/data"
 import { modelComponentsRelationTable } from "./tables/model_components_relation"
+import { modelComponentsTable } from "./tables/model_components"
 
 class Database extends Dexie {
   constructor() {

package/internal/database/extended_database.js

@@ -1,7 +1,7 @@
 import { Dexie } from "dexie"
-import { dataTable } from "./tables/data_table"
-import { modelComponentsTable } from "./tables/model_components"
+import { dataTable } from "./tables/data"
 import { modelComponentsRelationTable } from "./tables/model_components_relation"
+import { modelComponentsTable } from "./tables/model_components"
 
 export class ExtendedDatabase extends Dexie {
   constructor(currentVersion, currentStores, newTables) {

package/internal/database/tables/data.js

@@ -0,0 +1,5 @@
+export const dataTable = {
+  name: "data",
+  schema:
+    "id, name, viewer_type, geode_object_type, visible, created_at, binary_light_viewable",
+}

package/internal/database/tables/model_components_relation.js

@@ -1,4 +1,4 @@
 export const modelComponentsRelationTable = {
   name: "model_components_relation",
-  schema: "[id+parent+child+type], id, parent, child, type",
+  schema: "[id+parent+child], type",
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geode/opengeodeweb-front",
-  "version": "10.5.0",
+  "version": "10.5.1",
   "description": "OpenSource Vue/Nuxt/Pinia/Vuetify framework for web applications",
   "homepage": "https://github.com/Geode-solutions/OpenGeodeWeb-Front",
   "bugs": {

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

@@ -5,4 +5,4 @@
 #    pip-compile --output-file=tests/integration/microservices/back/requirements.txt tests/integration/microservices/back/requirements.in
 #
 
-opengeodeweb-back==6.*,>=6.3.2
+opengeodeweb-back==6.*,>=6.3.3

package/tests/unit/composables/project_manager.nuxt.test.js

@@ -218,10 +218,7 @@ function verifyDataManagement() {
   )
   expect(dataStyleStoreMock.applyAllStylesFromState).toHaveBeenCalledWith()
   expect(dataStoreMock.registerObject).toHaveBeenCalledWith("abc123")
-  expect(dataStoreMock.addItem).toHaveBeenCalledWith(
-    "abc123",
-    expect.anything(),
-  )
+  expect(dataStoreMock.addItem).toHaveBeenCalledWith(snapshotMock.data.items[0])
   expect(treeviewStoreMock.addItem).toHaveBeenCalledWith(
     "PointSet2D",
     "My Data",

package/internal/database/tables/data_table.js

@@ -1,4 +0,0 @@
-export const dataTable = {
-  name: "data",
-  schema: "id, name, viewer_type, geode_object_type, visible, created_at",
-}