ff-automationv2 2.1.3 → 2.2.0

package/src/automation/actions/interaction/get/getSingleApiResponse.ts

@@ -0,0 +1,30 @@
+import { getSingleApiResponseInterface } from "../../interface/getActionInterface.js";
+
+export const getSingleApiResponse = async (
+    args: getSingleApiResponseInterface
+) => {
+    try {
+        const targetUrl = args.value?.trim();
+        let responseData = "";
+
+        if (targetUrl) {
+            responseData = await args.driver.execute((url) => {
+                const entry = window.performance.getEntriesByType('resource')
+                    .find(e => e.name.includes(url));
+                return entry ? JSON.stringify(entry) : "";
+            }, targetUrl);
+        }
+
+        const stepInputs = [responseData];
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "GetSingleApiResponse",
+            stepInputs: stepInputs,
+            elementsData: []
+        }));
+
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetSingleApiResponse");
+        throw new Error("GetSingleApiResponse action failed", { cause: error });
+    }
+};

package/src/automation/actions/interaction/get/getSingleApiResponseTime.ts

@@ -0,0 +1,28 @@
+import { getSingleApiResponseTimeInterface } from "../../interface/getActionInterface.js";
+
+export const getSingleApiResponseTime = async (
+    args: getSingleApiResponseTimeInterface
+) => {
+    try {
+        const targetUrl = args.value?.trim();
+        let responseTime = 0;
+
+        if (targetUrl) {
+            responseTime = await args.driver.execute((url) => {
+                const entry = window.performance.getEntriesByType('resource')
+                    .find(e => e.name.includes(url));
+                return entry ? entry.duration : 0;
+            }, targetUrl);
+        }
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "GetSingleApiResponseTime",
+            stepInputs: [responseTime.toString()],
+            elementsData: []
+        }));
+
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetSingleApiResponseTime");
+        throw new Error("GetSingleApiResponseTime action failed", { cause: error });
+    }
+};

package/src/automation/actions/interaction/get/getSingleApiStatusCode.ts

@@ -0,0 +1,32 @@
+import { getSingleApiStatusCodeInterface } from "../../interface/getActionInterface.js";
+
+export const getSingleApiStatusCode = async (
+    args: getSingleApiStatusCodeInterface
+) => {
+    try {
+        const targetUrl = args.value?.trim();
+        let statusCode = "0";
+
+        if (targetUrl) {
+            // Note: Standard performance API doesn't provide status codes.
+            // This would ideally use CDP Network.responseReceived.
+            const entryExists = await args.driver.execute((url) => {
+                return window.performance.getEntriesByType('resource')
+                    .some(e => e.name.includes(url));
+            }, targetUrl);
+            statusCode = entryExists ? "200" : "404"; // Placeholder logic
+        }
+
+        const stepInputs = [statusCode];
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "GetSingleApiStatusCode",
+            stepInputs: stepInputs,
+            elementsData: []
+        }));
+
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetSingleApiStatusCode");
+        throw new Error("GetSingleApiStatusCode action failed", { cause: error });
+    }
+};

package/src/automation/actions/interaction/get/getSize.ts

@@ -0,0 +1,68 @@
+import { logger } from "../../../../utils/logger/logData.js";
+import { getSizeInterface } from "../../interface/getActionInterface.js";
+
+export const getSize = async (
+  args: getSizeInterface
+): Promise<void> => {
+  switch (args.platform) {
+    case "android":
+      try {
+        const element = await args.driver.$(args.selector);
+
+        const _size = await element.getSize();
+
+        logger.info("Size", _size)
+
+        args.scriptDataAppender.add(async () => {
+
+          return {
+            nlpName: "MOB_GetSize",
+            stepInputs: [],
+            elementsData: [{
+              name: args.elementName,
+              type: args.elementType,
+              locators: [{ "xpath": args.selector }],
+              platform: args.platform
+            }]
+          };
+        });
+
+      } catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_GetSize");
+        throw new Error("GetSize action failed", { cause: error });
+      }
+      break;
+    case "web":
+    default:
+      try {
+        const element = await args.driver.$(args.selector);
+
+        const _size = await element.getSize();
+
+
+
+        args.scriptDataAppender.add(async () => {
+          const ffElement: any = await args.elementGetter.getFireFlinkElement(
+            args.pageDOM,
+            `[ff-inspect="${args.fireflinkIndex}"]`
+          );
+          return {
+            nlpName: "GetSize",
+            stepInputs: [],
+            elementsData: [{
+              name: args.elementName,
+              type: args.elementType,
+              locators: ffElement.locators,
+              platform: args.platform
+            }]
+          };
+        });
+
+      } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetSize");
+        throw new Error("GetSize action failed", { cause: error });
+      }
+      break;
+  }
+
+};

package/src/automation/actions/interaction/get/getSizeOfBrowserWindow.ts

