@geode/opengeodeweb-front 9.0.2-rc.2 → 9.0.2

package/components/FeedBack/Snackers.vue

@@ -9,6 +9,7 @@
     transition="slide-x-reverse-transition"
     max-width="200px"
     height="20px"
+    timeout="10000"
   >
     <v-row dense class="flex-nowrap">
       <v-col cols="auto">

package/package.json

@@ -37,10 +37,10 @@
   },
   "description": "OpenSource Vue/Vuetify framework for web applications",
   "type": "module",
-  "version": "9.0.2-rc.2",
+  "version": "9.0.2",
   "main": "./nuxt.config.js",
   "dependencies": {
-    "@geode/opengeodeweb-back": "5.0.0",
+    "@geode/opengeodeweb-back": "5.1.0",
     "@geode/opengeodeweb-viewer": "0.2.0",
     "@kitware/vtk.js": "30.3.1",
     "@mdi/font": "^7.4.47",

package/stores/geode.js

@@ -32,32 +32,39 @@ export const use_geode_store = defineStore("geode", {
       }
       return geode_url
     },
-    is_busy(state) {
-      return state.request_counter > 0
+    is_busy() {
+      return this.request_counter > 0
     },
   },
   actions: {
     ping_task() {
-      setInterval(() => this.do_ping(), 10 * 1000)
+      setInterval(() => {
+        if (this.is_running) {
+          this.do_ping()
+        }
+      }, 10 * 1000)
     },
     async do_ping() {
       const feedback_store = use_feedback_store()
-      await api_fetch(
-        { schema: back_schemas.opengeodeweb_back.ping, params: {} },
-        {
-          request_error_function: async () => {
+      return new Promise((resolve, reject) => {
+        useFetch(back_schemas.opengeodeweb_back.ping.$id, {
+          baseURL: this.base_url,
+          method: back_schemas.opengeodeweb_back.ping.methods[0],
+          async onRequestError() {
             await feedback_store.$patch({ server_error: true })
             this.is_running = false
+            reject()
           },
-          response_function: async () => {
-            this.is_running = true
+          async onResponse() {
+            resolve()
           },
-          response_error_function: async () => {
+          async onResponseError() {
             await feedback_store.$patch({ server_error: true })
             this.is_running = false
+            reject()
           },
-        },
-      )
+        })
+      })
     },
     start_request() {
       this.request_counter++

package/stores/infra.js

@@ -43,21 +43,11 @@ export const use_infra_store = defineStore("infra", {
   },
   actions: {
     async create_connexion() {
-      const geode_store = use_geode_store()
       if (this.is_connexion_launched) {
         return
       }
       this.is_connexion_launched = true
-      if (["", null].includes(this.ID) || typeof this.ID === "undefined") {
-        return this.create_backend()
-      } else {
-        try {
-          await geode_store.do_ping()
-          return geode_store.ping_task()
-        } catch (e) {
-          return this.create_backend()
-        }
-      }
+      return this.create_backend()
     },
     async create_backend() {
       const geode_store = use_geode_store()

package/stores/viewer.js

@@ -40,8 +40,8 @@ export const use_viewer_store = defineStore("viewer", {
       viewer_url += "/ws"
       return viewer_url
     },
-    is_busy(state) {
-      return state.request_counter > 0
+    is_busy() {
+      return this.request_counter > 0
     },
   },
   actions: {

package/test/stores/Geode.test.js

@@ -99,20 +99,18 @@ describe("Geode Store", () => {
     describe("do_ping", () => {
       test("request_error", async () => {
         geode_store.base_url = ""
-        geode_store.is_running = true
         try {
           await geode_store.do_ping()
         } catch (e) {
-          console.log(e)
+          console.log("e", e)
         }
-
         expect(geode_store.is_running).toBe(false)
         expect(feedback_store.server_error).toBe(true)
-        expect(feedback_store.feedbacks.length).toBe(1)
       })
 
       test("response", async () => {
         geode_store.base_url = ""
+        geode_store.is_running = true
         registerEndpoint(back_schemas.opengeodeweb_back.ping.$id, {
           method: "POST",
           handler: () => ({}),