feat(import_project): add 2 buttons : Export and import

Compatibility with data_style

Author: MaxNumerique

composables/project_manager.js

@@ -1,15 +1,11 @@
 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"
-import { useAppStore } from "../stores/app.js"
-import { useGeodeStore } from "../stores/geode.js"
-import { useInfraStore } from "../stores/infra.js"
-import { viewer_call } from "./viewer_call.js"
-import { api_fetch } from "./api_fetch.js"
+
 
 export function useProjectManager() {
-  const appStore = useAppStore()
   const geode = useGeodeStore()
+  const appStore = useAppStore()
 
   async function exportProject() {
     geode.start_request()
@@ -41,83 +37,19 @@ export function useProjectManager() {
       const infra = useInfraStore()
       await infra.create_connection()
 
-      const isJson = (file.name || "").toLowerCase().endsWith(".json")
-      if (isJson) {
-        const snapshot = JSON.parse(await file.text())
-        await viewer_call({
-          schema: viewer_schemas.opengeodeweb_viewer.import_project,
-          params: {},
-        })
-        await viewer_call({
-          schema: viewer_schemas.opengeodeweb_viewer.viewer.reset_visualization,
-          params: {},
-        })
-        await appStore.importStores(snapshot)
-        return
-      }
-
-      // Import ZIP → multipart/form-data
       const form = new FormData()
       form.append("file", file, file.name || "project.zip")
 
-      const importId =
+      const importPath =
         back_schemas.opengeodeweb_back.import_project?.$id ||
         "opengeodeweb_back/import_project"
-      const importURL = new URL(
-        "/" + String(importId),
-        infra?.base_url || window.location.origin,
-      ).toString()
 
-      let result
-      try {
-        result = await $fetch(importURL, { method: "POST", body: form })
-      } catch (error) {
-        const status = error?.response?.status ?? error?.status
-        const data = error?.response?._data ?? error?.data
-        if (status === 423) {
-          await viewer_call({
-            schema:
-              viewer_schemas.opengeodeweb_viewer.viewer.reset_visualization,
-            params: {},
-          })
-          result = await $fetch(importURL, { method: "POST", body: form })
-        } else {
-          console.error("Backend import_project erreur:", data ?? error)
-        }
-      }
-
-      // Si le backend renvoie un snapshot, on met à jour les stores
-      if (result?.snapshot) {
-        await appStore.importStores(result.snapshot)
-      }
-
-      // Si pas de viewables prêts, on tente des conversions courantes
-      const needsViewables = result?.viewables_ready === false || result == null
-      if (needsViewables) {
-        const candidates = [
-          { input_geode_object: "BRep", filename: "native/main.og_brep" },
-          {
-            input_geode_object: "SurfaceMesh",
-            filename: "native/main.og_mesh",
-          },
-        ]
-        for (const c of candidates) {
-          try {
-            await api_fetch({
-              schema: back_schemas.opengeodeweb_back.save_viewable_file,
-              params: {
-                input_geode_object: c.input_geode_object,
-                filename: c.filename,
-              },
-            })
-            break
-          } catch (_) {
-            // On ignore et on essaie le candidat suivant
-          }
-        }
-      }
+      const result = await $fetch(importPath, {
+        baseURL: geode.base_url,
+        method: "POST",
+        body: form,
+      })
 
-      // Synchronisation Viewer
       await viewer_call({
         schema: viewer_schemas.opengeodeweb_viewer.import_project,
         params: {},
@@ -126,10 +58,45 @@ export function useProjectManager() {
         schema: viewer_schemas.opengeodeweb_viewer.viewer.reset_visualization,
         params: {},
       })
+
+      await appStore.importStores(result.snapshot)
+
+      const dataBaseStore = useDataBaseStore()
+      for (const [id, item] of Object.entries(dataBaseStore.items)) {
+        const registerSchema =
+          item.object_type === "model"
+            ? viewer_schemas.opengeodeweb_viewer.model.register
+            : viewer_schemas.opengeodeweb_viewer.mesh.register
+        await viewer_call({ schema: registerSchema, params: { id } })
+
+        if (item.vtk_js?.binary_light_viewable) {
+          await viewer_call({
+            schema: viewer_schemas.opengeodeweb_viewer.viewer.update_data,
+            params: {
+              id,
+              vtk_js: {
+                binary_light_viewable: item.vtk_js.binary_light_viewable,
+              },
+            },
+          })
+        }
+
+        if (item.viewable_filename) {
+          await viewer_call({
+            schema: viewer_schemas.opengeodeweb_viewer.viewer.update_data,
+            params: {
+              id,
+              vtk_js: { viewable_file_name: item.viewable_filename },
+            },
+          })
+        }
+      }
     } finally {
       geode.stop_request()
     }
   }
 
   return { exportProject, importProjectFile }
 }
+
+export default useProjectManager

stores/data_style.js

@@ -10,9 +10,7 @@ export const useDataStyleStore = defineStore("dataStyle", () => {
   const dataBaseStore = useDataBaseStore()
 
   /** Actions **/
-  function addDataStyle(id, geode_object, object_type) {
-    dataStyleState.styles[id] = getDefaultStyle(geode_object)
-    const promise_array = []
+  // function applyDataStyle() {
     if (object_type === "mesh") {
       promise_array.push(meshStyleStore.applyMeshDefaultStyle(id))
     } else if (object_type === "model") {
@@ -21,15 +19,37 @@ export const useDataStyleStore = defineStore("dataStyle", () => {
     } else {
       throw new Error("Unknown object type")
     }
-    return Promise.all(promise_array)
+    await Promise.all(promise_array);
+    await rpc_call("opengeodeweb_viewer.viewer.render_now", {});
+    return true;
   }
 
-  function setVisibility(id, visibility) {
-    const object_type = dataBaseStore.itemMetaDatas(id).object_type
+  async function setVisibility(payloadOrId, visibility) {
+    const id =
+      typeof payloadOrId === "string"
+        ? payloadOrId
+        : payloadOrId?.id ?? payloadOrId?.data_id ?? payloadOrId?.model_id
+    if (!id) return Promise.resolve([])
+
+    const meta = dataBaseStore.itemMetaDatas(id)
+    const object_type = meta?.object_type
+    if (!object_type) return Promise.resolve([])
+
+    if (!dataStyleState.styles[id]) {
+      await addDataStyle(id, meta.geode_object, object_type)
+    }
+
+    const visible =
+      typeof visibility === "boolean"
+        ? visibility
+        : payloadOrId?.visible != null
+        ? !!payloadOrId.visible
+        : true
+
     if (object_type === "mesh") {
-      return Promise.all([meshStyleStore.setMeshVisibility(id, visibility)])
-    } else if (object_type === "model") {
-      return Promise.all([modelStyleStore.setModelVisibility(id, visibility)])
+      return Promise.all([meshStyleStore.setMeshVisibility(id, visible)])
+    } else {
+      return Promise.all([modelStyleStore.setModelVisibility(id, visible)])
     }
   }