@geode/opengeodeweb-front 10.2.0-rc.1 → 10.2.0

package/app/components/Viewer/EdgedCurve/SpecificEdgesOptions.vue

@@ -0,0 +1,103 @@
+<template>
+  <ViewerContextMenuItem
+    :itemProps="props.itemProps"
+    tooltip="Edges options"
+    :btn_image="EdgedCurveEdges"
+  >
+    <template #options>
+      <ViewerOptionsVisibilitySwitch v-model="visibility" />
+      <template v-if="visibility">
+        <v-row class="pa-0" align="center">
+          <v-divider />
+          <v-col cols="auto" justify="center">
+            <v-icon size="30" icon="mdi-ruler" v-tooltip:left="'Width'" />
+          </v-col>
+          <v-col justify="center">
+            <v-slider
+              v-model="size"
+              hide-details
+              min="0"
+              max="20"
+              step="2"
+              thumb-color="black"
+              ticks
+            />
+          </v-col>
+        </v-row>
+        <v-row>
+          <v-col>
+            <ViewerOptionsColoringTypeSelector
+              :id="id"
+              v-model:coloring_style_key="coloring_style_key"
+              v-model:color="color"
+              v-model:vertex_attribute="vertex_attribute"
+              v-model:edge_attribute="edge_attribute"
+            />
+          </v-col>
+        </v-row>
+      </template>
+    </template>
+  </ViewerContextMenuItem>
+</template>
+
+<script setup>
+  import ViewerContextMenuItem from "@ogw_front/components/Viewer/ContextMenuItem"
+  import ViewerOptionsVisibilitySwitch from "@ogw_front/components/Viewer/Options/VisibilitySwitch"
+  import ViewerOptionsColoringTypeSelector from "@ogw_front/components/Viewer/Options/ColoringTypeSelector"
+  import EdgedCurveEdges from "@ogw_front/assets/viewer_svgs/edged_curve_edges.svg"
+
+  import { useDataStyleStore } from "@ogw_front/stores/data_style"
+  import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer"
+
+  const dataStyleStore = useDataStyleStore()
+  const hybridViewerStore = useHybridViewerStore()
+
+  const props = defineProps({
+    itemProps: { type: Object, required: true },
+  })
+
+  const id = toRef(() => props.itemProps.id)
+
+  const visibility = computed({
+    get: () => dataStyleStore.meshEdgesVisibility(id.value),
+    set: (newValue) => {
+      dataStyleStore.setMeshEdgesVisibility(id.value, newValue)
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const size = computed({
+    get: () => dataStyleStore.meshEdgesWidth(id.value),
+    set: (newValue) => {
+      dataStyleStore.setMeshEdgesWidth(id.value, newValue)
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const coloring_style_key = computed({
+    get: () => dataStyleStore.meshEdgesActiveColoring(id.value),
+    set: (newValue) => {
+      dataStyleStore.setMeshEdgesActiveColoring(id.value, newValue)
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const color = computed({
+    get: () => dataStyleStore.meshEdgesColor(id.value),
+    set: (newValue) => {
+      dataStyleStore.setMeshEdgesColor(id.value, newValue)
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const vertex_attribute = computed({
+    get: () => dataStyleStore.meshEdgesVertexAttribute(id.value),
+    set: (newValue) => {
+      dataStyleStore.setMeshEdgesVertexAttribute(id.value, newValue)
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const edge_attribute = computed({
+    get: () => dataStyleStore.meshEdgesEdgeAttribute(id.value),
+    set: (newValue) => {
+      dataStyleStore.setMeshEdgesEdgeAttribute(id.value, newValue)
+      hybridViewerStore.remoteRender()
+    },
+  })
+</script>

package/app/components/Viewer/Generic/Mesh/EdgesOptions.vue

@@ -7,11 +7,32 @@
     <template #options>
       <ViewerOptionsVisibilitySwitch v-model="visibility" />
       <template v-if="visibility">
-        <ViewerOptionsColoringTypeSelector
-          :id="id"
-          v-model:coloring_style_key="coloring_style_key"
-          v-model:color="color"
-        />
+        <v-row class="pa-0" align="center">
+          <v-divider />
+          <v-col cols="auto" justify="center">
+            <v-icon size="30" icon="mdi-ruler" v-tooltip:left="'Width'" />
+          </v-col>
+          <v-col justify="center">
+            <v-slider
+              v-model="size"
+              hide-details
+              min="0"
+              max="20"
+              step="2"
+              thumb-color="black"
+              ticks
+            />
+          </v-col>
+        </v-row>
+        <v-row>
+          <v-col>
+            <ViewerOptionsColoringTypeSelector
+              :id="id"
+              v-model:coloring_style_key="coloring_style_key"
+              v-model:color="color"
+            />
+          </v-col>
+        </v-row>
       </template>
     </template>
   </ViewerContextMenuItem>
@@ -43,9 +64,9 @@
     },
   })
   const size = computed({
-    get: () => dataStyleStore.edgesSize(id.value),
+    get: () => dataStyleStore.meshEdgesWidth(id.value),
     set: (newValue) => {
-      dataStyleStore.setEdgesSize(id.value, newValue)
+      dataStyleStore.setMeshEdgesWidth(id.value, newValue)
       hybridViewerStore.remoteRender()
     },
   })
@@ -63,4 +84,11 @@
       hybridViewerStore.remoteRender()
     },
   })
+  const vertex_attribute = computed({
+    get: () => dataStyleStore.meshEdgesVertexAttribute(id.value),
+    set: (newValue) => {
+      dataStyleStore.setMeshEdgesVertexAttribute(id.value, newValue)
+      hybridViewerStore.remoteRender()
+    },
+  })
 </script>

package/app/components/Viewer/Generic/Mesh/PointsOptions.vue

@@ -30,6 +30,7 @@
               :id="id"
               v-model:coloring_style_key="coloring_style_key"
               v-model:color="color"
+              v-model:vertex_attribute="vertex_attribute"
             />
           </v-col>
         </v-row>
@@ -84,11 +85,4 @@
       hybridViewerStore.remoteRender()
     },
   })
-  const vertex_attribute = computed({
-    get: () => dataStyleStore.meshPointsVertexAttribute(id.value),
-    set: (newValue) => {
-      dataStyleStore.setMeshPointsVertexAttribute(id.value, newValue)
-      hybridViewerStore.remoteRender()
-    },
-  })
 </script>

package/app/components/Viewer/Generic/Mesh/PolygonsOptions.vue

@@ -12,8 +12,6 @@
           v-model:coloring_style_key="coloring_style_key"
           v-model:color="color"
           v-model:textures="textures"
-          v-model:vertex_attribute="vertex_attribute"
-          v-model:polygon_attribute="polygon_attribute"
         />
       </template>
     </template>
@@ -34,6 +32,7 @@
   const props = defineProps({
     itemProps: { type: Object, required: true },
     btn_image: { type: String, required: true },
+
     tooltip: { type: String, required: false, default: "Polygons options" },
   })
 
@@ -67,18 +66,4 @@
       hybridViewerStore.remoteRender()
     },
   })
-  const vertex_attribute = computed({
-    get: () => dataStyleStore.meshPolygonsVertexAttribute(id.value),
-    set: (newValue) => {
-      dataStyleStore.setMeshPolygonsVertexAttribute(id.value, newValue)
-      hybridViewerStore.remoteRender()
-    },
-  })
-  const polygon_attribute = computed({
-    get: () => dataStyleStore.meshPolygonsPolygonAttribute(id.value),
-    set: (newValue) => {
-      dataStyleStore.setMeshPolygonsPolygonAttribute(id.value, newValue)
-      hybridViewerStore.remoteRender()
-    },
-  })
 </script>

package/app/components/Viewer/Generic/Mesh/PolyhedraOptions.vue

@@ -6,14 +6,11 @@
   >
     <template #options>
       <ViewerOptionsVisibilitySwitch v-model="visibility" />
-
       <template v-if="visibility">
         <ViewerOptionsColoringTypeSelector
           :id="id"
           v-model:coloring_style_key="coloring_style_key"
           v-model:color="color"
-          v-model:vertex_attribute="vertex_attribute"
-          v-model:polyhedron_attribute="polyhedron_attribute"
         />
       </template>
     </template>
@@ -60,18 +57,4 @@
       hybridViewerStore.remoteRender()
     },
   })
