fix(Refactor): refactor functions in shared

app/components/ObjectSelector.vue

@@ -1,6 +1,7 @@
 <script setup>
 import FetchingData from "@ogw_front/components/FetchingData.vue";
 import { geode_objects } from "@ogw_front/assets/geode_objects";
+import { resolveAllowedObjects } from "@ogw_shared/utils/response_handlers/load.js";
 import schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json";
 import { useBackStore } from "@ogw_front/stores/back";
 
@@ -15,100 +16,49 @@ const { filenames } = defineProps({
 const backStore = useBackStore();
 
 const loading = ref(false);
-const allowed_objects = ref({});
-const toggle_loading = useToggle(loading);
-const multiple_files_no_common = ref(false);
+const allowedGeodeObjects = ref({});
+const toggleLoading = useToggle(loading);
+const multipleFilesNoCommon = ref(false);
 
-function select_geode_object(object_map) {
-  const object_keys = Object.keys(object_map);
-  if (object_keys.length === 0) {
-    return undefined;
-  }
-  if (object_keys.length === 1 && object_map[object_keys[0]].is_loadable > 0) {
-    return object_keys[0];
-  }
-  const highest_load_score = Math.max(...object_keys.map((key) => object_map[key].is_loadable));
-  if (highest_load_score <= 0) {
-    return undefined;
-  }
-  const best_score_objects = object_keys.filter(
-    (key) => object_map[key].is_loadable === highest_load_score,
-  );
-  if (best_score_objects.length === 1) {
-    return best_score_objects[0];
-  }
-  const highest_priority = Math.max(
-    ...best_score_objects.map((key) => object_map[key].object_priority ?? -Infinity),
-  );
-  const best_priority_objects = best_score_objects.filter(
-    (key) => object_map[key].object_priority === highest_priority,
-  );
-  if (highest_priority !== -Infinity && best_priority_objects.length === 1) {
-    return best_priority_objects[0];
-  }
-  return undefined;
-}
-
-function isCsvFile(filename) {
-  return filename.toLowerCase().endsWith(".csv") || filename.toLowerCase().endsWith(".csv.json");
-}
-
-async function get_allowed_objects() {
-  toggle_loading();
-  allowed_objects.value = {};
-  multiple_files_no_common.value = false;
-
-  const promise_array = filenames.map((filename) => {
+async function fetchAllowedObjectsList() {
+  const promiseArray = filenames.map((filename) => {
     const params = { filename };
     return backStore.request({ schema, params });
   });
-  const responses = await Promise.all(promise_array);
-  const allowed_objects_list = responses.map((response) => response.allowed_objects);
-  const all_keys = [...new Set(allowed_objects_list.flatMap((obj) => Object.keys(obj)))];
-  const common_keys = all_keys.filter((key) => allowed_objects_list.every((obj) => key in obj));
+  const responses = await Promise.all(promiseArray);
+  return responses.map((response) => response.allowed_objects);
+}
 
-  if (filenames.length > 1 && all_keys.length > 0 && common_keys.length === 0) {
-    multiple_files_no_common.value = true;
-  }
+async function getAllowedGeodeObjects() {
+  toggleLoading();
+  allowedGeodeObjects.value = {};
+  multipleFilesNoCommon.value = false;
 
-  const final_object = {};
-  for (const key of common_keys) {
-    const load_scores = allowed_objects_list.map((obj) => obj[key].is_loadable);
-    const priorities = allowed_objects_list
-      .map((obj) => obj[key].object_priority)
-      .filter((priority) => priority !== undefined);
-    final_object[key] = { is_loadable: Math.min(...load_scores) };
-    if (priorities.length > 0) {
-      final_object[key].object_priority = Math.max(...priorities);
-    }
-  }
-  const isCsv = filenames.some((filename) => isCsvFile(filename));
-  if (isCsv && !final_object["PointSet3D"]) {
-    final_object["PointSet3D"] = { is_loadable: 1, object_priority: 100 };
-  }
+  const allowedGeodeObjectsList = await fetchAllowedObjectsList();
+  const resolved = resolveAllowedObjects(filenames, allowedGeodeObjectsList);
 
-  allowed_objects.value = final_object;
-  const selected_object = select_geode_object(final_object);
-  if (selected_object) {
-    set_geode_object(selected_object);
+  allowedGeodeObjects.value = resolved.mergedAllowedObjects;
+  multipleFilesNoCommon.value = resolved.multipleFilesNoCommon;
+  if (resolved.selectedGeodeObject) {
+    setGeodeObject(resolved.selectedGeodeObject);
   }
-  toggle_loading();
+  toggleLoading();
 }
 
-function set_geode_object(geode_object_type) {
+function setGeodeObject(geode_object_type) {
   if (geode_object_type) {
     emit("update_values", { geode_object_type });
     emit("increment_step");
   }
 }
 // oxlint-disable-next-line no-top-level-await
-await get_allowed_objects();
+await getAllowedGeodeObjects();
 </script>
 
 <template>
   <FetchingData v-if="loading" />
-  <v-row v-else-if="Object.keys(allowed_objects).length" class="justify-left">
-    <v-col v-for="(value, key) in allowed_objects" :key="key" cols="3" md="4">
+  <v-row v-else-if="Object.keys(allowedGeodeObjects).length" class="justify-left">
+    <v-col v-for="(value, key) in allowedGeodeObjects" :key="key" cols="3" md="4">
       <v-tooltip
         :text="
           value['is_loadable']
@@ -124,7 +74,7 @@ await get_allowed_objects();
               class="card ma-2"
               hover
               rounded
-              @click="set_geode_object(key)"
+              @click="setGeodeObject(key)"
               :disabled="!value['is_loadable']"
               :elevation="value['is_loadable'] ? 5 : 3"
             >
@@ -139,7 +89,7 @@ await get_allowed_objects();
       </v-tooltip>
     </v-col>
   </v-row>
-  <v-row v-else-if="multiple_files_no_common" class="pa-5">
+  <v-row v-else-if="multipleFilesNoCommon" class="pa-5">
     <v-card class="card" variant="tonal" rounded>
       <v-card-text>
         These files cannot be loaded together because they don't share a common data type.

app/composables/project_manager.js

@@ -2,8 +2,8 @@ import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.jso
 import fileDownload from "js-file-download";
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
+import { fetchRaw } from "@ogw_shared/utils/fetch_raw";
 import { importWorkflowFromSnapshot } from "@ogw_front/utils/import_workflow";
-
 import { useAppStore } from "@ogw_front/stores/app";
 import { useBackStore } from "@ogw_front/stores/back";
 import { useDataStore } from "@ogw_front/stores/data";
@@ -21,12 +21,14 @@ async function exportProject() {
   const snapshot = await appStore.exportStores();
   const schema = back_schemas.opengeodeweb_back.export_project;
   const defaultName = "project.vease";
-
-  const result = await $fetch(schema.$id, {
+  const params = { snapshot, filename: defaultName };
+  const result = await fetchRaw({
+    route: schema.$id,
+    params,
+    method: schema.methods[0],
     baseURL: backStore.base_url,
-    method: schema.methods.find((method) => method !== "OPTIONS"),
-    body: { snapshot, filename: defaultName },
   });
+
   fileDownload(result, defaultName);
   feedbackStore.add_success("Project exported successfully");
   return { result };
@@ -46,26 +48,27 @@ async function importProject(file) {
   if (client && client.getConnection && client.getConnection().getSession) {
     await client.getConnection().getSession().call("opengeodeweb_viewer.release_database", [{}]);
   }
-  const schema = viewer_schemas.opengeodeweb_viewer.viewer.reset_visualization;
+  const resetVisualizationSchema = viewer_schemas.opengeodeweb_viewer.viewer.reset_visualization;
   const timeout = undefined;
-  await viewerStore.request({ schema, timeout });
+  await viewerStore.request({ schema: resetVisualizationSchema, timeout });
 
   treeviewStore.clear();
   dataStore.clear();
   hybridViewerStore.clear();
 
-  const schemaImport = back_schemas.opengeodeweb_back.import_project;
+  const importProjectSchema = back_schemas.opengeodeweb_back.import_project;
   const form = new FormData();
   const originalFileName = file && file.name ? file.name : "project.vease";
   if (!originalFileName.toLowerCase().endsWith(".vease")) {
     throw new Error("Uploaded file must be a .vease");
   }
   form.append("file", file, originalFileName);
 
-  const result = await $fetch(schemaImport.$id, {
+  const result = await fetchRaw({
+    route: importProjectSchema.$id,
+    params: form,
+    method: importProjectSchema.methods[0],
     baseURL: backStore.base_url,
-    method: "POST",
-    body: form,
   });
   const snapshot = result && result.snapshot ? result.snapshot : {};
 

app/stores/app.js

@@ -227,13 +227,16 @@ export const useAppStore = defineStore("app", () => {
   }
 
   function upload(file, callbacks = {}) {
-    const route = "/api/local/extensions/upload";
+    const schema = {
+      $id: "/api/local/extensions/upload",
+      methods: ["OPTIONS", "PUT"],
+    };
     const store = useAppStore();
     const { PROJECT: projectName } = useRuntimeConfig().public;
     const params = { projectName };
     return upload_file(
       store,
-      { route, file, params },
+      { schema, file, params },
       {
         ...callbacks,
         response_function: async (response) => {
@@ -247,16 +250,13 @@ export const useAppStore = defineStore("app", () => {
   }
 
   function request({ schema, params }, callbacks = {}) {
-    console.log("[APP] Request:", schema.$id);
-
     const store = useAppStore();
     return api_fetch(
       store,
-      { schema, params, headers: {} },
+      { schema, params },
       {
         ...callbacks,
         response_function: async (response) => {
-          console.log("[APP] Request completed:", schema.$id);
           if (callbacks.response_function) {
             await callbacks.response_function(response);
           }
@@ -274,7 +274,8 @@ export const useAppStore = defineStore("app", () => {
   }
   const is_busy = computed(() => request_counter.value > 0);
 
-  const projectFolderPath = ref(isCloudMode() ? "/project" : "");
+  const projectFolderPath = ref("");
+
   function createProjectFolder() {
     const { PROJECT } = useRuntimeConfig().public;
     const schema = {

app/stores/back.js

@@ -104,22 +104,12 @@ export const useBackStore = defineStore("back", {
       return Promise.resolve();
     },
     request({ schema, params = {} }, callbacks = {}) {
-      console.log("[GEODE] Request:", schema.$id);
-      const start = Date.now();
-
       return api_fetch(
         this,
         { schema, params, headers: {} },
         {
           ...callbacks,
           response_function: async (response) => {
-            console.log(
-              "[GEODE] Request completed:",
-              schema.$id,
-              "in",
-              (Date.now() - start) / MILLISECONDS_IN_SECOND,
-              "s",
-            );
             if (callbacks.response_function) {
               await callbacks.response_function(response);
             }
@@ -128,17 +118,16 @@ export const useBackStore = defineStore("back", {
       );
     },
     upload(file, callbacks = {}) {
-      const route = back_schemas.opengeodeweb_back.upload_file.$id;
+      const schema = back_schemas.opengeodeweb_back.upload_file;
       return upload_file(
         this,
         {
-          route,
+          schema,
           file,
         },
         {
           ...callbacks,
           response_function: async (response) => {
-            console.log("[GEODE] Request completed:", route);
             if (callbacks.response_function) {
               await callbacks.response_function(response);
             }

app/stores/cloud.js

@@ -43,6 +43,9 @@ export const useCloudStore = defineStore("cloud", {
               domain_name: response.url,
             });
             setAppBaseUrl(appStore.base_url);
+            appStore.$patch({
+              projectFolderPath: "/project",
+            });
           },
           response_error_function: () => {
             feedbackStore.$patch({ server_error: true });

app/stores/infra.js

@@ -77,11 +77,6 @@ export const useInfraStore = defineStore("infra", {
     },
     async create_connection() {
       console.log("[INFRA] Starting create_connection");
-      console.log(
-        "[INFRA] Connecting microservices:",
-        this.microservices.map((store) => store.$id),
-      );
-
       await Promise.all(
         this.microservices.map(async (store) => {
           console.log("[INFRA] Connecting to microservice:", store.$id);

app/stores/viewer.js

@@ -156,25 +156,13 @@ export const useViewerStore = defineStore(
     }
 
     function request({ schema, params = {}, timeout = request_timeout }, callbacks = {}) {
-      console.log("[VIEWER] Request:", schema.$id);
-      const start = Date.now();
-
-      // Get current store instance to pass to viewer_call
       const store = useViewerStore();
-
       return viewer_call(
         store,
         { schema, params, timeout },
         {
           ...callbacks,
           response_function: async (response) => {
-            console.log(
-              "[VIEWER] Request completed:",
-              schema.$id,
-              "in",
-              (Date.now() - start) / MS_PER_SECOND,
-              "s",
-            );
             if (callbacks.response_function) {
               await callbacks.response_function(response);
             }

app/utils/import_workflow.js

@@ -35,13 +35,6 @@ async function importWorkflow(files) {
   return results;
 }
 
-function buildImportItemFromPayloadApi(value, geode_object_type) {
-  return {
-    geode_object_type,
-    ...value,
-  };
-}
-
 async function importItem(item) {
   const dataStore = useDataStore();
   const dataStyleStore = useDataStyleStore();
@@ -94,8 +87,7 @@ async function importFile(filename, geode_object_type) {
     filename,
   };
   const response = await backStore.request({ schema, params });
-  const item = buildImportItemFromPayloadApi(response, geode_object_type);
-  return importItem(item);
+  return importItem(response);
 }
 
 async function importWorkflowFromSnapshot(items) {

app/utils/log.js

@@ -0,0 +1,18 @@
+function startRequestLog(microservice, schema) {
+  console.log(`[${microservice.$id}] Request:`, schema.$id);
+  const requestStartingTime = new Date(Date.now());
+  return requestStartingTime;
+}
+
+function endRequestLog(microservice, schema, requestStartingTime) {
+  const requestEndingTime = new Date(Date.now());
+  console.log(
+    `[${microservice.$id}] Request completed:`,
+    schema.$id,
+    "in",
+    requestEndingTime.getSeconds() - requestStartingTime.getSeconds(),
+    "s",
+  );
+}
+
+export { startRequestLog, endRequestLog };