@eodash/eodash 5.0.0-rc.2.5 → 5.0.0

package/widgets/EodashProcess/methods/outputs.js

@@ -0,0 +1,216 @@
+import mustache from "mustache";
+import { extractLayerConfig } from "@/eodashSTAC/helpers";
+import axios from "@/plugins/axios";
+import { createLayerDefinition } from "./utils";
+import { pollProcessStatus } from "./async";
+import { indicator } from "@/store/states";
+
+/**
+ * @param {import("stac-ts").StacLink[] | undefined} links
+ * @param {Record<string,any>|undefined} jsonformValue
+ * @param {number[]} origBbox
+ */
+export function processImage(links, jsonformValue, origBbox) {
+  if (!links) return;
+  const imageLinks = links.filter(
+    (link) => link.rel === "service" && link.type === "image/png",
+  );
+  const layers = [];
+  for (const link of imageLinks) {
+    layers.push({
+      type: "Image",
+      properties: {
+        id: link.id,
+        title: "Results " + link.id,
+      },
+      source: {
+        type: "ImageStatic",
+        imageExtent: origBbox,
+        url: mustache.render(link.href, {
+          ...(jsonformValue ?? {}),
+        }),
+      },
+    });
+  }
+  return layers;
+}
+
+/**
+ * @param {import("stac-ts").StacLink[] | undefined} links
+ * @param {Record<string,any> | undefined} jsonformValue
+ * @param {string} layerId
+ */
+export async function processVector(links, jsonformValue, layerId) {
+  if (!links) return;
+  /** @type {Record<string,any>[]} */
+  const layers = [];
+  const vectorLinks = links.filter(
+    (link) => link.rel === "service" && link.type === "application/geo+json",
+  );
+  if (vectorLinks.length === 0) return layers;
+
+  let flatStyleJSON = null;
+
+  for (const link of vectorLinks) {
+    if ("eox:flatstyle" in (link ?? {})) {
+      flatStyleJSON = await axios
+        .get(/** @type {string} */ (link["eox:flatstyle"]))
+        .then((resp) => resp.data);
+    }
+
+    /** @type {Record<string,any>|undefined} */
+    let layerConfig;
+    /** @type {Record<string,any>|undefined} */
+    let style;
+    if (flatStyleJSON) {
+      const extracted = extractLayerConfig(flatStyleJSON);
+      layerConfig = extracted.layerConfig;
+      style = extracted.style;
+    }
+
+    layers.push({
+      type: "Vector",
+      source: {
+        type: "Vector",
+        url: mustache.render(link.href, {
+          ...(jsonformValue ?? {}),
+        }),
+        format: "GeoJSON",
+      },
+      properties: {
+        id: layerId + "_vector_process",
+        title: "Results " + layerId,
+        ...(layerConfig && { ...layerConfig, ...(style && { style: style }) }),
+      },
+    });
+  }
+  return layers;
+}
+
+/**
+ * @param {import("stac-ts").StacLink[] | undefined} links
+ * @param {Record<string,any> | undefined} jsonformValue
+ * @param {string} specUrl
+ * @returns {Promise<[import("@eox/chart").EOxChart["spec"] | null,Record<string,any>|null]>}
+ **/
+export async function getChartValues(links, jsonformValue, specUrl) {
+  if (!specUrl || !links) return [null, null];
+  /** @type {import("vega").Spec} */
+  const spec = await axios.get(specUrl).then((resp) => {
+    return resp.data;
+  });
+  // //@ts-expect-error NamedData
+  // const dataName = spec?.data?.name;
+  const dataLinks = links.filter(
+    (link) => link.rel === "service", // && dataName && link.id === dataName,
+  );
+
+  /** @type {Record<string,any>}  */
+  const dataValues = {};
+  for (const link of dataLinks ?? []) {
+    if (link.type && ["application/json", "text/csv"].includes(link.type)) {
+      const dataUrl = mustache.render(link.href, {
+        ...(jsonformValue ?? {}),
+        ...(link["eox:flatstyle"] ?? {}),
+      });
+
+      // Wait for data to be retrieved
+      const data = await axios.get(dataUrl).then((resp) => {
+        return resp.data;
+      });
+      // @ts-expect-error we assume data to exist in spec
+      spec.data.values = data;
+      continue;
+    }
+
+    dataValues[/** @type {string} */ (link.id)] = await axios
+      .get(
+        mustache.render(link.href, {
+          ...(jsonformValue ?? {}),
+          ...(link["eox:flatstyle"] ?? {}),
+        }),
+      )
+      .then((resp) => resp.data);
+  }
+
+  return [spec, dataValues];
+}
+
+/**
+ * @param {import("stac-ts").StacLink[] | undefined} links
+ * @param {Record<string,any> | undefined} jsonformValue
+ * @param {import("vue").Ref<boolean>} isPolling
+ * @param {string} layerId
+ * @param {string} projection
+ */
+export async function processGeoTiff(
+  links,
+  jsonformValue,
+  layerId,
+  isPolling,
+  projection,
+) {
+  if (!links) return;
+  const geotiffLinks = links.filter(
+    (link) => link.rel === "service" && link.type === "image/tiff",
+  );
+  let urls = [];
+  let processId = "";
+  for (const link of geotiffLinks ?? []) {
+    if (link.endpoint === "eoxhub_workspaces") {
+      // TODO: prove of concept, needs to be reworked for sure
+      // Special handling for eoxhub workspace process endpoints
+      const postBody = await axios
+        .get(/** @type {string} */ (link["body"]), { responseType: "text" })
+        .then((resp) => resp.data);
+      const jsonData = JSON.parse(
+        mustache.render(postBody, { ...(jsonformValue ?? {}) }),
+      );
+      try {
+        const responseProcess = await axios.post(link.href, jsonData, {
+          headers: {
+            "Content-Type": "application/json",
+          },
+        });
+        console.log(responseProcess.headers.location);
+        // We save the process status url into localstorage assigning it to the indicator id
+        const currentJobs = JSON.parse(
+          localStorage.getItem(indicator.value) || "[]",
+        );
+        currentJobs.push(responseProcess.headers.location);
+        localStorage.setItem(indicator.value, JSON.stringify(currentJobs));
+        await pollProcessStatus({
+          processUrl: responseProcess.headers.location,
+          isPolling,
+        })
+          .then((resultItem) => {
+            // @ts-expect-error we have currently no definition of what is allowed as response
+            const resultUrls = resultItem?.urls;
+            if (resultUrls?.length < 1) {
+              return;
+            }
+            //@ts-expect-error todo
+            processId = resultItem?.id;
+            urls = resultUrls;
+          })
+          .catch((error) => {
+            if (error instanceof Error) {
+              console.error("Polling failed:", error.message);
+            } else {
+              console.error("Unknown error occurred during polling:", error);
+            }
+          });
+      } catch (error) {
+        if (error instanceof Error) {
+          console.error("Error sending POST request:", error.message);
+        } else {
+          console.error("Unknown error occurred:", error);
+        }
+      }
+    } else {
+      urls.push(mustache.render(link.href, { ...(jsonformValue ?? {}) }));
+    }
+  }
+
+  return createLayerDefinition(links[0], layerId, urls, projection, processId);
+}