-  const vertex_attribute = computed({
-    get: () => dataStyleStore.polyhedraVertexAttribute(id.value),
-    set: (newValue) => {
-      dataStyleStore.setPolyhedraVertexAttribute(id.value, newValue)
-      hybridViewerStore.remoteRender()
-    },
-  })
-  const polyhedron_attribute = computed({
-    get: () => dataStyleStore.polyhedraPolyhedronAttribute(id.value),
-    set: (newValue) => {
-      dataStyleStore.setPolyhedraPolyhedronAttribute(id.value, newValue)
-      hybridViewerStore.remoteRender()
-    },
-  })
 </script>

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

@@ -34,9 +34,12 @@
               :id="id"
             />
           </template>
-          <!-- <template v-if="coloring_style_key === edge_dict['value']">
-            <ViewerOptionsEdgeAttributeSelector v-model="edge_attribute" :id="id" />
-          </template> -->
+          <template v-if="coloring_style_key === edge_dict['value']">
+            <ViewerOptionsEdgeAttributeSelector
+              v-model="edge_attribute"
+              :id="id"
+            />
+          </template>
           <template v-if="coloring_style_key === cell_dict['value']">
             <ViewerOptionsCellAttributeSelector
               v-model="cell_attribute"
@@ -65,7 +68,7 @@
   import ViewerOptionsColorPicker from "@ogw_front/components/Viewer/Options/ColorPicker"
   import ViewerOptionsTexturesSelector from "@ogw_front/components/Viewer/Options/TexturesSelector"
   import ViewerOptionsVertexAttributeSelector from "@ogw_front/components/Viewer/Options/VertexAttributeSelector"
