feat(save_and_load): add import/export methods

composables/project_manager.js

@@ -0,0 +1,97 @@
+import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+import fileDownload from "js-file-download"
+
+export function useProjectManager() {
+  const geode = useGeodeStore()
+  const appStore = useAppStore()
+
+  async function exportProject() {
+    geode.start_request()
+    try {
+      await useInfraStore().create_connection()
+      const snapshot = appStore.exportStores()
+      const schema = back_schemas.opengeodeweb_back.export_project
+      const defaultName = "project.zip"
+
+      await api_fetch(
+        { schema, params: { snapshot, filename: defaultName } },
+        {
+          response_function: async (response) => {
+            const data = response._data
+            const downloadName =
+              response.headers?.get?.("new-file-name") || defaultName
+            fileDownload(data, downloadName)
+          },
+        },
+      )
+    } finally {
+      geode.stop_request()
+    }
+  }
+
+  async function importProjectFile(file) {
+    geode.start_request()
+    try {
+      await useInfraStore().create_connection()
+
+      const schemaImport = back_schemas.opengeodeweb_back.import_project
+      const form = new FormData()
+      form.append("file", file, file?.name)
+
+      const result = await $fetch(schemaImport.$id, {
+        baseURL: geode.base_url,
+        method: "POST",
+        body: form,
+      })
+      const snapshot = result?.snapshot ?? {}
+
+      await viewer_call({
+        schema: viewer_schemas.opengeodeweb_viewer.import_project,
+        params: {},
+      })
+      await viewer_call({
+        schema: viewer_schemas.opengeodeweb_viewer.viewer.reset_visualization,
+        params: {},
+      })
+
+      const treeviewStore = useTreeviewStore()
+      treeviewStore.isImporting = true
+      await treeviewStore.importStores(snapshot?.treeview)
+
+      const hybridViewerStore = useHybridViewerStore()
+      await hybridViewerStore.initHybridViewer()
+      hybridViewerStore.clear()
+      await hybridViewerStore.importStores(snapshot?.hybridViewer)
+
+      const snapshotDataBase = snapshot?.dataBase?.db || {}
+      const items = Object.entries(snapshotDataBase).map(([id, item]) => ({
+        id,
+        object_type: item.object_type,
+        geode_object: item.geode_object,
+        native_filename: item.native_filename,
+        viewable_filename: item.viewable_filename,
+        displayed_name: item.displayed_name,
+        vtk_js: { binary_light_viewable: item?.vtk_js?.binary_light_viewable },
+      }))
+
+      await importWorkflowFromSnapshot(items)
+
+      // Appliquer la caméra importée après avoir créé les actors
+      await hybridViewerStore.importStores(snapshot?.hybridViewer)
+
+      const dataStyleStore = useDataStyleStore()
+      await dataStyleStore.importStores(snapshot?.dataStyle)
+      await dataStyleStore.applyAllStylesFromState()
+
+      treeviewStore.finalizeImportSelection()
+      treeviewStore.isImporting = false
+    } finally {
+      geode.stop_request()
+    }
+  }
+
+  return { exportProject, importProjectFile }
+}
+
+export default useProjectManager

composables/viewer_call.js