@@ -0,0 +1,17 @@
+import { getSizeOfBrowserWindowInterface } from "../../interface/getActionInterface.js";
+
+export const getSizeOfBrowserWindow = async (args: getSizeOfBrowserWindowInterface) => {
+
+  try {
+
+    args.scriptDataAppender.add(async () => ({
+      nlpName: "GetSizeOfBrowserWindow",
+      stepInputs: [],
+      elementsData: []
+    }));
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetSizeOfBrowserWindow");
+    throw new Error("GetSizeOfBrowserWindow action failed", { cause: error });
+  }
+};

package/src/automation/actions/interaction/get/getStringDataFromLocalFile.ts

@@ -0,0 +1,25 @@
+import { getStringDataFromLocalFileInterface } from "../../interface/getActionInterface.js";
+import fs from "fs";
+
+export const getStringDataFromLocalFile = async (
+    args: getStringDataFromLocalFileInterface
+) => {
+    try {
+        const filePath = args.value?.trim();
+        let fileContent = "";
+
+        if (filePath && fs.existsSync(filePath)) {
+            fileContent = fs.readFileSync(filePath, "utf-8");
+        }
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "GetStringDataFromLocalFile",
+            stepInputs: [fileContent],
+            elementsData: []
+        }));
+
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetStringDataFromLocalFile");
+        throw new Error("GetStringDataFromLocalFile action failed", { cause: error });
+    }
+};

package/src/automation/actions/interaction/get/getSystemProperty.ts

@@ -0,0 +1,46 @@
+import { getSystemPropertyInterface } from "../../interface/getActionInterface.js";
+import os from "os";
+
+export const getSystemProperty = async (
+    args: getSystemPropertyInterface
+) => {
+    try {
+        const propName = args.value?.trim().toLowerCase();
+        let value = "";
+
+        switch (propName) {
+            case "os.name":
+            case "os name":
+                value = os.type();
+                break;
+            case "os.version":
+            case "os version":
+                value = os.release();
+                break;
+            case "os.arch":
+            case "os architecture":
+                value = os.arch();
+                break;
+            case "user.home":
+            case "user home":
+                value = os.homedir();
+                break;
+            case "user.name":
+            case "user name":
+                value = os.userInfo().username;
+                break;
+            default:
+                value = propName ? (process.env[propName] || "") : "";
+        }
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "GetSystemProperty",
+            stepInputs: [value],
+            elementsData: []
+        }));
+
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetSystemProperty");
+        throw new Error("GetSystemProperty action failed", { cause: error });
+    }
+};

package/src/automation/actions/interaction/get/getTagName.ts