package/widgets/EodashProcess/methods/utils.js

@@ -0,0 +1,138 @@
+import { extractLayerConfig } from "@/eodashSTAC/helpers";
+import axios from "@/plugins/axios";
+import { isMulti } from "@eox/jsonform/src/custom-inputs/spatial/utils";
+
+/**
+ * @param {Record<string,any> |null} [jsonformSchema]
+ **/
+export function getBboxProperty(jsonformSchema) {
+  return /** @type {string} */ (
+    Object.keys(jsonformSchema?.properties ?? {}).find(
+      (key) => jsonformSchema?.properties[key].format === "bounding-box",
+    )
+  );
+}
+
+/**
+ * Extracts the keys of type "geojson" from the jsonform schema
+ * @param {Record<string,any> |null} [jsonformSchema]
+ **/
+export function getGeoJsonProperties(jsonformSchema) {
+  return /** @type {string[]} */ (
+    Object.keys(jsonformSchema?.properties ?? {}).filter(
+      (key) => jsonformSchema?.properties[key].type === "geojson",
+    )
+  );
+}
+
+/**
+ * Converts jsonform geojson values to stringified geometries
+ * @param {Record<string,any> |null} [jsonformSchema]
+ * @param {Record<string,any>} jsonformValue
+ **/
+export function extractGeometries(jsonformValue, jsonformSchema) {
+  const geojsonKeys = getGeoJsonProperties(jsonformSchema);
+
+  for (const key of geojsonKeys) {
+    if (!jsonformValue[key]) {
+      continue;
+    }
+
+    if (isMulti(jsonformSchema?.properties[key])) {
+      // jsonformValue[key] is a feature collection
+      jsonformValue[key] =
+        /** @type {import("ol/format/GeoJSON").GeoJSONFeatureCollection} */ (
+          jsonformValue[key]
+        ).features.map((feature) => JSON.stringify(feature.geometry));
+    } else {
+      // jsonformValue[key] is a single feature
+      jsonformValue[key] = JSON.stringify(jsonformValue[key].geometry);
+    }
+  }
+}
+
+/**
+ *
+ * @param {*} link
+ * @param {*} layerId
+ * @param {string[]} urls
+ * @param {*} projection
+ * @param {*} processId
+ * @returns
+ */
+export async function createLayerDefinition(
+  link,
+  layerId,
+  urls,
+  projection,
+  processId,
+) {
+  let flatStyleJSON = null;
+  if ("eox:flatstyle" in (link ?? {})) {
+    flatStyleJSON = await axios
+      .get(/** @type {string} */ (link["eox:flatstyle"]))
+      .then((resp) => resp.data);
+  }
+
+  /** @type {Record<string,any>|undefined} */
+  let layerConfig;
+  /** @type {Record<string,any>|undefined} */
+  let style;
+  if (flatStyleJSON) {
+    const extracted = extractLayerConfig(layerId ?? "", flatStyleJSON);
+    layerConfig = extracted.layerConfig;
+    style = extracted.style;
+  }
+  // We want to make sure the urls are alphabetically sorted
+  urls = urls.sort();
+  const layerdef =
+    urls.length > 0
+      ? {
+          type: "WebGLTile",
+          source: {
+            type: "GeoTIFF",
+            normalize: !style,
+            sources: urls.map((url) => ({ url })),
+          },
+          properties: {
+            id: layerId + "_geotiff_process" + processId,
+            title: "Results " + layerId,
+            ...(layerConfig && { layerConfig: layerConfig }),
+            layerControlToolsExpand: true,
+          },
+          ...(style && { style: style }),
+        }
+      : undefined;
+
+  // We want to see if the currently selected indicator uses a
+  // specific map projection if it does we want to apply it
+  if (projection && layerdef) {
+    //@ts-expect-error TODO
+    layerdef.source.projection = projection;
+  }
+  return layerdef;
+}
+/**
+ * @param {string} fileName
+ * @param {string|Record<string,any>} content
+ * @returns
+ */
+export const download = (fileName, content) => {
+  if (!content) {
+    return;
+  }
+  let url = /** @type string */ (content);
+  if (typeof content === "object") {
+    content = JSON.stringify(content);
+    const blob = new Blob([content], { type: "text" });
+    url = URL.createObjectURL(blob);
+  }
+  const link = document.createElement("a");
+  if (confirm(`Would you like to download ${fileName}?`)) {
+    link.href = url;
+    link.download = fileName;
+    link.click();
+  }
+  URL.revokeObjectURL(url);
+  link.remove();
+};

