Merge pull request #62 from Geode-solutions/feat/is_saveable

JulienChampagnol · web-flow · commit 15d2217f336f · 2023-12-11T15:31:15.000+01:00
Feat/is saveable
diff --git a/assets/schemas/ExtensionSelector.json b/assets/schemas/ExtensionSelector.json
@@ -5,8 +5,11 @@
   "properties": {
     "input_geode_object": {
       "type": "string"
+    },
+    "filename": {
+      "type": "string"
     }
   },
-  "required": ["input_geode_object"],
+  "required": ["input_geode_object", "filename"],
   "additionalProperties": false
 }
diff --git a/components/ExtensionSelector.vue b/components/ExtensionSelector.vue
@@ -1,42 +1,46 @@
 <template>
   <FetchingData v-if="loading" />
   <v-row
-    v-for="item in geode_objects_and_output_extensions"
-    :key="item.geode_object"
+    v-for="(
+      output_extensions, output_geode_object
+    ) in geode_objects_and_output_extensions"
+    :key="output_geode_object"
     class="justify-left"
   >
     <v-card class="card ma-2 pa-2" width="100%">
-      <v-tooltip :text="`Export as a ${item.geode_object}`" location="bottom">
+      <v-tooltip :text="`Export as a ${output_geode_object}`" location="bottom">
         <template v-slot:activator="{ props }">
           <v-card-title v-bind="props">
-            {{ item.geode_object }}
+            {{ output_geode_object }}
           </v-card-title>
         </template>
       </v-tooltip>
       <v-card-text>
         <v-row>
           <v-col
-            v-for="output in item.outputs"
-            :key="output.extension"
+            v-for="(extension, output_extension) in output_extensions"
+            :key="output_extension"
             cols="auto"
             class="pa-0"
           >
             <v-tooltip
-              :disabled="output.is_saveable"
+              :disabled="extension.is_saveable"
               text="Data not saveable with this file extension"
               location="bottom"
             >
               <template v-slot:activator="{ props }">
                 <span v-bind="props">
                   <v-card
                     class="card ma-2"
-                    :color="output.is_saveable ? 'primary' : 'grey'"
+                    :color="extension.is_saveable ? 'primary' : 'grey'"
                     hover
-                    @click="set_variables(item.geode_object, output.extension)"
-                    :disabled="!output.is_saveable"
+                    @click="
+                      set_variables(output_geode_object, output_extension)
+                    "
+                    :disabled="!extension.is_saveable"
                   >
                     <v-card-title align="center">
-                      {{ output.extension }}
+                      {{ output_extension }}
                     </v-card-title>
                   </v-card>
                 </span>
@@ -50,6 +54,7 @@
 </template>
 
 <script setup>
