ebta-workflow-prod 1.1.2 → 4.0.1

package/src/activities/GetElementByDataLayoutID.ts

@@ -0,0 +1,58 @@
+import type { IActivityHandler } from "@vertigis/workflow";
+
+/** An interface that defines the inputs of the activity. */
+interface GetElementByDataLayoutIDInputs {
+  /**
+   * @displayName Data Layout ID
+   * @description The data-layout-id of the element to find.
+   * @required
+   */
+  dataLayoutId: string;
+
+  /**
+   * @displayName CSS Styles
+   * @description The CSS styles to inject into the element.
+   * @required
+   */
+  cssStyles: string;
+}
+
+/** An interface that defines the outputs of the activity. */
+interface GetElementByDataLayoutIDOutputs {
+  /**
+   * @description A message indicating the result of the activity.
+   */
+  result: string;
+}
+
+/**
+ * @displayName Get Element By DataLayout ID
+ * @category EBTA Utilities
+ * @description Get Element By DataLayout ID and inject CSS styles V1.
+ */
+export default class GetElementByDataLayoutIDActivity
+  implements IActivityHandler
+{
+  /** Perform the execution logic of the activity. */
+  execute(
+    inputs: GetElementByDataLayoutIDInputs
+  ): GetElementByDataLayoutIDOutputs {
+    const { dataLayoutId, cssStyles } = inputs;
+    const element = document.querySelector(
+      `[data-layout-id="${dataLayoutId}"]`
+    );
+
+    if (!element) {
+      return {
+        result: `Element with data-layout-id="${dataLayoutId}" not found.`,
+      };
+    }
+
+    // Inject the CSS styles
+    element.setAttribute("style", cssStyles);
+
+    return {
+      result: `CSS styles injected into element with data-layout-id="${dataLayoutId}".`,
+    };
+  }
+}

package/src/activities/GetSesionStorage.ts

@@ -0,0 +1,36 @@
+import type { IActivityHandler } from "@vertigis/workflow";
+
+/** An interface that defines the inputs of the activity. */
+interface GetSessionStorageItemActivityInputs {
+    /**
+     * @displayName keyName
+     * @description A string containing the name of the key you want to retrieve from SessionStorage
+     * @required
+     */
+    keyName: string;
+
+}
+
+/** An interface that defines the outputs of the activity. */
+interface GetSessionStorageItemActivityOutputs {
+    /**
+     * @description the returned keyValue from SessionStorage
+     */
+    result: string;
+}
+
+/**
+ * @displayName Get SessionStorage Item
+ * @category EBTA Utilities
+ * @description Get an item from browser SessionStorage object 1.1
+ */
+export default class GetSessionStorageItemActivity implements IActivityHandler {
+    /** Perform the execution logic of the activity. */
+    async execute(inputs: GetSessionStorageItemActivityInputs): Promise<GetSessionStorageItemActivityOutputs> {
+        const { keyName } = inputs;
+        const keyValue = sessionStorage.getItem(keyName);
+        return {
+            result: `${keyValue}`,
+        };
+    }
+}

package/src/activities/GetTaskStatus.ts