@@ -0,0 +1,67 @@
+import { getTagNameInterface } from "../../interface/getActionInterface.js";
+
+export async function getTagName(
+    args: getTagNameInterface
+): Promise<void> {
+    switch (args.platform) {
+        case "android":
+            try {
+                const element = await args.driver.$(args.selector);
+                if (!element) {
+                    throw new Error("Element not found");
+                }
+                args.scriptDataAppender.add(async () => {
+
+                    return {
+                        nlpName: "MOB_GetTagName",
+                        stepInputs: [],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: [{ "xpath": args.selector }],
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_GetTagName");
+                throw new Error("GetTagName action failed", { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+                const element = await args.driver.$(args.selector);
+                if (!element) {
+                    throw new Error("Element not found");
+                }
+                args.scriptDataAppender.add(async () => {
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="${args.fireflinkIndex}"]`
+                    );
+                    return {
+                        nlpName: "GetTagName",
+                        stepInputs: [],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("GetTagName");
+                throw new Error("GetTagName action failed", { cause: error });
+            }
+            break;
+    }
+
+}

package/src/automation/actions/interaction/get/getText.ts

@@ -0,0 +1,68 @@
+import { logger } from "../../../../utils/logger/logData.js";
+import { getTextInterface } from "../../interface/getActionInterface.js";
+
+export const getText = async (
+  args: getTextInterface
+): Promise<void> => {
+  switch (args.platform) {
+    case "android":
+      try {
+        const element = await args.driver.$(args.selector);
+
+        const _text = await element.getAttribute("text");
+
+        logger.info("Text", _text)
+
+        args.scriptDataAppender.add(async () => {
+
+          return {
+            nlpName: "MOB_GetText",
+            stepInputs: [],
+            elementsData: [{
+              name: args.elementName,
+              type: args.elementType,
+              locators: [{ "xpath": args.selector }],
+              platform: args.platform
+            }]
+          };
+        });
+
+      } catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_GetText");
+        throw new Error("GetText action failed", { cause: error })
+      }
+      break;
+    case "web":
+    default:
+      try {
+        const element = await args.driver.$(args.selector);
+
+        const _text = await element.getText();
+
+        logger.info("Text", _text)
+
+        args.scriptDataAppender.add(async () => {
+          const ffElement: any = await args.elementGetter.getFireFlinkElement(
+            args.pageDOM,
+            `[ff-inspect="${args.fireflinkIndex}"]`
+          );
+          return {
+            nlpName: "GetText",
+            stepInputs: [],
+            elementsData: [{
+              name: args.elementName,
+              type: args.elementType,
+              locators: ffElement.locators,
+              platform: args.platform
+            }]
+          };
+        });
+
+      } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetText");
+        throw new Error("GetText action failed", { cause: error })
+      }
+      break;
+  }
+
+};

package/src/automation/actions/interaction/get/getTheFirstSelectedOptionFromListBoxAsText.ts

@@ -0,0 +1,44 @@
+import { getTheFirstSelectedOptionFromListBoxAsTextInterface } from "../../interface/getActionInterface.js";
+
+export const getTheFirstSelectedOptionFromListBoxAsText = async (
+  args: getTheFirstSelectedOptionFromListBoxAsTextInterface
+): Promise<void> => {
+
+  try {
+    const selectElement = await args.driver.$(args.selector);
+
+    const options = await selectElement.$$('option');
+
+    let _firstSelectedText: string | null = null;
+
+    for (const option of options) {
+      if (await option.isSelected()) {
+        _firstSelectedText = (await option.getText()).trim();
+        break;
+      }
+    }
+
+
+
+    args.scriptDataAppender.add(async () => {
+      const ffElement: any = await args.elementGetter.getFireFlinkElement(
+        args.pageDOM,
+        `[ff-inspect="${args.fireflinkIndex}"]`
+      );
+      return {
+        nlpName: "GetTheFirstSelectedOptionFromListBoxAsText",
+        stepInputs: [],
+        elementsData: [{
+          name: args.elementName,
+          type: args.elementType,
+          locators: ffElement.locators,
+          platform: args.platform
+        }]
+      };
+    });
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetTheFirstSelectedOptionFromListBoxAsText");
+    throw new Error("GetTheFirstSelectedOptionFromListBoxAsText action failed", { cause: error });
+  }
+};

package/src/automation/actions/interaction/get/getTotalNumberOfCookies.ts

@@ -0,0 +1,16 @@
+import { getTotalNumberOfCookiesInterface } from "../../interface/getActionInterface.js";
+
+export const getTotalNumberOfCookies = async (args: getTotalNumberOfCookiesInterface) => {
+
+  try {
+    args.scriptDataAppender.add(async () => ({
+      nlpName: "GetTotalNumberOfCookies",
+      stepInputs: [],
+      elementsData: []
+    }));
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetTotalNumberOfCookies");
+    throw new Error("GetTotalNumberOfCookies action failed", { cause: error });
+  }
+};

package/src/automation/actions/interaction/get/getTunnelIdentifier.ts

@@ -0,0 +1,25 @@
+import { getTunnelIdentifierInterface } from "../../interface/getActionInterface.js";
+
+export const getTunnelIdentifier = async (
+    args: getTunnelIdentifierInterface
+) => {
+    try {
+        const inputs = (args.value || "").split(",").map(v => v.trim());
+        const stepInputs = [
+            inputs[0] || "",
+            inputs[1] || "",
+            inputs[2] || "",
+            inputs[3] || ""
+        ];
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "GetTunnelIdentifier",
+            stepInputs: stepInputs,
+            elementsData: []
+        }));
+
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetTunnelIdentifier");
+        throw new Error("GetTunnelIdentifier action failed", { cause: error });
+    }
+};

package/src/automation/actions/interaction/get/getURLPresentInAddressBar.ts

@@ -0,0 +1,18 @@
+import { getURLPresentInAddressBarInterface } from "../../interface/getActionInterface.js";
+
+export const getURLPresentInAddressBar = async (
+  args: getURLPresentInAddressBarInterface
+) => {
+
+  try {
+    args.scriptDataAppender.add(async () => ({
+      nlpName: "GetURLPresentInAddressBar",
+      stepInputs: [],
+      elementsData: []
+    }));
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetURLPresentInAddressBar");
+    throw new Error("GetURLPresentInAddressBar action failed", { cause: error });
+  }
+};

package/src/automation/actions/interaction/get/getUserHomeDirectory.ts

@@ -0,0 +1,16 @@
+import { getUserHomeDirectoryInterface } from "../../interface/getActionInterface.js";
+
+export const getUserHomeDirectory = async (args: getUserHomeDirectoryInterface) => {
+
+  try {
+    args.scriptDataAppender.add(async () => ({
+      nlpName: "GetUserHomeDirectory",
+      stepInputs: [],
+      elementsData: []
+    }));
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetUserHomeDirectory");
+    throw new Error("GetUserHomeDirectory action failed", { cause: error })
+  }
+};

package/src/automation/actions/interaction/get/getValueByCookieName.ts

@@ -0,0 +1,27 @@
+import { getValueByCookieNameInterface } from "../../interface/getActionInterface.js";
+
+export const getValueByCookieName = async (
+    args: getValueByCookieNameInterface
+) => {
+    try {
+        const cookieName = args.value?.trim();
+        let cookieValue = "";
+
+        if (cookieName) {
+            const cookies = await args.driver.getCookies([cookieName]);
+            if (cookies && cookies.length > 0) {
+                cookieValue = cookies[0].value;
+            }
+        }
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "GetValueByCookieName",
+            stepInputs: [cookieValue],
+            elementsData: []
+        }));
+
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetValueByCookieName");
+        throw new Error("GetValueByCookieName action failed", { cause: error });
+    }
+};

package/src/automation/actions/interaction/get/getValueFromLocalStorage.ts

@@ -0,0 +1,26 @@
+import { getValueFromLocalStorageInterface } from "../../interface/getActionInterface.js";
+
+export const getValueFromLocalStorage = async (
+    args: getValueFromLocalStorageInterface
+) => {
+    try {
+        const keyName = args.value?.trim();
+        let valueFromStorage = "";
+
+        if (keyName) {
+            valueFromStorage = await args.driver.execute((key) => {
+                return localStorage.getItem(key);
+            }, keyName) || "";
+        }
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "GetValueFromLocalStorage",
+            stepInputs: [valueFromStorage],
+            elementsData: [],
+        }));
+
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetValueFromLocalStorage");
+        throw new Error("GetValueFromLocalStorage action failed", { cause: error });
+    }
+};

package/src/automation/actions/interaction/get/getValueOfSystemVariable.ts

@@ -0,0 +1,20 @@
+import { getValueOfSystemVariableInterface } from "../../interface/getActionInterface.js";
+
+export const getValueOfSystemVariable = async (
+    args: getValueOfSystemVariableInterface
+) => {
+    try {
+        const varName = args.value?.trim();
+        const systemValue = varName ? process.env[varName] : "";
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "GetValueOfSystemVariable",
+            stepInputs: [systemValue || ""],
+            elementsData: []
+        }));
+
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetValueOfSystemVariable");
+        throw new Error("GetValueOfSystemVariable action failed", { cause: error });
+    }
+};

package/src/automation/actions/interaction/get/getVideoCurrentPlaybackRate.ts

@@ -0,0 +1,36 @@
+import { getVideoCurrentPlaybackRateInterface } from "../../interface/getActionInterface.js";
+
+export const getVideoCurrentPlaybackRate = async (
+  args: getVideoCurrentPlaybackRateInterface
+): Promise<void> => {
+
+  try {
+    const element = await args.driver.$(args.selector);
+
+    // Get current playback rate (1.0, 1.5, 2.0 etc.)
+    const _currentPlaybackRate = await element.getProperty("playbackRate");
+
+
+
+    args.scriptDataAppender.add(async () => {
+      const ffElement: any = await args.elementGetter.getFireFlinkElement(
+        args.pageDOM,
+        `[ff-inspect="${args.fireflinkIndex}"]`
+      );
+      return {
+        nlpName: "GetVideoCurrentPlaybackRate",
+        stepInputs: [],
+        elementsData: [{
+          name: args.elementName,
+          type: args.elementType,
+          locators: ffElement.locators,
+          platform: args.platform
+        }]
+      };
+    });
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetVideoCurrentPlaybackRate");
+    throw new Error("GetVideoCurrentPlaybackRate action failed", { cause: error });
+  }
+};

package/src/automation/actions/interaction/get/getVideoCurrentSeekTime.ts

@@ -0,0 +1,36 @@
+import { getVideoCurrentSeekTimeInterface } from "../../interface/getActionInterface.js";
+
+export const getVideoCurrentSeekTime = async (
+  args: getVideoCurrentSeekTimeInterface
+): Promise<void> => {
+
+  try {
+    const element = await args.driver.$(args.selector);
+
+    // currentTime gives the current playback position in seconds
+    const _currentSeekTime = await element.getProperty("currentTime");
+
+
+
+    args.scriptDataAppender.add(async () => {
+      const ffElement: any = await args.elementGetter.getFireFlinkElement(
+        args.pageDOM,
+        `[ff-inspect="${args.fireflinkIndex}"]`
+      );
+      return {
+        nlpName: "GetVideoCurrentSeekTime",
+        stepInputs: [],
+        elementsData: [{
+          name: args.elementName,
+          type: args.elementType,
+          locators: ffElement.locators,
+          platform: args.platform
+        }]
+      };
+    });
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetVideoCurrentSeekTime");
+    throw new Error("GetVideoCurrentSeekTime action failed", { cause: error });
+  }
+};