remove logs

Author: JulienChampagnol

composables/api_fetch.js

@@ -29,9 +29,8 @@ export function api_fetch(
   if (schema.max_retry) {
     request_options.max_retry = schema.max_retry
   }
-
   return new Promise((resolve, reject) => {
-    return useFetch(schema.$id, {
+    useFetch(schema.$id, {
       baseURL: geode_store.base_url,
       ...request_options,
       async onRequestError({ error }) {

stores/feedback.js

@@ -23,9 +23,7 @@ export const use_feedback_store = defineStore("feedback", {
       await this.feedbacks.splice(feedback_index, 1)
     },
     async delete_server_error() {
-      console.group("delete_server_error")
-      this.$patch({ server_error: false })
-      // this.server_error = false
+      this.server_error = false
     },
   },
 })

stores/geode.js

@@ -45,37 +45,19 @@ export const use_geode_store = defineStore("geode", {
       await api_fetch(
         { schema: back_schemas.opengeodeweb_back.ping, params: {} },
         {
-          request_error_function: () => {
-            feedback_store.$patch({ server_error: true })
+          request_error_function: async () => {
+            await feedback_store.$patch({ server_error: true })
+            this.is_running = false
           },
-          response_function: () => {
+          response_function: async () => {
             this.is_running = true
           },
-          response_error_function: () => {
-            feedback_store.$patch({ server_error: true })
+          response_error_function: async () => {
+            await feedback_store.$patch({ server_error: true })
+            this.is_running = false
           },
         },
       )
-      // return new Promise((resolve, reject) => {
-      //   useFetch(schemas.opengeodeweb_back.ping, {
-      //     baseURL: this.base_url,
-      //     method: "POST",
-      //     onRequestError({ error }) {
-      //       feedback_store.$patch({ server_error: true })
-      //       reject(error)
-      //     },
-      //     onResponse({ response }) {
-      //       if (response.ok) {
-      //         this.is_running = true
-      //         resolve(response)
-      //       }
-      //     },
-      //     onResponseError({ response }) {
-      //       feedback_store.$patch({ server_error: true })
-      //       reject(response)
-      //     },
-      //   })
-      // })
     },
     start_request() {
       this.request_counter++

stores/infra.js

@@ -11,13 +11,27 @@ export const use_infra_store = defineStore("infra", {
     is_cloud() {
       return !isElectron() && !process.env.NODE_ENV === "development"
     },
-    domain_name() {
-      if (this.is_cloud) {
+    domain_name(state) {
+      if (state.is_cloud) {
         return useRuntimeConfig().public.API_URL
       } else {
         return "localhost"
       }
     },
+    lambda_url(state) {
+      const geode_store = use_geode_store()
+      const public_runtime_config = useRuntimeConfig().public
+      const url =
+        geode_store.protocol +
+        "://" +
+        state.domain_name +
+        ":" +
+        geode_store.port +
+        public_runtime_config.SITE_BRANCH +
+        public_runtime_config.PROJECT +
+        "/createbackend"
+      return url
+    },
     is_running() {
       return use_geode_store().is_running && use_viewer_store().is_running
     },
@@ -32,21 +46,14 @@ export const use_infra_store = defineStore("infra", {
         return
       }
       this.is_connexion_launched = true
-      if (
-        this.ID === "" ||
-        this.ID === null ||
-        typeof this.ID === "undefined"
-      ) {
+      if (["", null].includes(this.ID) || typeof this.ID === "undefined") {
         return this.create_backend()
       } else {
-        const { data, error } = await useFetch(`${geode_store.base_url}/`, {
-          method: "POST",
-        })
-        if (data.value !== null) {
-          geode_store.is_running = true
+        try {
+          await geode_store.do_ping()
           return geode_store.ping_task()
-        } else {
-          await this.create_backend()
+        } catch (e) {
+          return this.create_backend()
         }
       }
     },
@@ -56,17 +63,15 @@ export const use_infra_store = defineStore("infra", {
       const feedback_store = use_feedback_store()
 
       if (isElectron()) {
-        await window.electronAPI.run_back(geode_store.PORT)
-        await window.electronAPI.run_viewer(viewer_store.PORT)
+        const back_port = await window.electronAPI.run_back(geode_store.port)
+        geode_store.$patch({ default_local_port: back_port })
+        const viewer_port = await window.electronAPI.run_viewer(
+          viewer_store.port,
+        )
+        viewer_store.$patch({ default_local_port: viewer_port })
         return
       } else {
-        const public_runtime_config = useRuntimeConfig().public
-        const url = this.api_url.concat(
-          public_runtime_config.SITE_BRANCH,
-          public_runtime_config.PROJECT,
-          "/createbackend",
-        )
-        const { data, error } = await useFetch(url, {
+        const { data, error } = await useFetch(this.lambda_url, {
           method: "POST",
         })
         if (data.value !== null) {