-  // import ViewerOptionsEdgeAttributeSelector from "@ogw_front/components/Viewer/Options/EdgeAttributeSelector"
+  import ViewerOptionsEdgeAttributeSelector from "@ogw_front/components/Viewer/Options/EdgeAttributeSelector"
   import ViewerOptionsPolygonAttributeSelector from "@ogw_front/components/Viewer/Options/PolygonAttributeSelector"
   import ViewerOptionsCellAttributeSelector from "@ogw_front/components/Viewer/Options/CellAttributeSelector"
   import ViewerOptionsPolyhedronAttributeSelector from "@ogw_front/components/Viewer/Options/PolyhedronAttributeSelector"
@@ -75,7 +78,7 @@
   const color = defineModel("color")
   const textures = defineModel("textures")
   const vertex_attribute = defineModel("vertex_attribute")
-  // const edge_attribute = defineModel("edge_attribute");
+  const edge_attribute = defineModel("edge_attribute")
   const cell_attribute = defineModel("cell_attribute")
   const polygon_attribute = defineModel("polygon_attribute")
   const polyhedron_attribute = defineModel("polyhedron_attribute")
@@ -91,7 +94,9 @@
   const has_vertex = computed(() =>
     vertex_attribute.value !== undefined ? true : false,
   )
-  // const has_edge = computed(() => (edge_attribute.value !== undefined ? true : false));
+  const has_edge = computed(() =>
+    edge_attribute.value !== undefined ? true : false,
+  )
   const has_cells = computed(() =>
     cell_attribute.value !== undefined ? true : false,
   )
@@ -105,7 +110,7 @@
   const color_dict = { name: "Color", value: "color" }
   const textures_dict = { name: "Textures", value: "textures" }
   const vertex_dict = { name: "Vertex attribute", value: "vertex" }