@@ -18,8 +18,9 @@ export function viewer_call(
   const client = viewer_store.client
 
   return new Promise((resolve, reject) => {
-    if (!client) {
-      reject()
+    if (!client?.getConnection) {
+      resolve()
+      return
     }
     viewer_store.start_request()
     client
@@ -37,7 +38,7 @@ export function viewer_call(
           if (request_error_function) {
             request_error_function(reason)
           }
-          reject()
+          reject(reason)
         },
       )
       .catch((error) => {
@@ -50,7 +51,7 @@ export function viewer_call(
         if (response_error_function) {
           response_error_function(error)
         }
-        reject()
+        reject(error)
       })
       .finally(() => {
         viewer_store.stop_request()

stores/app_store.js → stores/app.js

@@ -5,81 +5,72 @@ export const useAppStore = defineStore("app", () => {
     const isAlreadyRegistered = stores.some(
       (registeredStore) => registeredStore.$id === store.$id,
     )
-
     if (isAlreadyRegistered) {
       console.log(
         `[AppStore] Store "${store.$id}" already registered, skipping`,
       )
       return
     }
-
     console.log("[AppStore] Registering store", store.$id)
     stores.push(store)
   }
 
-  function save() {
+  function exportStores() {
     const snapshot = {}
-    let savedCount = 0
+    let exportCount = 0
 
     for (const store of stores) {
-      if (!store.save) {
-        continue
-      }
+      if (!store.exportStores) continue
       const storeId = store.$id
       try {
-        snapshot[storeId] = store.save()
-        savedCount++
+        snapshot[storeId] = store.exportStores()
+        exportCount++
       } catch (error) {
-        console.error(`[AppStore] Error saving store "${storeId}":`, error)
+        console.error(`[AppStore] Error exporting store "${storeId}":`, error)
       }
     }
-
-    console.log(`[AppStore] Saved ${savedCount} stores`)
+    console.log(
+      `[AppStore] Exported ${exportCount} stores; snapshot keys:`,
+      Object.keys(snapshot),
+    )
     return snapshot
   }
 
-  function load(snapshot) {
+  async function importStores(snapshot) {
     if (!snapshot) {
-      console.warn("[AppStore] load called with invalid snapshot")
+      console.warn("[AppStore] import called with invalid snapshot")
       return
     }
+    console.log("[AppStore] Import snapshot keys:", Object.keys(snapshot || {}))
 
-    let loadedCount = 0
+    let importedCount = 0
     const notFoundStores = []
-
     for (const store of stores) {
-      if (!store.load) {
-        continue
-      }
-
+      if (!store.importStores) continue
       const storeId = store.$id
-
       if (!snapshot[storeId]) {
         notFoundStores.push(storeId)
         continue
       }
-
       try {
-        store.load(snapshot[storeId])
-        loadedCount++
+        await store.importStores(snapshot[storeId])
+        importedCount++
       } catch (error) {
-        console.error(`[AppStore] Error loading store "${storeId}":`, error)
+        console.error(`[AppStore] Error importing store "${storeId}":`, error)
       }
     }
-
     if (notFoundStores.length > 0) {
       console.warn(
         `[AppStore] Stores not found in snapshot: ${notFoundStores.join(", ")}`,
       )
     }
-
-    console.log(`[AppStore] Loaded ${loadedCount} stores`)
+    console.log(`[AppStore] Imported ${importedCount} stores`)
   }
 
   return {
     stores,
     registerStore,
-    save,
-    load,
+    exportStores,
+    importStores,
   }
 })

stores/data_base.js

@@ -48,6 +48,9 @@ export const useDataBaseStore = defineStore("dataBase", () => {
     })
   }
 
+  const treeviewStore = useTreeviewStore()
+  const hybridViewerStore = useHybridViewerStore()
+
   async function addItem(
     id,
     value = {
@@ -59,7 +62,17 @@ export const useDataBaseStore = defineStore("dataBase", () => {
       vtk_js: { binary_light_viewable },
     },
   ) {
+    console.log("[DataBase] addItem start", {
+      id,
+      object_type: value.object_type,
+      geode_object: value.geode_object,
+    })
     db[id] = value
+
+    if (value.object_type === "model") {
+      await fetchMeshComponents(id)
+      await fetchUuidToFlatIndexDict(id)
+    }
   }
 
   async function fetchMeshComponents(id) {
@@ -93,6 +106,37 @@ export const useDataBaseStore = defineStore("dataBase", () => {
     )
   }
 
+  function exportStores() {
+    const snapshotDb = {}
+    for (const [id, item] of Object.entries(db)) {
+      if (!item) continue
+      snapshotDb[id] = {
+        object_type: item.object_type,
+        geode_object: item.geode_object,
+        native_filename: item.native_filename,
+        viewable_filename: item.viewable_filename,
+        displayed_name: item.displayed_name,
+        vtk_js: {
+          binary_light_viewable: item?.vtk_js?.binary_light_viewable,
+        },
+      }
+    }
+    return { db: snapshotDb }
+  }
+
+  async function importStores(snapshot) {
+    await hybridViewerStore.initHybridViewer()
+    hybridViewerStore.clear()
+    console.log(
+      "[DataBase] importStores entries:",
+      Object.keys(snapshot?.db || {}),
+    )
+    for (const [id, item] of Object.entries(snapshot?.db || {})) {
+      await registerObject(id)
+      await addItem(id, item)
+    }
+  }
+
   function getCornersUuids(id) {
     const { mesh_components } = itemMetaDatas(id)
     return Object.values(mesh_components["Corner"])
@@ -134,5 +178,7 @@ export const useDataBaseStore = defineStore("dataBase", () => {
     getSurfacesUuids,
     getBlocksUuids,
     getFlatIndexes,
+    exportStores,
+    importStores,
   }
 })

stores/data_style.js

@@ -1,6 +1,8 @@
 import useDataStyleState from "../internal_stores/data_style_state.js"
 import useMeshStyle from "../internal_stores/mesh/index.js"
 import useModelStyle from "../internal_stores/model/index.js"
+import { defineStore } from "pinia"
+import { useDataBaseStore } from "./data_base.js"
 
 export const useDataStyleStore = defineStore("dataStyle", () => {
   const dataStyleState = useDataStyleState()
@@ -13,11 +15,12 @@ export const useDataStyleStore = defineStore("dataStyle", () => {
   }
 
   function setVisibility(id, visibility) {
-    console.log(
-      "dataBaseStore.itemMetaDatas(id)",
-      dataBaseStore.itemMetaDatas(id),
-    )
-    const object_type = dataBaseStore.itemMetaDatas(id).object_type
+    const meta = dataBaseStore.itemMetaDatas(id)
+    if (!meta) {
+      console.warn("[DataStyle] setVisibility skipped: unknown id", id)
+      return Promise.resolve([])
+    }
+    const object_type = meta.object_type
     if (object_type === "mesh") {
       return Promise.all([meshStyleStore.setMeshVisibility(id, visibility)])
     } else if (object_type === "model") {
@@ -32,8 +35,43 @@ export const useDataStyleStore = defineStore("dataStyle", () => {
       return meshStyleStore.applyMeshStyle(id)
     } else if (object_type === "model") {
       return modelStyleStore.applyModelStyle(id)
-    } else {
-      throw new Error("Unknown object_type: " + object_type)
+    }
+    return Promise.resolve([])
+  }
+
+  function setModelEdgesVisibility(id, visibility) {
+    return modelStyleStore.setModelEdgesVisibility(id, visibility)
+  }
+
+  function modelEdgesVisibility(id) {
+    return modelStyleStore.modelEdgesVisibility(id)
+  }
+
+  function exportStores() {
+    return { styles: dataStyleState.styles }
+  }
+
+  async function importStores(snapshot) {
+    const stylesSnapshot = snapshot?.styles || {}
+    for (const id of Object.keys(dataStyleState.styles))
+      delete dataStyleState.styles[id]
+    for (const [id, style] of Object.entries(stylesSnapshot)) {
+      dataStyleState.styles[id] = style
+    }
+  }
+
+  async function applyAllStylesFromState() {
+    const ids = Object.keys(dataStyleState.styles || {})
+    for (const id of ids) {
+      const meta = dataBaseStore.itemMetaDatas(id)
+      const objectType = meta?.object_type
+      const style = dataStyleState.styles[id]
+      if (!style || !objectType) continue
+      if (objectType === "mesh") {
+        await meshStyleStore.applyMeshStyle(id)
+      } else if (objectType === "model") {
+        await modelStyleStore.applyModelStyle(id)
+      }
     }
   }
 
@@ -44,5 +82,10 @@ export const useDataStyleStore = defineStore("dataStyle", () => {
     addDataStyle,
     applyDefaultStyle,
     setVisibility,
+    setModelEdgesVisibility,
+    modelEdgesVisibility,
+    exportStores,
+    importStores,
+    applyAllStylesFromState,
   }
 })