ebta-workflow-prod 1.1.3 → 4.0.2

package/src/activities/RequestChecker.ts

@@ -0,0 +1,94 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/unbound-method */
+import type { IActivityHandler } from "@vertigis/workflow";
+
+/** An interface that defines the inputs of the activity. */
+interface RequestCheckerInputs {}
+
+/** An interface that defines the outputs of the activity. */
+interface RequestCheckerOutputs {
+    /**
+     * @description True if there is still any pending request.
+     */
+    result: boolean;
+}
+
+/**
+ * @displayName RequestChecker
+ * @category EBTA Utilities
+ * @description Check if there is any pending HTTP request
+ */
+export default class RequestCheckerActivity implements IActivityHandler {
+    // Track ongoing XMLHttpRequests
+    private static activeXHRs: XMLHttpRequest[] = [];
+
+    // Track ongoing Fetch requests
+    private static activeFetches: Promise<Response>[] = [];
+
+    constructor() {
+        // Monkey patch XMLHttpRequest to track active requests
+        const xhrProto = XMLHttpRequest.prototype as any;
+
+        const originalOpen = xhrProto.open;
+        const originalAbort = xhrProto.abort;
+
+        xhrProto.open = function (
+            this: XMLHttpRequest,
+            method: string,
+            url: string,
+            async?: boolean,
+            username?: string | null,
+            password?: string | null
+        ): void {
+            RequestCheckerActivity.activeXHRs.push(this);
+            this.addEventListener("loadend", () => {
+                const index = RequestCheckerActivity.activeXHRs.indexOf(this);
+                if (index > -1) {
+                    RequestCheckerActivity.activeXHRs.splice(index, 1);
+                }
+            });
+            return originalOpen.call(this, method, url, async, username, password);
+        };
+
+        xhrProto.abort = function (this: XMLHttpRequest): void {
+            const index = RequestCheckerActivity.activeXHRs.indexOf(this);
+            if (index > -1) {
+                RequestCheckerActivity.activeXHRs.splice(index, 1);
+            }
+            return originalAbort.call(this);
+        };
+
+        // Monkey patch global fetch to track active promises
+        const originalFetch = window.fetch.bind(window);
+        (window as any).fetch = (...args: Parameters<typeof fetch>) => {
+            const fetchPromise = originalFetch(...args);
+            RequestCheckerActivity.activeFetches.push(fetchPromise);
+
+            void fetchPromise
+                .then(() => {
+                    const index = RequestCheckerActivity.activeFetches.indexOf(fetchPromise);
+                    if (index > -1) {
+                        RequestCheckerActivity.activeFetches.splice(index, 1);
+                    }
+                })
+                .catch(() => {
+                    const index = RequestCheckerActivity.activeFetches.indexOf(fetchPromise);
+                    if (index > -1) {
+                        RequestCheckerActivity.activeFetches.splice(index, 1);
+                    }
+                });
+
+            return fetchPromise;
+        };
+    }
+
+    execute(inputs: RequestCheckerInputs): RequestCheckerOutputs {
+        // Check both XMLHttpRequests and Fetch requests
+        const hasPendingXHR = RequestCheckerActivity.activeXHRs.length > 0;
+        const hasPendingFetch = RequestCheckerActivity.activeFetches.length > 0;
+
+        return {
+            result: hasPendingXHR || hasPendingFetch,
+        };
+    }
+}

package/src/activities/Sample.ts