@@ -0,0 +1,56 @@
+import type { IActivityHandler } from "@vertigis/workflow";
+import axios from "axios";
+
+/** An interface that defines the inputs of the activity. */
+interface GetTaskStatusInputs {
+    /**
+     * @displayName job url
+     * @description Job url to get the status of.
+     * @required
+     */
+    jobUrl: string;
+
+    /**
+     * @displayName Token
+     * @description Token to access the task.
+     */
+    token?: string;
+}
+
+/** An interface that defines the outputs of the activity. */
+interface GetTaskStatusOutputs {
+    /**
+     * @description The result of the activity.
+     */
+    result: object;
+}
+
+const getTaskStatus = async (jobUrl: string, token: string) => {
+    const url = `${jobUrl}?f=json&token=${token}`;
+    let jobStatus = 'Processing';
+    let jobresult = {};
+    while (jobStatus === 'Processing') {
+        const response = await axios.get(url);
+        jobStatus = response.data.status;
+        jobresult = response.data;
+        await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+
+    return jobresult;
+
+}
+
+/**
+ * @displayName GetTaskStatus
+ * @category Geocortex
+ * @description Get ArcGIS Online Task Status
+ */
+export default class GetTaskStatusActivity implements IActivityHandler {
+    /** Perform the execution logic of the activity. */
+    async execute(inputs: GetTaskStatusInputs): Promise<GetTaskStatusOutputs> {
+        const result = await getTaskStatus(inputs.jobUrl, inputs.token || '');
+        return {
+            result: result
+        };
+    }
+}

package/src/activities/GetUserToken.ts

@@ -0,0 +1,102 @@
+import type { IActivityHandler } from "@vertigis/workflow";
+
+
+interface Auth {
+    appId: string;
+    refreshToken: string;
+}
+
+/** An interface that defines the inputs of the activity. */
+interface GetUserTokenInputs {
+    /**
+     * @displayName Portal Url
+     * @description The second input to the activity.
+     */
+    portalurl?: string; // Ensure this is the correct type
+}
+
+/** An interface that defines the outputs of the activity. */
+interface GetUserTokenOutputs {
+    /**
+     * @description The result of the activity.
+     */
+    access_token: string;
+}
+
+/**
+ * @displayName Get User Token
+ * @category EBTA Utilities
+ * @description Get User Token 1.2
+ */
+export default class GetUserTokenActivity implements IActivityHandler {
+    /** Perform the execution logic of the activity. */
+    async execute(inputs: GetUserTokenInputs): Promise<GetUserTokenOutputs> {
+        // Your existing code here
+    
+        console.log("GetUserTokenActivity version: 1.2");
+        const authData = sessionStorage.getItem("esriJSAPIOAuth");
+
+        let auth:Auth = {
+            appId: 'your_client_id',
+            refreshToken: 'your_refresh_token'
+        };
+
+        if (authData !== null) {
+            const parsedAuthData = JSON.parse(authData);
+            const portalAuth = parsedAuthData?.['/']?.[inputs.portalurl || 'https://www.arcgis.com'];
+            if (typeof portalAuth === 'object') {
+                auth = portalAuth;
+            }
+        }
+
+     
+        const url = "https://www.arcgis.com/sharing/rest/oauth2/token";
+        if (auth) {
+
+            const myHeaders = new Headers();
+            myHeaders.append("Content-Type", "application/x-www-form-urlencoded");
+
+            const urlencoded = new URLSearchParams();
+            urlencoded.append("client_id", (auth.appId));
+            urlencoded.append("refresh_token", auth.refreshToken);
+            urlencoded.append("grant_type", "refresh_token");
+
+
+            const requestOptions = {
+                method: "POST",
+                headers: myHeaders,
+                body: urlencoded.toString()
+            };
+
+
+            try {
+                const response = await fetch(url, requestOptions);
+                console.log(response)
+    
+                if (!response.ok) {
+                    throw new Error(`HTTP error! status: ${response.status}`);
+                }
+    
+                return response.json()
+                    .then(responseData => {
+                        const data = responseData;
+                        return { access_token: data.access_token };
+                        
+                    })
+                    .catch(error => {
+                        console.error('Error processing response:', error);
+                        throw error;
+                    });
+                                
+            } catch (error) {
+                console.error("Error fetching access token:", error);
+                throw error;
+            }
+        } else {
+            // Handle the case where auth is null
+            console.error("Authentication data is missing.");
+            // You can throw an error or handle it as per your application's requirement
+            throw new Error("Authentication data is missing.");
+        }
+    }
+}

package/src/activities/GetvGISDetails copy.ts

@@ -0,0 +1,110 @@
+import type { IActivityHandler } from "@vertigis/workflow";
+
+/** An interface that defines the inputs of the activity. */
+interface GetvGISDetailsInputs {
+
+
+    /**
+     * @displayName Assignee Email
+     * @description The email of the assignee.
+     * @required
+     */
+    assigneeEmail: string;
+
+    /**
+     * @displayName Creator Email
+     * @description The email of the creator.
+     * @required
+     */
+    creatorEmail: string;
+
+    /**
+     * @displayName Due Date
+     * @description The due date for the task.
+     * @required
+     */
+    dueDate: string;
+
+    /**
+     * @displayName Polygon
+     * @description The polygon coordinates.
+     * @required
+     */
+    polygon: string;
+
+    /**
+     * @displayName Name
+     * @description The name of the task.
+     * @required
+     */
+    name: string;
+
+    /**
+     * @displayName Bearer Token
+     * @description The bearer token for authorization.
+     * @required
+     */
+    bearerToken: string;
+
+        /**
+     * @displayName file
+     * @description The bearer token for authorization.
+     */
+    file: Blob;
+}
+
+/** An interface that defines the outputs of the activity. */
+interface GetvGISDetailsOutputs {
+    /**
+     * @description The result of the activity.
+     */
+    result: object;
+}
+
+/**
+ * @displayName Get vGIS Details
+ * @category Geocortex
+ * @description Get vGIS Details v1.1
+ */
+export default class GetvGISDetailsActivity implements IActivityHandler {
+    /** Perform the execution logic of the activity. */
+    async execute(inputs: GetvGISDetailsInputs): Promise<GetvGISDetailsOutputs> {
+        try {
+            const myHeaders = new Headers();
+            myHeaders.append("Authorization", `Bearer ${inputs.bearerToken}`);
+            
+
+            const formdata = new FormData();
+            formdata.append("assigneeEmail", inputs.assigneeEmail);
+            formdata.append("creatorEmail", inputs.creatorEmail);
+            formdata.append("dueDate", inputs.dueDate);
+            formdata.append("polygon", inputs.polygon);
+            formdata.append("name", inputs.name);
+            if (inputs.file) {
+                formdata.append("file", inputs.file, "file");
+            }
+
+            const requestOptions = {
+                method: "POST",
+                headers: myHeaders,
+                body: formdata,
+                redirect: "follow" as RequestRedirect,
+            };
+
+            const response = await fetch("https://external-api-vgis.meemim.com/api/custom/59307/dig-permit", requestOptions);
+            const resultText = await response.json();
+            return {
+                result: resultText,
+            };
+        } catch (error) {
+            console.error("Error in fetching data from vGIS")
+            return {
+                result: {
+                    IssueUrl: null,
+                    ViewpointUrl: null,
+                    QrCodeUrl: null,
+                },
+            };
+        }
+    }
+}

package/src/activities/GetvGISDetails.ts

@@ -0,0 +1,110 @@
+import type { IActivityHandler } from "@vertigis/workflow";
+
+/** An interface that defines the inputs of the activity. */
+interface GetvGISDetailsInputs {
+
+
+    /**
+     * @displayName Assignee Email
+     * @description The email of the assignee.
+     * @required
+     */
+    assigneeEmail: string;
+
+    /**
+     * @displayName Creator Email
+     * @description The email of the creator.
+     * @required
+     */
+    creatorEmail: string;
+
+    /**
+     * @displayName Due Date
+     * @description The due date for the task.
+     * @required
+     */
+    dueDate: string;
+
+    /**
+     * @displayName Polygon
+     * @description The polygon coordinates.
+     * @required
+     */
+    polygon: string;
+
+    /**
+     * @displayName Name
+     * @description The name of the task.
+     * @required
+     */
+    name: string;
+
+    /**
+     * @displayName Bearer Token
+     * @description The bearer token for authorization.
+     * @required
+     */
+    bearerToken: string;
+
+        /**
+     * @displayName file
+     * @description The bearer token for authorization.
+     */
+    file: Blob;
+}
+
+/** An interface that defines the outputs of the activity. */
+interface GetvGISDetailsOutputs {
+    /**
+     * @description The result of the activity.
+     */
+    result: object;
+}
+
+/**
+ * @displayName Get vGIS Details
+ * @category EBTA Utilities
+ * @description Get vGIS Details v1.1
+ */
+export default class GetvGISDetailsActivity implements IActivityHandler {
+    /** Perform the execution logic of the activity. */
+    async execute(inputs: GetvGISDetailsInputs): Promise<GetvGISDetailsOutputs> {
+        try {
+            const myHeaders = new Headers();
+            myHeaders.append("Authorization", `Bearer ${inputs.bearerToken}`);
+            
+
+            const formdata = new FormData();
+            formdata.append("assigneeEmail", inputs.assigneeEmail);
+            formdata.append("creatorEmail", inputs.creatorEmail);
+            formdata.append("dueDate", inputs.dueDate);
+            formdata.append("polygon", inputs.polygon);
+            formdata.append("name", inputs.name);
+            if (inputs.file) {
+                formdata.append("file", inputs.file, "file");
+            }
+
+            const requestOptions = {
+                method: "POST",
+                headers: myHeaders,
+                body: formdata,
+                redirect: "follow" as RequestRedirect,
+            };
+
+            const response = await fetch("https://external-api-vgis.meemim.com/api/custom/59307/dig-permit", requestOptions);
+            const resultText = await response.json();
+            return {
+                result: resultText,
+            };
+        } catch (error) {
+            console.error("Error in fetching data from vGIS")
+            return {
+                result: {
+                    IssueUrl: null,
+                    ViewpointUrl: null,
+                    QrCodeUrl: null,
+                },
+            };
+        }
+    }
+}

package/src/activities/HTMLextractor.ts

@@ -0,0 +1,188 @@
+/* eslint-disable prefer-const */
+import type { IActivityHandler } from "@vertigis/workflow";
+import html2canvas from 'html2canvas';
+/** An interface that defines the inputs of the activity. */
+interface HTMLextractorInputs {
+    /**
+     * @displayName CSS Selector
+     * @description The string of css selector.
+     * @required
+     */
+    selector: string;
+
+    /**
+     * @displayName Request
+     * @description Chose one from the following requests: "getImage","getProperty"
+    */
+    request?: "getImage" | "getProperty";
+        /**
+     * @displayName Additional Value(optional)
+     * @description Additional value: If request is getProperty, put in property name like width; If request is getImage, put in whiteBackground to force background to be white
+     */
+    value?: string;
+}
+
+/** An interface that defines the outputs of the activity. */
+interface HTMLextractorOutputs {
+    /**
+     * @description The result of the activity.
+     */
+    result: string;
+}
+
+
+/**
+ * @displayName Extract HTML Element by CSS Selector
+ * @category EBTA Utilities
+ * @description Extract screenshot or attribute of HTML component by a css selector
+ */
+function convertSVGTagstoIMG(container) {
+    let svgElements: NodeListOf<SVGElement> = container.querySelectorAll('svg[role="img"]');
+    let SVGDom = Array.from(svgElements).filter(svg => {
+        let svgElement = svg;
+        let gTag = svgElement.querySelector('g');
+        return gTag && gTag.querySelector('image');
+    });
+    
+
+    SVGDom.forEach(svg => {
+        let svgElement = svg;
+        // Create a new <img> element
+        let img = document.createElement('img');
+
+    
+        let imageDOM = svgElement.querySelector('image');
+        if (imageDOM) {
+
+    
+            let imageurl = imageDOM.getAttribute('href');
+    
+            // Transfer the relevant attributes
+            img.alt = imageDOM.getAttribute('alt') || '';
+            img.src = imageurl || ''; // Use xlink:href for the src
+            img.width = parseInt(imageDOM.getAttribute('width') || '0');
+            img.height = parseInt(imageDOM.getAttribute('height') || '0');
+
+    
+            svg.parentNode!.replaceChild(img, svg);
+        } else {
+            console.log('No image found inside svg.');
+        }
+    });
+    console.log('IMG conversion finished');
+}
+
+
+async function captureElementByCSSToFile(css: string,mode?:string): Promise<string> {
+    // Query the DOM for the first element with the specified class name
+    const element :HTMLElement = document.querySelector(css)!;
+    if (!element) {
+        throw new Error(`Element with selector ${css} not found`);
+    }
+
+
+
+    // Ensure all external images have the crossOrigin attribute set
+   
+    try {
+        convertSVGTagstoIMG(element)
+        const images:NodeListOf<HTMLImageElement>  = element.querySelectorAll('img[src]') ;
+        images.forEach((img) => {
+            if (!img.crossOrigin) {
+                img.crossOrigin = 'anonymous';
+            }
+        });
+    
+        let originalStyles 
+        let children : NodeListOf<HTMLElement> = element.querySelectorAll('*');
+        let originalChildStyles:{element: HTMLElement, backgroundColor: string, color: string}[] = [];
+if (mode=='whiteBackground'){
+originalStyles= {
+            backgroundColor: element.style.backgroundColor,
+            color: element.style.color
+        };
+    
+
+        // Reverse the dark mode styles
+        element.style.backgroundColor = 'white';
+        element.style.color = 'black';
+    
+        // Apply the same style changes to all children, and backup the original
+
+    
+        children.forEach(child => {
+            originalChildStyles.push({
+                element: child,
+                backgroundColor: child.style.backgroundColor,
+                color: child.style.color
+            });
+            child.style.backgroundColor = 'white';
+            child.style.color = 'black';
+        });
+}
+
+    
+
+
+
+        // Capture the element using html2canvas with useCORS option
+        const canvas = await html2canvas(element, { 
+            useCORS: true,
+            logging: true,
+            backgroundColor: '#ffffff',
+            allowTaint: true ,
+            scale:2.5
+        });
+
+        // Convert the canvas to Base64 image
+        let imageBase64 = canvas.toDataURL("image/jpeg");
+
+        if (mode=='whiteBackground'){
+        // Revert to the original styles
+        element.style.backgroundColor = originalStyles.backgroundColor;
+        element.style.color = originalStyles.color;
+    
+        // Revert the styles of all children
+        originalChildStyles.forEach(({ element, backgroundColor, color }) => {
+            element.style.backgroundColor = backgroundColor;
+            element.style.color = color;
+        });
+    }
+
+
+        return imageBase64;
+    } catch (error) {
+        throw new Error(`Failed to capture legend screenshot: ${(error as Error).message}`);
+    }
+}
+
+
+/**
+ * @displayName HTMLextractor
+ * @category Custom Activities
+ * @description Extract screenshot or attribute of HTML component by a css selector
+ */
+export default class HTMLextractorActivity implements IActivityHandler {
+    /** Perform the execution logic of the activity. */
+    async execute(inputs: HTMLextractorInputs): Promise<HTMLextractorOutputs> {
+
+        const element :HTMLElement = document.querySelector(inputs.selector)!;
+        console.log('HTML element:')
+        console.log(element)
+        let result
+        if (!element) {
+            throw new Error(`Element with query: ' ${inputs.selector} ' not found`);
+        }
+        if(inputs.request=='getProperty'){
+           const computedStyle = window.getComputedStyle(element); 
+            result=inputs.value? computedStyle[inputs.value]:'cannot get property'
+        }
+        else if(inputs.request=='getImage'){
+           result = await captureElementByCSSToFile(inputs.selector,inputs.value);
+        } 
+
+        return {
+            result: result
+        };
+    }
+}