@geode/opengeodeweb-front 6.3.0-rc.1 → 7.0.0-rc.1

package/stores/viewer.js

@@ -1,8 +1,36 @@
+import _ from "lodash"
+import vtkWSLinkClient from "@kitware/vtk.js/IO/Core/WSLinkClient"
+import SmartConnect from "wslink/src/SmartConnect"
+import "@kitware/vtk.js/Rendering/OpenGL/Profiles/Geometry"
+import { connectImageStream } from "@kitware/vtk.js/Rendering/Misc/RemoteView"
+import schemas from "@/utils/schemas.json"
+
+vtkWSLinkClient.setSmartConnectClass(SmartConnect)
+
 export const use_viewer_store = defineStore("viewer", {
   state: () => ({
+    client: {},
+    config: null,
+    is_running: false,
     picking_mode: false,
     picked_point: { x: null, y: null },
+    request_counter: 0,
   }),
+  getters: {
+    base_url: () => {
+      const cloud_store = use_cloud_store()
+      const public_runtime_config = useRuntimeConfig().public
+      var viewer_url = `${public_runtime_config.VIEWER_PROTOCOL}://${public_runtime_config.API_URL}:${public_runtime_config.VIEWER_PORT}`
+      if (process.env.NODE_ENV == "production") {
+        viewer_url += `/${cloud_store.ID}/viewer`
+      }
+      viewer_url += "/ws"
+      return viewer_url
+    },
+    is_busy: (state) => {
+      return state.request_counter > 0
+    },
+  },
   actions: {
     toggle_picking_mode(value) {
       this.picking_mode = value
@@ -14,152 +42,70 @@ export const use_viewer_store = defineStore("viewer", {
       this.picked_point.y = world_y
       this.picking_mode = false
     },
+    ws_connect() {
+      if (process.env.NODE_ENV != "test") {
+        const config = { application: "Viewer" }
+        config.sessionURL = this.base_url
 
-    async create_object_pipeline(params) {
-      const websocket_store = use_websocket_store()
-      if (websocket_store.client) {
-        websocket_store.start_request()
-        websocket_store.client
-          .getRemote()
-          .vtk.create_object_pipeline(params)
-          .catch(console.error)
-        websocket_store.stop_request()
-      }
-    },
-    async delete_object_pipeline(params) {
-      const websocket_store = use_websocket_store()
-      if (websocket_store.client) {
-        websocket_store.start_request()
-        websocket_store.client
-          .getRemote()
-          .vtk.delete_object_pipeline(params)
-          .catch(console.error)
-        websocket_store.stop_request()
-      }
-    },
-    async reset_camera() {
-      const websocket_store = use_websocket_store()
-      if (websocket_store.client) {
-        websocket_store.start_request()
-        websocket_store.client
-          .getRemote()
-          .vtk.reset_camera()
-          .catch(console.error)
-        websocket_store.stop_request()
-      }
-    },
-    async toggle_object_visibility(params) {
-      const websocket_store = use_websocket_store()
-      if (websocket_store.client) {
-        websocket_store.start_request()
-        websocket_store.client
-          .getRemote()
-          .vtk.toggle_object_visibility(params)
-          .catch(console.error)
-        websocket_store.stop_request()
-      }
-    },
-    async toggle_edge_visibility(params) {
-      const websocket_store = use_websocket_store()
-      if (websocket_store.client) {
-        websocket_store.start_request()
-        websocket_store.client
-          .getRemote()
-          .vtk.toggle_edge_visibility(params)
-          .catch(console.error)
-        websocket_store.stop_request()
-      }
-    },
-    async toggle_point_visibility(params) {
-      const websocket_store = use_websocket_store()
-      if (websocket_store.client) {
-        websocket_store.start_request()
-        websocket_store.client
-          .getRemote()
-          .vtk.toggle_point_visibility(params)
-          .catch(console.error)
-        websocket_store.stop_request()
-      }
-    },
-    async point_size(params) {
-      const websocket_store = use_websocket_store()
-      if (websocket_store.client) {
-        websocket_store.start_request()
-        websocket_store.client
-          .getRemote()
-          .vtk.point_size(params)
-          .catch(console.error)
-        websocket_store.stop_request()
-      }
-    },
-    async set_color(params) {
-      const websocket_store = use_websocket_store()
-      if (websocket_store.client) {
-        websocket_store.start_request()
-        websocket_store.client
-          .getRemote()
-          .vtk.set_color(params)
-          .catch(console.error)
-        websocket_store.stop_request()
-      }
-    },
-    async set_vertex_attribute(params) {
-      const websocket_store = use_websocket_store()
-      if (websocket_store.client) {
-        websocket_store.start_request()
-        websocket_store.client
-          .getRemote()
-          .vtk.set_vertex_attribute(params)
-          .catch(console.error)
-        websocket_store.stop_request()
-      }
-    },
-    async apply_textures(params) {
-      const websocket_store = use_websocket_store()
-      if (websocket_store.client) {
-        websocket_store.start_request()
-        websocket_store.client
-          .getRemote()
-          .vtk.apply_textures(params)
-          .catch(console.error)
-        websocket_store.stop_request()
-      }
-    },
-    async get_point_position(params) {
-      const websocket_store = use_websocket_store()
-      if (websocket_store.client) {
-        websocket_store.start_request()
-        const response = await websocket_store.client
-          .getRemote()
-          .vtk.get_point_position(params)
-          .catch(console.error)
-        websocket_store.stop_request()
-        return response
+        const { client } = this
+        if (this.is_running && client.isConnected()) {
+          client.disconnect(-1)
+          this.is_running = false
+        }
+        let clientToConnect = client
+        if (_.isEmpty(clientToConnect)) {
+          clientToConnect = vtkWSLinkClient.newInstance()
+        }
+
+        // Connect to busy store
+        clientToConnect.onBusyChange((count) => {
+          this.buzy = count
+        })
+        clientToConnect.beginBusy()
+
+        // Error
+        clientToConnect.onConnectionError((httpReq) => {
+          const message =
+            (httpReq && httpReq.response && httpReq.response.error) ||
+            `Connection error`
+          console.error(message)
+        })
+
+        // Close
+        clientToConnect.onConnectionClose((httpReq) => {
+          const message =
+            (httpReq && httpReq.response && httpReq.response.error) ||
+            `Connection close`
+          console.error(message)
+        })
+
+        // Connect
+        clientToConnect
+          .connect(config)
+          .then((validClient) => {
+            connectImageStream(validClient.getConnection().getSession())
+            this.client = validClient
+            clientToConnect.endBusy()
+
+            // Now that the client is ready let's setup the server for us
+            viewer_call({
+              schema: schemas.opengeodeweb_viewer.create_visualization,
+            })
+            viewer_call({
+              schema: schemas.opengeodeweb_viewer.reset,
+            })
+            this.is_running = true
+          })
+          .catch((error) => {
+            console.error(error)
+          })
       }
     },
-    async update_data(params) {
-      const websocket_store = use_websocket_store()
-      if (websocket_store.client) {
-        websocket_store.start_request()
-        const response = await websocket_store.client
-          .getRemote()
-          .vtk.update_data(params)
-          .catch(console.error)
-        websocket_store.stop_request()
-        return response
-      }
+    start_request() {
+      this.request_counter++
     },
-    async reset() {
-      const websocket_store = use_websocket_store()
-      if (websocket_store.client) {
-        websocket_store.start_request()
-        const response = await websocket_store.client
-          .getRemote()
-          .vtk.reset()
-          .catch(console.error)
-        websocket_store.stop_request()
-        return response
-      }
+    stop_request() {
+      this.request_counter--
     },
   },
 })

package/test/components/CrsSelector.nuxt.test.js

@@ -8,15 +8,16 @@ import * as components from "vuetify/components"
 import * as directives from "vuetify/directives"
 
 import CrsSelector from "@/components/CrsSelector.vue"
-import schema from "@/assets/schemas/CrsSelector.json"
+import schemas from "@geode/opengeodeweb-back/schemas.json"
+
+const crs_selector_schema =
+  schemas.opengeodeweb_back.geographic_coordinate_systems
 
 const vuetify = createVuetify({
   components,
   directives,
 })
 
-global.ResizeObserver = require("resize-observer-polyfill")
-
 describe("CrsSelector.vue", async () => {
   test(`BRep`, async () => {
     const crs_list = [
@@ -26,8 +27,8 @@ describe("CrsSelector.vue", async () => {
         name: "Anguilla 1957 / British West Indies Grid",
       },
     ]
-    registerEndpoint(schema.$id, {
-      method: schema.method,
+    registerEndpoint(crs_selector_schema.$id, {
+      method: crs_selector_schema.methods.filter((m) => m !== "OPTIONS")[0],
       handler: () => ({
         crs_list,
       }),
@@ -40,8 +41,9 @@ describe("CrsSelector.vue", async () => {
       props: { input_geode_object: "BRep", key_to_update },
     })
     const td = await wrapper.find("td")
-    const imput = await td.find("input")
-    await imput.trigger("click")
+    await wrapper.vm.$nextTick()
+    const input = await td.find("input")
+    await input.trigger("click")
     expect(wrapper.emitted()).toHaveProperty("update_values")
     expect(wrapper.emitted().update_values).toHaveLength(1)
     expect(wrapper.emitted().update_values[0][0]).toEqual({

package/test/components/ExtensionSelector.nuxt.test.js

@@ -8,23 +8,24 @@ import * as components from "vuetify/components"
 import * as directives from "vuetify/directives"
 
 import ExtensionSelector from "@/components/ExtensionSelector.vue"
-import schema from "@/assets/schemas/ExtensionSelector.json"
-import { flushPromises } from "@vue/test-utils"
+
+import schemas from "@geode/opengeodeweb-back/schemas.json"
+
+const geode_objects_and_output_extensions =
+  schemas.opengeodeweb_back.geode_objects_and_output_extensions
 
 const vuetify = createVuetify({
   components,
   directives,
 })
 
-global.ResizeObserver = require("resize-observer-polyfill")
-
 describe("ExtensionSelector.vue", async () => {
   test(`Select geode_object & extension`, async () => {
     const output_geode_object = "BRep"
     const output_extension = "msh"
 
-    registerEndpoint(schema.$id, {
-      method: schema.method,
+    registerEndpoint(geode_objects_and_output_extensions.$id, {
+      method: geode_objects_and_output_extensions.methods[0],
       handler: () => ({
         geode_objects_and_output_extensions: {
           BRep: { msh: { is_saveable: true } },

package/test/components/FileSelector.nuxt.test.js

@@ -10,19 +10,21 @@ import * as directives from "vuetify/directives"
 
 import FileSelector from "@/components/FileSelector.vue"
 import FileUploader from "@/components/FileUploader.vue"
-import schema from "@/assets/schemas/FileSelector.json"
+
+import schemas from "@geode/opengeodeweb-back/schemas.json"
+
+const allowed_files_schema = schemas.opengeodeweb_back.allowed_files
+const upload_file_schema = schemas.opengeodeweb_back.upload_file
 
 const vuetify = createVuetify({
   components,
   directives,
 })
 
-global.ResizeObserver = require("resize-observer-polyfill")
-
 describe("FileSelector.vue", async () => {
   test(`Select file`, async () => {
-    registerEndpoint(schema.$id, {
-      method: schema.method,
+    registerEndpoint(allowed_files_schema.$id, {
+      method: allowed_files_schema.methods[0],
       handler: () => ({
         extensions: ["1", "2", "3"],
       }),
@@ -31,13 +33,13 @@ describe("FileSelector.vue", async () => {
       global: {
         plugins: [vuetify],
       },
-      props: { multiple: false, key: "test", route: "/upload" },
+      props: { multiple: false, supported_feature: "test" },
     })
 
     const file_uploader = wrapper.findComponent(FileUploader)
 
-    registerEndpoint("/upload", {
-      method: "PUT",
+    registerEndpoint(upload_file_schema.$id, {
+      method: upload_file_schema.methods[1],
       handler: () => ({}),
     })
 

package/test/components/FileUploader.nuxt.test.js

@@ -10,24 +10,26 @@ import * as directives from "vuetify/directives"
 
 import FileUploader from "@/components/FileUploader.vue"
 
+import schemas from "@geode/opengeodeweb-back/schemas.json"
+
+const upload_file_schema = schemas.opengeodeweb_back.upload_file
+
 const vuetify = createVuetify({
   components,
   directives,
 })
 
-global.ResizeObserver = require("resize-observer-polyfill")
-
 describe("FileUploader.vue", async () => {
   test(`Upload file`, async () => {
-    registerEndpoint("/upload", {
-      method: "PUT",
+    registerEndpoint(upload_file_schema.$id, {
+      method: upload_file_schema.methods[0],
       handler: () => ({}),
     })
     const wrapper = await mountSuspended(FileUploader, {
       global: {
         plugins: [vuetify],
       },
-      props: { multiple: false, accept: "*.txt", route: "/upload" },
+      props: { multiple: false, accept: "*.txt" },
     })
     const v_file_input = wrapper.findComponent(components.VFileInput)
     await v_file_input.trigger("click")
@@ -35,6 +37,12 @@ describe("FileUploader.vue", async () => {
     await v_file_input.setValue(files)
     await v_file_input.trigger("change")
     const v_btn = wrapper.findComponent(components.VBtn)
+
+    registerEndpoint(upload_file_schema.$id, {
+      method: upload_file_schema.methods[1],
+      handler: () => ({}),
+    })
+
     await v_btn.trigger("click")
     await flushPromises()
     expect(wrapper.emitted().files_uploaded[0][0]).toEqual(files)

package/test/components/MissingFilesSelector.nuxt.test.js

@@ -11,19 +11,20 @@ import * as directives from "vuetify/directives"
 import MissingFilesSelector from "@/components/MissingFilesSelector.vue"
 import FileUploader from "@/components/FileUploader.vue"
 
-import schema from "@/assets/schemas/MissingFilesSelector.json"
+import schemas from "@geode/opengeodeweb-back/schemas.json"
+
+const missing_files_schema = schemas.opengeodeweb_back.missing_files
+const upload_file_schema = schemas.opengeodeweb_back.upload_file
 
 const vuetify = createVuetify({
   components,
   directives,
 })
 
-global.ResizeObserver = require("resize-observer-polyfill")
-
 describe("MissingFilesSelector.vue", async () => {
   test(`Select file`, async () => {
-    registerEndpoint(schema.$id, {
-      method: schema.method,
+    registerEndpoint(missing_files_schema.$id, {
+      method: missing_files_schema.methods[0],
       handler: () => ({
         has_missing_files: true,
         mandatory_files: ["fake_file.txt"],
@@ -38,7 +39,6 @@ describe("MissingFilesSelector.vue", async () => {
         multiple: false,
         input_geode_object: "BRep",
         filenames: ["fake_file.txt"],
-        route: "/upload_file",
       },
     })
 
@@ -52,8 +52,8 @@ describe("MissingFilesSelector.vue", async () => {
     await v_file_input.trigger("change")
     const v_btn = file_uploader.findComponent(components.VBtn)
 
-    registerEndpoint("/upload_file", {
-      method: "PUT",
+    registerEndpoint(upload_file_schema.$id, {
+      method: upload_file_schema.methods[1],
       handler: () => ({}),
     })
     await v_btn.trigger("click")

package/test/components/ObjectSelector.nuxt.test.js

@@ -9,17 +9,16 @@ import * as components from "vuetify/components"
 import * as directives from "vuetify/directives"
 
 import ObjectSelector from "@/components/ObjectSelector.vue"
-import schema from "@/assets/schemas/ObjectSelector.json"
-import geode_objects from "@/assets/geode_objects"
+
+import schemas from "@geode/opengeodeweb-back/schemas.json"
+
+const allowed_objects = schemas.opengeodeweb_back.allowed_objects
 
 const vuetify = createVuetify({
   components,
   directives,
 })
 
-global.ResizeObserver = require("resize-observer-polyfill")
-
-// for (const [geode_object] of Object.entries(geode_objects)) {
 const geode_object = "BRep"
 describe("ObjectSelector.vue", async () => {
   test(`BRep`, async () => {
@@ -27,15 +26,15 @@ describe("ObjectSelector.vue", async () => {
       allowed_objects: {},
     }
     response["allowed_objects"][geode_object] = { is_loadable: true }
-    registerEndpoint(schema.$id, {
-      method: schema.method,
+    registerEndpoint(allowed_objects.$id, {
+      method: allowed_objects.methods[0],
       handler: () => response,
     })
     const wrapper = await mountSuspended(ObjectSelector, {
       global: {
         plugins: [vuetify],
       },
-      props: { filenames: ["test.toto"], key: "test" },
+      props: { filenames: ["test.toto"], supported_feature: "test" },
     })
     const v_card = wrapper.findComponent(components.VCard)
     const v_img = v_card.findComponent(components.VImg)

package/test/components/PackagesVersions.nuxt.test.js

@@ -14,19 +14,17 @@ const vuetify = createVuetify({
   directives,
 })
 
-global.ResizeObserver = require("resize-observer-polyfill")
-
 describe("PackagesVersions.vue", async () => {
   test(`Mount`, async () => {
     const schema = {
       $id: "/versions",
-      method: "GET",
+      methods: ["GET"],
       type: "object",
       properties: {},
       additionalProperties: false,
     }
     registerEndpoint(schema.$id, {
-      method: schema.method,
+      method: schema.methods[0],
       handler: () => ({
         versions: [
           {

package/test/composables/api_fetch.nuxt.test.js

@@ -7,7 +7,7 @@ describe("api_fetch.js", () => {
   const schema = {
     $id: "/test",
     type: "object",
-    method: "POST",
+    methods: ["POST"],
     properties: {
       test: {
         type: "string",
@@ -16,16 +16,18 @@ describe("api_fetch.js", () => {
     required: ["test"],
     additionalProperties: false,
   }
+  var params
+
   beforeEach(async () => {
     await errors_store.$patch({ errors: [] })
   })
 
   test("Ajv wrong params", async () => {
     registerEndpoint(schema.$id, {
-      method: schema.method,
+      method: schema.methods[0],
       handler: () => ({ return: "toto" }),
     })
-    const params = {}
+    params = {}
     try {
       await api_fetch({ schema, params })
     } catch (error) {
@@ -37,64 +39,32 @@ describe("api_fetch.js", () => {
     expect(errors_store.errors[0].code).toBe(400)
   })
 
-  // test("onRequestError", async () => {
-  //   const schema = {
-  //     $id: "/test",
-  //     type: "object",
-  //     method: "POST",
-  //     properties: {
-  //       test: {
-  //         type: "string",
-  //       },
-  //     },
-  //     required: ["test"],
-  //     additionalProperties: false,
-  //   }
-  //   registerEndpoint(schema.$id, {
-  //     method: schema.method,
-  //     handler: async () => {
-  //       setTimeout(() => {}, 100 * 1000)
-  //     },
-  //   })
-  //   const params = { test: "test" }
-  //   var request_error_value
-  //   await api_fetch(
-  //     { schema, params },
-  //     {
-  //       request_error_function: () => {
-  //         request_error_value = "error"
-  //       },
-  //     },
-  //   )
-  //   expect(errors_store.errors.length).toBe(1)
-  //   expect(errors_store.errors[0].code).toBe(404)
-  //   expect(request_error_value).toBe("error")
-  // })
-
   test("onResponse", async () => {
-    registerEndpoint(schema.$id, {
-      method: schema.method,
-      handler: () => ({ return: "toto" }),
-    })
-    const params = { test: "test" }
     var response_value
-    await api_fetch(
-      { schema, params },
-      {
-        response_function: (response) => {
-          response_value = response._data.return
+    for (var i = 0; i < 3; i++) {
+      registerEndpoint(schema.$id, {
+        method: schema.methods[0],
+        handler: () => ({ return: "toto" }),
+      })
+      params = { test: "test" }
+      await api_fetch(
+        { schema, params },
+        {
+          response_function: (response) => {
+            response_value = response._data.return
+          },
         },
-      },
-    )
-    expect(errors_store.errors.length).toBe(0)
-    expect(response_value).toBe("toto")
+      )
+      expect(errors_store.errors.length).toBe(0)
+      expect(response_value).toBe("toto")
+    }
   })
 
   test("onResponseError", async () => {
     const schema = {
       $id: "/toto",
       type: "object",
-      method: "POST",
+      methods: ["POST"],
       properties: {
         test: {
           type: "string",
@@ -103,7 +73,7 @@ describe("api_fetch.js", () => {
       required: ["test"],
       additionalProperties: false,
     }
-    const params = { test: "test" }
+    params = { test: "test" }
     var response_error_value
     await api_fetch(
       { schema, params },

package/test/composables/runFunctionIfCloudRunning.nuxt.test.js

@@ -2,19 +2,19 @@ import { describe, expect, test, beforeEach, vi } from "vitest"
 
 describe("api_fetch.js", () => {
   const geode_store = use_geode_store()
-  const websocket_store = use_websocket_store()
+  const viewer_store = use_viewer_store()
 
   const dumb_obj = { dumb_method: () => true }
 
   beforeEach(async () => {
     await geode_store.$patch({ is_running: false })
-    await websocket_store.$patch({ is_running: false })
+    await viewer_store.$patch({ is_running: false })
   })
 
   test("is_running true", async () => {
     const spy = vi.spyOn(dumb_obj, "dumb_method")
     await geode_store.$patch({ is_running: true })
-    await websocket_store.$patch({ is_running: true })
+    await viewer_store.$patch({ is_running: true })
 
     await runFunctionIfCloudRunning(dumb_obj.dumb_method)
     expect(spy).toHaveBeenCalled()
@@ -24,7 +24,7 @@ describe("api_fetch.js", () => {
     const spy = vi.spyOn(dumb_obj, "dumb_method")
     runFunctionIfCloudRunning(dumb_obj.dumb_method)
     await geode_store.$patch({ is_running: true })
-    await websocket_store.$patch({ is_running: true })
+    await viewer_store.$patch({ is_running: true })
     expect(spy).toHaveBeenCalled()
   })
 })