@@ -0,0 +1,41 @@
+import type { IActivityHandler } from "@vertigis/workflow";
+
+/** An interface that defines the inputs of the activity. */
+interface SampleInputs {
+    /**
+     * @displayName Input 1
+     * @description The first input to the activity.
+     * @required
+     */
+    input1: string;
+
+    /**
+     * @displayName Input 2
+     * @description The second input to the activity.
+     */
+    input2?: number;
+}
+
+/** An interface that defines the outputs of the activity. */
+interface SampleOutputs {
+    /**
+     * @description The result of the activity.
+     */
+    result: string;
+}
+
+/**
+ * @displayName Sample
+ * @category Custom Activities
+ * @description sample for first prod-activity
+ */
+export default class SampleActivity implements IActivityHandler {
+    /** Perform the execution logic of the activity. */
+    execute(inputs: SampleInputs): SampleOutputs {
+        return {
+            result: `input1: ${inputs.input1}, input2: ${
+                inputs.input2 || "undefined"
+            }`,
+        };
+    }
+}

package/src/activities/SetSessionStorage.ts

@@ -0,0 +1,57 @@
+import type { IActivityHandler } from "@vertigis/workflow";
+
+/** An interface that defines the inputs of the activity. */
+interface SetSessionStorageItemActivityInputs {
+    /**
+     * @displayName keyName
+     * @description A string containing the name of the key you want to create/update.
+     * @required
+    */
+   keyName: string;
+   
+   /**
+    * @displayName keyValue
+    * @description A string containing the value you want to give the key you are creating/updating.
+    * @required
+    */
+    keyValue: string;
+}
+
+
+/** An interface that defines the outputs of the activity. */
+interface SetSessionStorageItemActivityOutputs {
+    /**
+     * @description The result of the activity.
+     */
+    result: object;
+}
+
+
+/**
+ * @displayName Set SessionStorage Item
+ * @category EBTA Utilities
+ * @description Add an item to browser SessionStorage object 1.1
+ */
+export default class SetSessionStorageItemActivity implements IActivityHandler {
+    /** Perform the execution logic of the activity. */
+    async execute(inputs: SetSessionStorageItemActivityInputs): Promise<SetSessionStorageItemActivityOutputs> {
+        const { keyName, keyValue } = inputs;
+        let message = "";
+
+        if (typeof(keyName) !== "undefined" && keyName !== null) {
+            if (typeof(keyValue) !== "undefined" && keyValue !== null) {
+                sessionStorage.setItem(keyName, keyValue);
+                message = "Wrote value to SessionStorage";
+            }
+        } else {
+            message = "Could not write value to SessionStorage"
+        }
+        return {
+            result: {
+                "message": message,
+                "keyName": keyName,
+                "keyValue": keyValue
+            }
+        };
+    }
+}

package/src/activities/SliceLine.ts

@@ -0,0 +1,61 @@
+import type { IActivityHandler } from "@vertigis/workflow";
+import { lineString, lineSliceAlong, length } from "@turf/turf";
+
+/** An interface that defines the inputs of the activity. */
+interface SliceLineInputs {
+  /**
+   * @displayName Path
+   * @description an array of path coordinates.
+   * @required
+   */
+  path: [];
+
+  /**
+   * @displayName start
+   * @description start distance to slice
+   * @required
+   */
+  start: number;
+
+  /**
+   * @displayName end
+   * @description end distance to slice
+   * @required
+   */
+  end: number;
+}
+
+/** An interface that defines the outputs of the activity. */
+interface SliceLineOutputs {
+  /**
+   * @description The result of the activity.
+   */
+  result: object;
+}
+
+function sliceLine(path: [], start: number, stop: number) {
+  const line = lineString(path);
+  const linelength = length(line, { units: "meters" });
+
+  if (stop > linelength) {
+    stop = linelength;
+  }
+
+  const sliced = lineSliceAlong(line, start, stop, { units: "meters" });
+  return sliced;
+}
+
+/**
+ * @displayName Slice Line
+ * @category Geocortex
+ * @description Slice Line based on start and end distance - Ver 1.01
+ */
+export default class SliceLineActivity implements IActivityHandler {
+  /** Perform the execution logic of the activity. */
+  execute(inputs: SliceLineInputs): SliceLineOutputs {
+    const result = sliceLine(inputs.path, inputs.start, inputs.end);
+    return {
+      result: result,
+    };
+  }
+}