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

package/components/CrsSelector.vue

@@ -24,7 +24,9 @@
 </template>
 
 <script setup>
-  import schema from "@/assets/schemas/CrsSelector.json"
+  import schemas from "@geode/opengeodeweb-back/schemas.json"
+  const schema = schemas.opengeodeweb_back.geographic_coordinate_systems
+
   const emit = defineEmits([
     "update_values",
     "increment_step",
@@ -64,11 +66,13 @@
   async function get_crs_table() {
     const params = { input_geode_object }
     toggle_loading()
+    console.log("get_crs_table")
     await api_fetch(
       { schema, params },
       {
         response_function: (response) => {
           crs_list.value = response._data.crs_list
+          console.log("crs_list", response._data.crs_list)
         },
       },
     )

package/components/ExtensionSelector.vue

@@ -59,8 +59,8 @@
 </template>
 
 <script setup>
-  import schema from "@/assets/schemas/ExtensionSelector.json"
-
+  import schemas from "@geode/opengeodeweb-back/schemas.json"
+  const schema = schemas.opengeodeweb_back.geode_objects_and_output_extensions
   const emit = defineEmits([
     "update_values",
     "increment_step",

package/components/FileSelector.vue

@@ -2,14 +2,15 @@
   <FetchingData v-if="loading" />
   <FileUploader
     v-else
-    v-bind="{ multiple, accept, route }"
+    v-bind="{ multiple, accept }"
     @files_uploaded="files_uploaded_event"
   />
 </template>
 
 <script setup>
-  import schema from "@/assets/schemas/FileSelector.json"
+  import schemas from "@geode/opengeodeweb-back/schemas.json"
 
+  const schema = schemas.opengeodeweb_back.allowed_files
   const emit = defineEmits([
     "update_values",
     "increment_step",
@@ -19,10 +20,9 @@
   const props = defineProps({
     multiple: { type: Boolean, required: true },
     key: { type: String, required: false, default: "" },
-    route: { type: String, required: false, default: "" },
   })
 
-  const { multiple, key, route } = props
+  const { multiple, key } = props
 
   const accept = ref("")
   const loading = ref(false)

package/components/FileUploader.vue

@@ -30,14 +30,16 @@
 </template>
 
 <script setup>
+  import schemas from "@geode/opengeodeweb-back/schemas.json"
+  const schema = schemas.opengeodeweb_back.upload_file
+
   const emit = defineEmits(["files_uploaded", "decrement_step"])
 
   const props = defineProps({
     multiple: { type: Boolean, required: true },
     accept: { type: String, required: true },
-    route: { type: String, required: true },
   })
-  const { multiple, accept, route } = toRefs(props)
+  const { multiple, accept } = toRefs(props)
 
   const label = multiple ? "Please select file(s)" : "Please select a file"
   const files = ref([])
@@ -52,7 +54,7 @@
     for (const file of files.value) {
       const promise = new Promise((resolve, reject) => {
         upload_file(
-          { route, file },
+          { route: schema.$id, file },
           {
             request_error_function: () => {
               reject()

package/components/MissingFilesSelector.vue

@@ -26,7 +26,7 @@
     <v-row>
       <v-col cols="12">
         <FileUploader
-          v-bind="{ multiple, accept, route }"
+          v-bind="{ multiple, accept }"
           @files_uploaded="files_uploaded_event"
         />
       </v-col>
@@ -43,7 +43,9 @@
 </template>
 
 <script setup>
-  import schema from "@/assets/schemas/MissingFilesSelector.json"
+  import schemas from "@geode/opengeodeweb-back/schemas.json"
+
+  const schema = schemas.opengeodeweb_back.missing_files
 
   const emit = defineEmits([
     "update_values",
@@ -55,10 +57,9 @@
     multiple: { type: Boolean, required: true },
     input_geode_object: { type: String, required: true },
     filenames: { type: Array, required: true },
-    route: { type: String, required: true },
   })
 
-  const { multiple, input_geode_object, filenames, route } = props
+  const { multiple, input_geode_object, filenames } = props
 
   const accept = ref("")
   const loading = ref(false)
@@ -68,6 +69,7 @@
   const toggle_loading = useToggle(loading)
 
   function files_uploaded_event(value) {
+    console.log("update_values")
     emit("update_values", { additional_files: value })
     missing_files()
   }

package/components/ObjectSelector.vue

@@ -50,7 +50,9 @@
 
 <script setup>
   import geode_objects from "@/assets/geode_objects"
-  import schema from "@/assets/schemas/ObjectSelector.json"
+  import schemas from "@geode/opengeodeweb-back/schemas.json"
+
+  const schema = schemas.opengeodeweb_back.allowed_objects
 
   const emit = defineEmits(["update_values", "increment_step"])
 

package/composables/api_fetch.js

@@ -12,7 +12,8 @@ export function api_fetch(
 
   const ajv = new Ajv()
 
-  ajv.addKeyword("method")
+  ajv.addKeyword("methods")
+  ajv.addKeyword("route")
   ajv.addKeyword("max_retry")
   const valid = ajv.validate(schema, body)
   if (!valid) {
@@ -25,8 +26,10 @@ export function api_fetch(
     throw new Error(schema.$id.concat(": ", ajv.errorsText()))
   }
   geode_store.start_request()
-
-  const request_options = { method: schema["method"] }
+  const method = schema.methods.filter((m) => m !== "OPTIONS")[0]
+  const request_options = {
+    method: method,
+  }
   if (!_.isEmpty(body)) {
     request_options.body = body
   }

package/package.json

@@ -33,9 +33,10 @@
   },
   "description": "OpenSource Vue/Vuetify framework for web applications",
   "type": "module",
-  "version": "6.3.0-rc.1",
+  "version": "6.3.0",
   "main": "./nuxt.config.js",
   "dependencies": {
+    "@geode/opengeodeweb-back": "3.3.2",
     "@kitware/vtk.js": "^29.4.6",
     "@mdi/font": "^7.4.47",
     "@pinia/nuxt": "^0.5.1",
@@ -44,7 +45,6 @@
     "@vueuse/core": "^10.7.2",
     "@vueuse/nuxt": "^10.7.2",
     "ajv": "^8.12.0",
-    "lodash": "^4.17.21",
     "pinia": "^2.1.7",
     "sass": "^1.70.0",
     "semver": "^7.5.4",

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,10 @@ 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")
+    console.log("toto", 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"],
       }),
@@ -36,8 +38,8 @@ describe("FileSelector.vue", async () => {
 
     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,17 +10,19 @@ 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, {
@@ -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,8 +26,8 @@ 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, {

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/assets/schemas/CrsSelector.json

@@ -1,12 +0,0 @@
-{
-  "$id": "/tools/geographic_coordinate_systems",
-  "type": "object",
-  "method": "POST",
-  "properties": {
-    "input_geode_object": {
-      "type": "string"
-    }
-  },
-  "required": ["input_geode_object"],
-  "additionalProperties": false
-}

package/assets/schemas/ExtensionSelector.json

@@ -1,15 +0,0 @@
-{
-  "$id": "/tools/geode_objects_and_output_extensions",
-  "type": "object",
-  "method": "POST",
-  "properties": {
-    "input_geode_object": {
-      "type": "string"
-    },
-    "filename": {
-      "type": "string"
-    }
-  },
-  "required": ["input_geode_object", "filename"],
-  "additionalProperties": false
-}

package/assets/schemas/FileSelector.json

@@ -1,12 +0,0 @@
-{
-  "$id": "/tools/allowed_files",
-  "type": "object",
-  "method": "POST",
-  "properties": {
-    "key": {
-      "type": ["string", "null"]
-    }
-  },
-  "required": ["key"],
-  "additionalProperties": false
-}

package/assets/schemas/MissingFilesSelector.json

@@ -1,15 +0,0 @@
-{
-  "$id": "/tools/missing_files",
-  "type": "object",
-  "method": "POST",
-  "properties": {
-    "input_geode_object": {
-      "type": "string"
-    },
-    "filename": {
-      "type": "string"
-    }
-  },
-  "required": ["input_geode_object", "filename"],
-  "additionalProperties": false
-}

package/assets/schemas/ObjectSelector.json

@@ -1,15 +0,0 @@
-{
-  "$id": "/tools/allowed_objects",
-  "type": "object",
-  "method": "POST",
-  "properties": {
-    "filename": {
-      "type": "string"
-    },
-    "key": {
-      "type": ["string", "null"]
-    }
-  },
-  "required": ["filename", "key"],
-  "additionalProperties": false
-}