@geode/opengeodeweb-front 10.0.1 → 10.0.2-rc.2

package/app/components/CrsSelector.vue

@@ -45,6 +45,7 @@
   const crs_list = ref([])
   const selected_crs = ref([])
   const toggle_loading = useToggle(data_table_loading)
+  const geodeStore = useGeodeStore()
 
   watch(selected_crs, (new_value) => {
     const crs = get_selected_crs(new_value[0])
@@ -66,14 +67,11 @@
   async function get_crs_table() {
     const params = { geode_object_type }
     toggle_loading()
-    await api_fetch(
-      { schema, params },
-      {
-        response_function: (response) => {
-          crs_list.value = response._data.crs_list
-        },
+    await geodeStore.request(schema, params, {
+      response_function: (response) => {
+        crs_list.value = response._data.crs_list
       },
-    )
+    })
     toggle_loading()
   }
 

package/app/components/ExtensionSelector.vue

@@ -79,27 +79,22 @@
   async function get_output_file_extensions() {
     toggle_loading()
     geode_objects_and_output_extensions.value = {}
-    var promise_array = []
-    for (const filename of filenames) {
-      const params = { geode_object_type, filename }
-      const promise = new Promise((resolve, reject) => {
-        api_fetch(
-          { schema, params },
-          {
-            request_error_function: () => {
-              reject()
-            },
-            response_function: (response) => {
-              resolve(response._data.geode_objects_and_output_extensions)
-            },
-            response_error_function: () => {
-              reject()
-            },
+    const geodeStore = useGeodeStore()
+    const promise_array = filenames.map((filename) => {
+      return new Promise((resolve, reject) => {
+        const params = {
+          geode_object_type,
+          filename,
+        }
+        geodeStore.request(schema, params, {
+          request_error_function: () => reject(),
+          response_function: (response) => {
+            resolve(response._data.geode_objects_and_output_extensions)
           },
-        )
+          response_error_function: () => reject(),
+        })
       })
-      promise_array.push(promise)
-    }
+    })
     const values = await Promise.all(promise_array)
     const all_keys = [...new Set(values.flatMap((value) => Object.keys(value)))]
     const common_keys = all_keys.filter(

package/app/components/FileSelector.vue

@@ -22,14 +22,14 @@
 
   const props = defineProps({
     multiple: { type: Boolean, required: true },
-    supported_feature: { type: String, required: false, default: null },
     files: { type: Array, required: false, default: [] },
     auto_upload: { type: Boolean, required: false, default: true },
   })
 
-  const { auto_upload, multiple, supported_feature } = props
+  const { multiple } = props
 
   const internal_files = ref(props.files)
+  const auto_upload = ref(props.auto_upload)
   const accept = ref("")
   const loading = ref(false)
 
@@ -40,6 +40,9 @@
     },
     { deep: true },
   )
+  watch(props.auto_upload, (newVal) => {
+    auto_upload.value = newVal
+  })
 
   const toggle_loading = useToggle(loading)
 
@@ -52,16 +55,11 @@
 
   async function get_allowed_files() {
     toggle_loading()
-    await api_fetch(
-      { schema },
-      {
-        response_function: (response) => {
-          accept.value = response._data.extensions
-            .map((extension) => "." + extension)
-            .join(",")
-        },
-      },
-    )
+    const geodeStore = useGeodeStore()
+    const response = await geodeStore.request(schema, {})
+    accept.value = response.data.value.extensions
+      .map((extension) => "." + extension)
+      .join(",")
     toggle_loading()
   }
   await get_allowed_files()

package/app/components/FileUploader.vue

@@ -34,6 +34,7 @@
 
 <script setup>
   import schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
+  import { upload_file } from "@ogw_front/utils/upload_file.js"
   const schema = schemas.opengeodeweb_back.upload_file
 
   const emit = defineEmits(["files_uploaded", "decrement_step"])

package/app/components/Inspector/InspectionButton.vue

@@ -33,18 +33,16 @@
   async function get_inspection_results(geode_object_type, filename) {
     toggle_loading()
     const params = { geode_object_type, filename }
+    const geodeStore = useGeodeStore()
 
-    await api_fetch(
-      { schema, params },
-      {
-        response_function: (response) => {
-          emit("update_values", {
-            inspection_result: [response._data.inspection_result],
-          })
-          emit("increment_step")
-        },
+    await geodeStore.request(schema, params, {
+      response_function: (response) => {
+        emit("update_values", {
+          inspection_result: [response._data.inspection_result],
+        })
+        emit("increment_step")
       },
-    )
+    })
     toggle_loading()
   }
 </script>

package/app/components/MissingFilesSelector.vue

@@ -81,28 +81,18 @@
     has_missing_files.value = false
     mandatory_files.value = []
     additional_files.value = []
-    var promise_array = []
+    const geodeStore = useGeodeStore()
 
-    for (const filename of filenames) {
+    const promise_array = filenames.map((filename) => {
       const params = { geode_object_type, filename }
-      const promise = new Promise((resolve, reject) => {
-        api_fetch(
-          { schema, params },
-          {
-            request_error_function: () => {
-              reject()
-            },
-            response_function: (response) => {
-              resolve(response._data)
-            },
-            response_error_function: () => {
-              reject()
-            },
-          },
-        )
+      return new Promise((resolve, reject) => {
+        geodeStore.request(schema, params, {
+          request_error_function: () => reject(),
+          response_function: (response) => resolve(response._data),
+          response_error_function: () => reject(),
+        })
       })
-      promise_array.push(promise)
-    }
+    })
     const values = await Promise.all(promise_array)
     for (const value of values) {
       has_missing_files.value = value.has_missing_files

package/app/components/ObjectSelector.vue

@@ -108,13 +108,13 @@
   async function get_allowed_objects() {
     toggle_loading()
     allowed_objects.value = {}
+    const geodeStore = useGeodeStore()
     const promise_array = filenames.map((filename) => {
-      const params = { filename }
-      return api_fetch({ schema, params })
+      return geodeStore.request(schema, { filename })
     })
     const responses = await Promise.all(promise_array)
     const allowed_objects_list = responses.map(
-      (response) => response.data.value.allowed_objects,
+      (r) => r.data.value.allowed_objects,
     )
     const all_keys = [...new Set(allowed_objects_list.flatMap(Object.keys))]
     const common_keys = all_keys.filter((key) =>

package/app/components/PackagesVersions.vue

@@ -25,35 +25,23 @@
     schema: { type: Object, required: true },
   })
 
-  const geode_store = useGeodeStore()
+  const geodeStore = useGeodeStore()
   const packages_versions = ref([])
 
   async function get_packages_versions() {
-    const array_promise = []
-
-    const promise = new Promise((resolve, reject) => {
-      api_fetch(
-        { schema: props.schema },
-        {
-          request_error_function: () => {
-            reject()
-          },
-          response_function: (response) => {
-            packages_versions.value = response._data.versions
-            resolve()
-          },
-          response_error_function: () => {
-            reject()
-          },
+    await geodeStore.request(
+      props.schema,
+      {},
+      {
+        response_function: (response) => {
+          packages_versions.value = response._data.versions
         },
-      )
-    })
-    array_promise.push(promise)
-    await Promise.all(array_promise)
+      },
+    )
   }
 
   watch(
-    () => geode_store.status,
+    () => geodeStore.status,
     (value) => {
       if (value == Status.CONNECTED) get_packages_versions()
     },

package/app/components/RemoteRenderingView.vue

@@ -14,7 +14,7 @@
         "
         class="pa-0"
         @click="get_x_y"
-        @keydown.esc="viewer_store.toggle_picking_mode(false)"
+        @keydown.esc="viewerStore.toggle_picking_mode(false)"
       />
     </div>
   </ClientOnly>
@@ -32,20 +32,20 @@
     viewId: { type: String, default: "-1" },
   })
 
-  const viewer_store = useViewerStore()
+  const viewerStore = useViewerStore()
   const viewer = useTemplateRef("viewer")
   const { width, height } = useElementSize(viewer)
 
   const { width: windowWidth, height: windowHeight } = useWindowSize()
 
   function get_x_y(event) {
-    if (viewer_store.picking_mode.value === true) {
+    if (viewerStore.picking_mode.value === true) {
       const { offsetX, offsetY } = event
-      viewer_store.set_picked_point(offsetX, offsetY)
-      viewer_call({
-        schema: viewer_schemas.opengeodeweb_viewer.viewer.get_point_position,
-        params: { x: offsetX, y: offsetY },
-      })
+      viewerStore.set_picked_point(offsetX, offsetY)
+      viewerStore.request(
+        viewer_schemas.opengeodeweb_viewer.viewer.get_point_position,
+        { x: offsetX, y: offsetY },
+      )
     }
   }
 
@@ -70,7 +70,7 @@
   })
 
   watch(
-    () => viewer_store.picking_mode,
+    () => viewerStore.picking_mode,
     (value) => {
       const cursor = value ? "crosshair" : "pointer"
       view.getCanvasView().setCursor(cursor)
@@ -82,7 +82,7 @@
   })
 
   watch(
-    () => viewer_store.client,
+    () => viewerStore.client,
     () => {
       connect()
     },
@@ -99,10 +99,10 @@
   )
 
   function connect() {
-    if (viewer_store.status !== Status.CONNECTED) {
+    if (viewerStore.status !== Status.CONNECTED) {
       return
     }
-    const session = viewer_store.client.getConnection().getSession()
+    const session = viewerStore.client.getConnection().getSession()
     view.setSession(session)
     view.setViewId(props.viewId)
     connected.value = true

package/app/components/Screenshot.vue

@@ -79,14 +79,13 @@
   const include_background = ref(true)
 
   async function takeScreenshot() {
-    await viewer_call(
+    const viewerStore = useViewerStore()
+    await viewerStore.request(
+      viewer_schemas.opengeodeweb_viewer.viewer.take_screenshot,
       {
-        schema: viewer_schemas.opengeodeweb_viewer.viewer.take_screenshot,
-        params: {
-          filename: filename.value,
-          output_extension: output_extension.value,
-          include_background: include_background.value,
-        },
+        filename: filename.value,
+        output_extension: output_extension.value,
+        include_background: include_background.value,
       },
       {
         response_function: async (response) => {

package/app/components/Step.vue

@@ -51,9 +51,10 @@
       :key="step_index"
       :is="steps[step_index].component.component_name"
       v-bind="steps[step_index].component.component_options"
-      @update_values="update_values_event"
       @increment_step="increment_step"
       @decrement_step="decrement_step"
+      @update_values="update_values_event"
+      @reset_values="$emit('reset_values')"
     />
   </v-stepper-content>
 </template>

package/app/components/Stepper.vue

@@ -7,7 +7,12 @@
   >
     <v-stepper-items>
       <v-col cols="12">
-        <Step v-for="(step, index) in steps" :key="step" :step_index="index" />
+        <Step
+          v-for="(step, index) in steps"
+          :key="step"
+          :step_index="index"
+          @reset_values="emit('reset_values')"
+        />
       </v-col>
     </v-stepper-items>
   </v-stepper-vertical>
@@ -16,6 +21,7 @@
 <script setup>
   import Step from "@ogw_front/components/Step.vue"
 
+  const emit = defineEmits(["reset_values"])
   const stepper_tree = inject("stepper_tree")
   const { steps, current_step_index } = toRefs(stepper_tree)
 </script>

package/app/components/VeaseViewToolbar.vue

@@ -74,13 +74,10 @@
       tooltip: "Toggle grid scale",
       icon: "mdi-ruler-square",
       action: () => {
-        viewer_call(
-          {
-            schema: schemas.opengeodeweb_viewer.viewer.grid_scale,
-            params: {
-              visibility: !grid_scale.value,
-            },
-          },
+        const viewerStore = useViewerStore()
+        viewerStore.request(
+          schemas.opengeodeweb_viewer.viewer.grid_scale,
+          { visibility: !grid_scale.value },
           {
             response_function: () => {
               grid_scale.value = !grid_scale.value

package/app/components/ViewToolbar.vue

@@ -33,9 +33,8 @@
       tooltip: "Reset camera",
       icon: "mdi-cube-scan",
       action: () => {
-        viewer_call({
-          schema: schemas.opengeodeweb_viewer.viewer.reset_camera,
-        })
+        const viewerStore = useViewerStore()
+        viewerStore.request(schemas.opengeodeweb_viewer.viewer.reset_camera)
       },
     },
     {
@@ -49,13 +48,10 @@
       tooltip: "Toggle grid scale",
       icon: "mdi-ruler-square",
       action: () => {
-        viewer_call(
-          {
-            schema: schemas.opengeodeweb_viewer.viewer.grid_scale,
-            params: {
-              visibility: !grid_scale.value,
-            },
-          },
+        const viewerStore = useViewerStore()
+        viewerStore.request(
+          schemas.opengeodeweb_viewer.viewer.grid_scale,
+          { visibility: !grid_scale.value },
           {
             response_function: () => {
               grid_scale.value = !grid_scale.value

package/app/components/Viewer/Options/CellAttributeSelector.vue

@@ -18,6 +18,7 @@
   const cell_attribute_name = ref("")
   const cell_attribute_names = ref([])
   const cell_attribute = reactive({ name: cell_attribute_name.value })
+  const geodeStore = useGeodeStore()
 
   onMounted(() => {
     if (model.value != null) {
@@ -35,12 +36,10 @@
   })
 
   function getCellAttributes() {
-    api_fetch(
+    geodeStore.request(
+      back_schemas.opengeodeweb_back.cell_attribute_names,
       {
-        schema: back_schemas.opengeodeweb_back.cell_attribute_names,
-        params: {
-          id: props.id,
-        },
+        id: props.id,
       },
       {
         response_function: (response) => {

package/app/components/Viewer/Options/PolygonAttributeSelector.vue

@@ -18,6 +18,7 @@
   const polygon_attribute_name = ref("")
   const polygon_attribute_names = ref([])
   const polygon_attribute = reactive({ name: polygon_attribute_name.value })
+  const geodeStore = useGeodeStore()
 
   onMounted(() => {
     if (model.value != null) {
@@ -35,12 +36,10 @@
   })
 
   function getPolygonAttributes() {
-    api_fetch(
+    geodeStore.request(
+      back_schemas.opengeodeweb_back.polygon_attribute_names,
       {
-        schema: back_schemas.opengeodeweb_back.polygon_attribute_names,
-        params: {
-          id: props.id,
-        },
+        id: props.id,
       },
       {
         response_function: (response) => {

package/app/components/Viewer/Options/PolyhedronAttributeSelector.vue

@@ -33,19 +33,16 @@
   })
 
   const polyhedron_attribute_names = ref([])
+  const geodeStore = useGeodeStore()
 
   onMounted(() => {
     getVertexAttributes()
   })
 
   function getVertexAttributes() {
-    api_fetch(
-      {
-        schema: back_schemas.opengeodeweb_back.polyhedron_attribute_names,
-        params: {
-          id: props.id,
-        },
-      },
+    geodeStore.request(
+      back_schemas.opengeodeweb_back.polyhedron_attribute_names,
+      { id: props.id },
       {
         response_function: (response) => {
           polyhedron_attribute_names.value =

package/app/components/Viewer/Options/TextureItem.vue

@@ -54,19 +54,16 @@
   texture_id.value = props.texture_id
 
   const texture_coordinates = ref([])
+  const geodeStore = useGeodeStore()
 
   onMounted(() => {
     getTextureCoordinates()
   })
 
   function getTextureCoordinates() {
-    api_fetch(
-      {
-        schema: back_schemas.opengeodeweb_back.texture_coordinates,
-        params: {
-          id: props.id,
-        },
-      },
+    geodeStore.request(
+      back_schemas.opengeodeweb_back.texture_coordinates,
+      { id: props.id },
       {
         response_function: (response) => {
           texture_coordinates.value = response._data.texture_coordinates
@@ -77,7 +74,8 @@
 
   async function files_uploaded_event(value) {
     if (value.length) {
-      await api_fetch(
+      await geodeStore.request(
+        back_schemas.opengeodeweb_back.save_viewable_file,
         {
           schema: back_schemas.opengeodeweb_back.save_viewable_file,
           params: {

package/app/components/Viewer/Options/VertexAttributeSelector.vue

@@ -36,13 +36,9 @@
   })
 
   function getVertexAttributes() {
-    api_fetch(
-      {
-        schema: back_schemas.opengeodeweb_back.vertex_attribute_names,
-        params: {
-          id: props.id,
-        },
-      },
+    geodeStore.request(
+      back_schemas.opengeodeweb_back.vertex_attribute_names,
+      { id: props.id },
       {
         response_function: (response) => {
           vertex_attribute_names.value = response._data.vertex_attribute_names

package/app/composables/project_manager.js

@@ -9,12 +9,10 @@ export function useProjectManager() {
     console.log("[export triggered]")
     const appStore = useAppStore()
     const geodeStore = useGeodeStore()
-    const infraStore = useInfraStore()
     const snapshot = appStore.exportStores()
     const schema = back_schemas.opengeodeweb_back.export_project
     const defaultName = "project.vease"
 
-    await infraStore.create_connection()
     const result = await $fetch(schema.$id, {
       baseURL: geodeStore.base_url,
       method: schema.methods.filter((m) => m !== "OPTIONS")[0],
@@ -30,9 +28,7 @@ export function useProjectManager() {
     const dataBaseStore = useDataBaseStore()
     const treeviewStore = useTreeviewStore()
     const hybridViewerStore = useHybridViewerStore()
-    const infraStore = useInfraStore()
 
-    await infraStore.create_connection()
     await viewerStore.ws_connect()
 
     const client = viewerStore.client
@@ -43,10 +39,10 @@ export function useProjectManager() {
         .call("opengeodeweb_viewer.release_database", [{}])
     }
 
-    await viewer_call({
-      schema: viewer_schemas.opengeodeweb_viewer.viewer.reset_visualization,
-      params: {},
-    })
+    await viewerStore.request(
+      viewer_schemas.opengeodeweb_viewer.viewer.reset_visualization,
+      {},
+    )
 
     treeviewStore.clear()
     dataBaseStore.clear()
@@ -81,9 +77,9 @@ export function useProjectManager() {
         .call("opengeodeweb_viewer.import_project", [{}])
     }
 
-    await treeviewStore.importStores(snapshot.treeview)
+    await treeviewStore.importStores(snapshot.treeview || {})
     await hybridViewerStore.initHybridViewer()
-    await hybridViewerStore.importStores(snapshot.hybridViewer)
+    await hybridViewerStore.importStores(snapshot.hybridViewer || {})
 
     const snapshotDataBase =
       snapshot && snapshot.dataBase && snapshot.dataBase.db
@@ -99,11 +95,11 @@ export function useProjectManager() {
     })
 
     await importWorkflowFromSnapshot(items)
-    await hybridViewerStore.importStores(snapshot.hybridViewer)
+    await hybridViewerStore.importStores(snapshot.hybridViewer || {})
 
     {
       const dataStyleStore = useDataStyleStore()
-      await dataStyleStore.importStores(snapshot.dataStyle)
+      await dataStyleStore.importStores(snapshot.dataStyle || {})
     }
     {
       const dataStyleStore = useDataStyleStore()

package/app/stores/data_base.js

@@ -42,10 +42,8 @@ export const useDataBaseStore = defineStore("dataBase", () => {
   }
 
   async function registerObject(id) {
-    return viewer_call({
-      schema: viewer_generic_schemas.register,
-      params: { id },
-    })
+    const viewerStore = useViewerStore()
+    return viewerStore.request(viewer_generic_schemas.register, { id })
   }
 
   async function addItem(
@@ -63,13 +61,10 @@ export const useDataBaseStore = defineStore("dataBase", () => {
   }
 
   async function fetchMeshComponents(id) {
-    return api_fetch(
-      {
-        schema: back_model_schemas.mesh_components,
-        params: {
-          id,
-        },
-      },
+    const geodeStore = useGeodeStore()
+    return geodeStore.request(
+      back_model_schemas.mesh_components,
+      { id },
       {
         response_function: async (response) => {
           db[id].mesh_components = response._data.uuid_dict
@@ -80,11 +75,10 @@ export const useDataBaseStore = defineStore("dataBase", () => {
 
   async function fetchUuidToFlatIndexDict(id) {
     console.log("fetchUuidToFlatIndexDict", id)
-    return api_fetch(
-      {
-        schema: back_model_schemas.vtm_component_indices,
-        params: { id },
-      },
+    const geodeStore = useGeodeStore()
+    return geodeStore.request(
+      back_model_schemas.vtm_component_indices,
+      { id },
       {
         response_function: async (response) => {
           db[id]["uuid_to_flat_index"] = response._data.uuid_to_flat_index