package/widgets/EodashStacInfo.vue

@@ -55,26 +55,32 @@ main {padding-bottom: 10px;}
 .footer-container small {font-size:10px;line-height:1;}`,
   },
   header: {
+    /** @type {import("vue").PropType<string[]>}  */
     type: Array,
     default: () => ["title"],
   },
   tags: {
+    /** @type {import("vue").PropType<string[]>}  */
     type: Array,
     default: () => ["themes"],
   },
   subheader: {
+    /** @type {import("vue").PropType<string[]>}  */
     type: Array,
     default: () => [],
   },
   body: {
+    /** @type {import("vue").PropType<string[]>}  */
     type: Array,
     default: () => ["satellite", "sensor", "agency", "extent"],
   },
   featured: {
+    /** @type {import("vue").PropType<string[]>}  */
     type: Array,
     default: () => ["description", "providers", "assets", "links"],
   },
   footer: {
+    /** @type {import("vue").PropType<string[]>}  */
     type: Array,
     default: () => ["sci:citation"],
   },

package/widgets/EodashTools.vue

@@ -74,6 +74,7 @@ const props = defineProps({
     default: "Select indicator",
   },
   itemFilterConfig: {
+    /** @type {import("vue").PropType<InstanceType<import("./EodashItemFilter.vue").default>["$props"]>} */
     type: Object,
     default: () => {},
   },