-  // const edge_dict = { name: "Edge attribute", value: "edge" }
+  const edge_dict = { name: "Edge attribute", value: "edge" }
   const cell_dict = { name: "Cell attribute", value: "cell" }
   const polygon_dict = { name: "Polygon attribute", value: "polygon" }
   const polyhedron_dict = {
@@ -117,7 +122,7 @@
     if (has_color.value) array.push(color_dict)
     if (has_textures.value) array.push(textures_dict)
     if (has_vertex.value) array.push(vertex_dict)
-    // if (has_edges.value) array.push(edge_dict);
+    if (has_edge.value) array.push(edge_dict)
     if (has_cells.value) array.push(cell_dict)
     if (has_polygons.value) array.push(polygon_dict)
     if (has_polyhedra.value) array.push(polyhedron_dict)

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

@@ -0,0 +1,72 @@
+<template>
+  <v-row justify="center" align="center">
+    <v-col cols="auto">
+      <v-icon
+        size="30"
+        icon="mdi-ray-end-arrow"
+        v-tooltip:left="'Edge Attribute'"
+      />
+    </v-col>
+    <v-col>
+      <v-select
+        v-model="edge_attribute_name"
+        :items="edge_attribute_names"
+        label="Select an edge attribute"
+        density="compact"
+        hide-details
+      />
+    </v-col>
+  </v-row>
+</template>
+
+<script setup>
+  import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
+  import { useGeodeStore } from "@ogw_front/stores/geode"
+
+  const geodeStore = useGeodeStore()
+
+  const model = defineModel()
+
+  const props = defineProps({
+    id: { type: String, required: true },
+  })
+
+  const edge_attribute_name = ref("")
+  const edge_attribute_names = ref([])
+
+  onMounted(() => {
+    if (model.value != null) {
+      edge_attribute_name.value = model.value.name
+    }
+  })
+
+  const edge_attribute = reactive({ name: edge_attribute_name.value })
+
+  watch(edge_attribute_name, (value) => {
+    edge_attribute.name = value
+    model.value = edge_attribute
+  })
+
+  function get_edge_attribute_names() {
+    geodeStore.request(
+      back_schemas.opengeodeweb_back.edge_attribute_names,
+      { id: props.id },
+      {
+        response_function: (response) => {
+          edge_attribute_names.value = response.edge_attribute_names
+        },
+      },
+    )
+  }
+
+  onMounted(() => {
+    get_edge_attribute_names()
+  })
+
+  watch(
+    () => props.id,
+    () => {
+      get_edge_attribute_names()
+    },
+  )
+</script>

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

@@ -9,6 +9,9 @@
 
 <script setup>
   import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
+  import { useGeodeStore } from "@ogw_front/stores/geode"
+
+  const geodeStore = useGeodeStore()
 
   const model = defineModel()
 

package/app/components/Viewer/PointSet/SpecificPointsOptions.vue

@@ -2,7 +2,7 @@
   <ViewerContextMenuItem
     :itemProps="props.itemProps"
     tooltip="Points options"
-    :btn_image="props.btn_image"
+    :btn_image="PointSetPoints"
   >
     <template #options>
       <ViewerOptionsVisibilitySwitch v-model="visibility" />
@@ -43,6 +43,7 @@
   import ViewerContextMenuItem from "@ogw_front/components/Viewer/ContextMenuItem"
   import ViewerOptionsVisibilitySwitch from "@ogw_front/components/Viewer/Options/VisibilitySwitch"
   import ViewerOptionsColoringTypeSelector from "@ogw_front/components/Viewer/Options/ColoringTypeSelector"
+  import PointSetPoints from "@ogw_front/assets/viewer_svgs/point_set_points.svg"
 
   import { useDataStyleStore } from "@ogw_front/stores/data_style"
   import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer"
@@ -52,7 +53,6 @@
 
   const props = defineProps({
     itemProps: { type: Object, required: true },
-    btn_image: { type: String, required: true },
   })
 
   const id = toRef(() => props.itemProps.id)

package/app/components/Viewer/PolygonalSurface/SpecificPolygonsOptions.vue

@@ -0,0 +1,84 @@
+<template>
+  <ViewerContextMenuItem
+    :itemProps="props.itemProps"
+    :tooltip="props.tooltip"
+    :btn_image="PolygonalSurfacePolygons"
+  >
+    <template #options>
+      <ViewerOptionsVisibilitySwitch v-model="visibility" />
+      <template v-if="visibility">
+        <ViewerOptionsColoringTypeSelector
+          :id="id"
+          v-model:coloring_style_key="coloring_style_key"
+          v-model:color="color"
+          v-model:textures="textures"
+          v-model:vertex_attribute="vertex_attribute"
+          v-model:polygon_attribute="polygon_attribute"
+        />
+      </template>
+    </template>
+  </ViewerContextMenuItem>
+</template>
+
+<script setup>
+  import ViewerContextMenuItem from "@ogw_front/components/Viewer/ContextMenuItem"
+  import ViewerOptionsVisibilitySwitch from "@ogw_front/components/Viewer/Options/VisibilitySwitch"
+  import ViewerOptionsColoringTypeSelector from "@ogw_front/components/Viewer/Options/ColoringTypeSelector"
+  import PolygonalSurfacePolygons from "@ogw_front/assets/viewer_svgs/surface_triangles.svg"
+
+  import { useDataStyleStore } from "@ogw_front/stores/data_style"
+  import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer"
+
+  const dataStyleStore = useDataStyleStore()
+  const hybridViewerStore = useHybridViewerStore()
+
+  const props = defineProps({
+    itemProps: { type: Object, required: true },
+    tooltip: { type: String, required: false, default: "Polygons options" },
+  })
+
+  const id = toRef(() => props.itemProps.id)
+
+  const visibility = computed({
+    get: () => dataStyleStore.meshPolygonsVisibility(id.value),
+    set: (newValue) => {
+      dataStyleStore.setMeshPolygonsVisibility(id.value, newValue)
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const coloring_style_key = computed({
+    get: () => dataStyleStore.meshPolygonsActiveColoring(id.value),
+    set: (newValue) => {
+      dataStyleStore.setMeshPolygonsActiveColoring(id.value, newValue)
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const color = computed({
+    get: () => dataStyleStore.meshPolygonsColor(id.value),
+    set: (newValue) => {
+      dataStyleStore.setMeshPolygonsColor(id.value, newValue)
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const textures = computed({
+    get: () => dataStyleStore.meshPolygonsTextures(id.value),
+    set: (newValue) => {
+      dataStyleStore.setMeshPolygonsTextures(id.value, newValue)
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const vertex_attribute = computed({
+    get: () => dataStyleStore.meshPolygonsVertexAttribute(id.value),
+    set: (newValue) => {
+      dataStyleStore.setMeshPolygonsVertexAttribute(id.value, newValue)
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const polygon_attribute = computed({
+    get: () => dataStyleStore.meshPolygonsPolygonAttribute(id.value),
+    set: (newValue) => {
+      dataStyleStore.setMeshPolygonsPolygonAttribute(id.value, newValue)
+      hybridViewerStore.remoteRender()
+    },
+  })
+</script>

package/app/components/Viewer/Solid/SpecificPolyhedraOptions.vue

@@ -0,0 +1,76 @@
+<template>
+  <ViewerContextMenuItem
+    :itemProps="props.itemProps"
+    :tooltip="props.tooltip"
+    :btn_image="SolidPolyhedra"
+  >
+    <template #options>
+      <ViewerOptionsVisibilitySwitch v-model="visibility" />
+      <template v-if="visibility">
+        <ViewerOptionsColoringTypeSelector
+          :id="id"
+          v-model:coloring_style_key="coloring_style_key"
+          v-model:color="color"
+          v-model:vertex_attribute="vertex_attribute"
+          v-model:polyhedron_attribute="polyhedron_attribute"
+        />
+      </template>
+    </template>
+  </ViewerContextMenuItem>
+</template>
+
+<script setup>
+  import ViewerContextMenuItem from "@ogw_front/components/Viewer/ContextMenuItem"
+  import ViewerOptionsVisibilitySwitch from "@ogw_front/components/Viewer/Options/VisibilitySwitch"
+  import ViewerOptionsColoringTypeSelector from "@ogw_front/components/Viewer/Options/ColoringTypeSelector"
+  import SolidPolyhedra from "@ogw_front/assets/viewer_svgs/solid_polyhedra.svg"
+
+  import { useDataStyleStore } from "@ogw_front/stores/data_style"
+  import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer"
+
+  const dataStyleStore = useDataStyleStore()
+  const hybridViewerStore = useHybridViewerStore()
+
+  const props = defineProps({
+    itemProps: { type: Object, required: true },
+    tooltip: { type: String, required: false, default: "Polyhedra options" },
+  })
+
+  const id = toRef(() => props.itemProps.id)
+
+  const visibility = computed({
+    get: () => dataStyleStore.meshPolyhedraVisibility(id.value),
+    set: (newValue) => {
+      dataStyleStore.setMeshPolyhedraVisibility(id.value, newValue)
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const coloring_style_key = computed({
+    get: () => dataStyleStore.meshPolyhedraActiveColoring(id.value),
+    set: (newValue) => {
+      dataStyleStore.setMeshPolyhedraActiveColoring(id.value, newValue)
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const color = computed({
+    get: () => dataStyleStore.meshPolyhedraColor(id.value),
+    set: (newValue) => {
+      dataStyleStore.setMeshPolyhedraColor(id.value, newValue)
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const vertex_attribute = computed({
+    get: () => dataStyleStore.polyhedraVertexAttribute(id.value),
+    set: (newValue) => {
+      dataStyleStore.setPolyhedraVertexAttribute(id.value, newValue)
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const polyhedron_attribute = computed({
+    get: () => dataStyleStore.polyhedraPolyhedronAttribute(id.value),
+    set: (newValue) => {
+      dataStyleStore.setPolyhedraPolyhedronAttribute(id.value, newValue)
+      hybridViewerStore.remoteRender()
+    },
+  })
+</script>

package/app/components/Viewer/TriangulatedSurface/TrianglesOptions.vue

@@ -1,14 +1,14 @@
 <template>
-  <ViewerGenericMeshPolygonsOptions
+  <ViewerSpecificPolygonsOptions
     :itemProps="props.itemProps"
-    :btn_image="TriangulatedSurfaceEdgesTriangles"
+    :btn_image="TriangulatedSurfaceTriangles"
     tooltip="Triangles options"
   />
 </template>
 
 <script setup>
-  import ViewerGenericMeshPolygonsOptions from "@ogw_front/components/Viewer/Generic/Mesh/PolygonsOptions"
-  import TriangulatedSurfaceEdgesTriangles from "@ogw_front/assets/viewer_svgs/surface_triangles.svg"
+  import ViewerSpecificPolygonsOptions from "@ogw_front/components/Viewer/PolygonalSurface/SpecificPolygonsOptions"
+  import TriangulatedSurfaceTriangles from "@ogw_front/assets/viewer_svgs/surface_triangles.svg"
 
   const props = defineProps({
     itemProps: { type: Object, required: true },

package/app/stores/geode.js

@@ -44,36 +44,33 @@ export const useGeodeStore = defineStore("geode", {
     },
   },
   actions: {
-    ping_task() {
+    set_ping() {
+      this.ping()
       setInterval(() => {
-        this.do_ping()
+        this.ping()
       }, 10 * 1000)
     },
-    do_ping() {
+    ping() {
       const geodeStore = this
       const feedbackStore = useFeedbackStore()
-      return $fetch(back_schemas.opengeodeweb_back.ping.$id, {
-        baseURL: this.base_url,
-        method: back_schemas.opengeodeweb_back.ping.methods[0],
-        body: {},
-        onResponse({ response }) {
-          if (response.ok) {
+      return this.request(
+        back_schemas.opengeodeweb_back.ping,
+        {},
+        {
+          request_error_function: () => {
+            feedbackStore.$patch({ server_error: true })
+            geodeStore.status = Status.NOT_CONNECTED
+          },
+          response_function: () => {
             feedbackStore.$patch({ server_error: false })
             geodeStore.status = Status.CONNECTED
-          }
-        },
-        onResponseError({ response }) {
-          feedbackStore.$patch({ server_error: true })
-          geodeStore.status = Status.NOT_CONNECTED
-        },
-        onRequestError({ error }) {
-          feedbackStore.$patch({ server_error: true })
-          geodeStore.status = Status.NOT_CONNECTED
+          },
+          response_error_function: () => {
+            feedbackStore.$patch({ server_error: true })
+            geodeStore.status = Status.NOT_CONNECTED
+          },
         },
-      })
-    },
-    ping() {
-      return this.do_ping()
+      )
     },
     start_request() {
       this.request_counter++
@@ -87,7 +84,8 @@ export const useGeodeStore = defineStore("geode", {
     },
     connect() {
       console.log("[GEODE] Connecting to geode microservice...")
-      return this.ping_task()
+      this.set_ping()
+      return Promise.resolve()
     },
     request(schema, params, callbacks = {}) {
       console.log("[GEODE] Request:", schema.$id)