+  import _ from "lodash"
   import schema from "@/assets/schemas/ExtensionSelector.json"
 
   const emit = defineEmits([
@@ -60,33 +65,65 @@
 
   const props = defineProps({
     input_geode_object: { type: String, required: true },
+    filenames: { type: Array, required: true },
   })
-  const { input_geode_object } = props
-
-  const geode_objects_and_output_extensions = ref([])
+  const { input_geode_object, filenames } = props
+  const geode_objects_and_output_extensions = ref({})
   const loading = ref(false)
 
   const toggle_loading = useToggle(loading)
 
   async function get_output_file_extensions() {
     toggle_loading()
-    const params = { input_geode_object }
-    await api_fetch(
-      { schema, params },
-      {
-        response_function: (response) => {
-          geode_objects_and_output_extensions.value =
-            response._data.geode_objects_and_output_extensions
-        },
-      },
-    )
+    geode_objects_and_output_extensions.vaue = {}
+    var promise_array = []
+    for (const filename of filenames) {
+      const params = { input_geode_object, filename }
+      const promise = new Promise((resolve, reject) => {
+        api_fetch(
+          { schema, params },
+          {
+            request_error_function: () => {
+              reject()
+            },
+            response_function: (response) => {
+              const data = response._data.geode_objects_and_output_extensions
+              if (_.isEmpty(geode_objects_and_output_extensions.value)) {
+                geode_objects_and_output_extensions.value = data
+              } else {
+                for (const [geode_object, geode_object_value] of Object.entries(
+                  data,
+                )) {
+                  for (const [
+                    output_extension,
+                    output_extension_value,
+                  ] of Object.entries(geode_object_value)) {
+                    if (!output_extension_value["is_saveable"]) {
+                      geode_objects_and_output_extensions.value[geode_object][
+                        output_extension
+                      ]["is_saveable"] = false
+                    }
+                  }
+                }
+              }
+              resolve()
+            },
+            response_error_function: () => {
+              reject()
+            },
+          },
+        )
+      })
+      promise_array.push(promise)
+    }
+    await Promise.all(promise_array)
     toggle_loading()
   }
 
-  function set_variables(geode_object, output_extension) {
-    if (geode_object != "" && output_extension != "") {
+  function set_variables(output_geode_object, output_extension) {
+    if (output_geode_object != "" && output_extension != "") {
       const keys_values_object = {
-        output_geode_object: geode_object,
+        output_geode_object,
         output_extension,
       }
       emit("update_values", keys_values_object)
diff --git a/components/FileUploader.vue b/components/FileUploader.vue
@@ -49,15 +49,29 @@
 
   async function upload_files() {
     toggle_loading()
-    await upload_file(
-      { route, files: multiple ? files.value : [files.value[0]] },
-      {
-        response_function: () => {
-          files_uploaded.value = true
-          emit("files_uploaded", files.value)
-        },
-      },
-    )
+    var promise_array = []
+    for (const file of files.value) {
+      const promise = new Promise((resolve, reject) => {
+        upload_file(
+          { route, file },
+          {
+            request_error_function: () => {
+              reject()
+            },
+            response_function: () => {
+              resolve()
+            },
+            response_error_function: () => {
+              reject()
+            },
+          },
+        )
+      })
+      promise_array.push(promise)
+    }
+    await Promise.all(promise_array)
+    files_uploaded.value = true
+    emit("files_uploaded", files.value)
     toggle_loading()
   }
 
diff --git a/components/MissingFilesSelector.vue b/components/MissingFilesSelector.vue
@@ -54,11 +54,11 @@
   const props = defineProps({
     multiple: { type: Boolean, required: true },
     input_geode_object: { type: String, required: true },
-    files: { type: Array, required: true },
+    filenames: { type: Array, required: true },
     route: { type: String, required: true },
   })
 
-  const { multiple, input_geode_object, files, route } = props
+  const { multiple, input_geode_object, filenames, route } = props
 
   const accept = ref("")
   const loading = ref(false)
@@ -73,39 +73,51 @@
   }
 
   async function missing_files() {
+    toggle_loading()
     has_missing_files.value = false
     mandatory_files.value = []
     additional_files.value = []
-    toggle_loading()
-    for (const file of files) {
-      const params = { input_geode_object, filename: file.name }
-      await api_fetch(
-        { schema, params },
-        {
-          response_function: (response) => {
-            has_missing_files.value = response._data.has_missing_files
-            mandatory_files.value = [].concat(
-              mandatory_files.value,
-              response._data.mandatory_files,
-            )
-            additional_files.value = [].concat(
-              additional_files.value,
-              response._data.additional_files,
-            )
-            const files_list = [].concat(
-              mandatory_files.value,
-              additional_files.value,
-            )
-            accept.value = files_list
-              .map((filename) => "." + filename.split(".").pop())
-              .join(",")
-            if (!has_missing_files.value) {
-              console.log("MISSING FILESSELECTOR increment_step")
-              emit("increment_step")
-            }
+    var promise_array = []
+
+    for (const filename of filenames) {
+      const params = { input_geode_object, filename }
+      const promise = new Promise((resolve, reject) => {
+        api_fetch(
+          { schema, params },
+          {
+            request_error_function: () => {
+              reject()
+            },
+            response_function: (response) => {
+              has_missing_files.value = response._data.has_missing_files
+                ? true
+                : has_missing_files.value
+              mandatory_files.value = [].concat(
+                mandatory_files.value,
+                response._data.mandatory_files,
+              )
+              additional_files.value = [].concat(
+                additional_files.value,
+                response._data.additional_files,
+              )
+              resolve()
+            },
+            response_error_function: () => {
+              reject()
+            },
           },
-        },
-      )
+        )
+      })
+      promise_array.push(promise)
+    }
+    await Promise.all(promise_array)
+    if (!has_missing_files.value) {
+      emit("increment_step")
+    } else {
+      accept.value = []
+        .concat(mandatory_files.value, additional_files.value)
+        .map((filename) => "." + filename.split(".").pop())
+        .join(",")
     }
     toggle_loading()
   }
diff --git a/components/ObjectSelector.vue b/components/ObjectSelector.vue
@@ -31,40 +31,62 @@
 </template>
 
 <script setup>
+  import { toRaw } from "vue"
   import geode_objects from "@/assets/geode_objects"
   import schema from "@/assets/schemas/ObjectSelector.json"
 
   const emit = defineEmits(["update_values", "increment_step"])
 
   const props = defineProps({
-    files: { type: Array, required: true },
+    filenames: { type: Array, required: true },
     key: { type: String, required: false, default: null },
   })
 
-  const { files, key } = props
+  const { filenames, key } = props
 
   const loading = ref(false)
   const allowed_objects = ref([])
 
   const toggle_loading = useToggle(loading)
 
   async function get_allowed_objects() {
-    const params = { filename: files[0].name, key }
     toggle_loading()
-    await api_fetch(
-      { schema, params },
-      {
-        response_function: (response) => {
-          allowed_objects.value = response._data.allowed_objects
-        },
-      },
-    )
+    allowed_objects.value = []
+    var promise_array = []
+    for (const filename of filenames) {
+      const params = { filename, key }
+      const promise = new Promise((resolve, reject) => {
+        api_fetch(
+          { schema, params },
+          {
+            request_error_function: () => {
+              reject()
+            },
+            response_function: (response) => {
+              if (allowed_objects.value.length == 0) {
+                allowed_objects.value = response._data.allowed_objects
+              } else {
+                allowed_objects.value = toRaw(allowed_objects.value).filter(
+                  (value) => response._data.allowed_objects.includes(value),
+                )
+              }
+              resolve()
+            },
+            response_error_function: () => {
+              reject()
+            },
+          },
+        )
+      })
+      promise_array.push(promise)
+    }
+    await Promise.all(promise_array)
     toggle_loading()
   }
 
-  function set_geode_object(geode_object) {
-    if (geode_object != "") {
-      emit("update_values", { input_geode_object: geode_object })
+  function set_geode_object(input_geode_object) {
+    if (input_geode_object != "") {
+      emit("update_values", { input_geode_object })
       emit("increment_step")
     }
   }
diff --git a/components/Step.vue b/components/Step.vue
@@ -63,9 +63,7 @@
   }
 
   function update_values_event(keys_values_object) {
-    console.log("update_values_event", keys_values_object)
     for (const [key, value] of Object.entries(keys_values_object)) {
-      console.log(key, value)
       stepper_tree[key] = value
     }
   }
diff --git a/composables/upload_file.js b/composables/upload_file.js
@@ -1,14 +1,12 @@
 export function upload_file(
-  { route, files },
+  { route, file },
   { request_error_function, response_function, response_error_function } = {},
 ) {
   const errors_store = use_errors_store()
   const geode_store = use_geode_store()
 
   const body = new FormData()
-  for (let i = 0; i < files.length; i++) {
-    body.append("content", files[i])
-  }
+  body.append("file", file)
 
   const request_options = {
     method: "PUT",
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json

Original file line number	Diff line number	Diff line change
`@@ -5,8 +5,11 @@`
`5`	`5`	`"properties": {`
`6`	`6`	`"input_geode_object": {`
`7`	`7`	`"type": "string"`
	`8`	`+ },`
	`9`	`+ "filename": {`
	`10`	`+ "type": "string"`
`8`	`11`	`}`
`9`	`12`	`},`
`10`		`- "required": ["input_geode_object"],`
	`13`	`+ "required": ["input_geode_object", "filename"],`
`11`	`14`	`"additionalProperties": false`
`12`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -63,9 +63,7 @@`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`function update_values_event(keys_values_object) {`
`66`		`- console.log("update_values_event", keys_values_object)`
`67`	`66`	`for (const [key, value] of Object.entries(keys_values_object)) {`
`68`		`- console.log(key, value)`
`69`	`67`	`stepper_tree[key] = value`
`70`	`68`	`}`
`71`	`69`	`}`