automation_model 1.0.0

package/bin/auto_page.js

@@ -0,0 +1,64 @@
+import { getContext } from "./init_browser.js";
+import { StableBrowser } from "./stable_browser.js";
+class AutoPage {
+  constructor() {
+    this.name = null;
+    this.path = null;
+    this.elements = {};
+    this.context = null;
+    this.login_required = false;
+    this.url_navigate = true;
+    this.stable = null;
+  }
+
+  /**
+   * Add element to the elements dictionary
+   * @param {string} name - Name of the element
+   * @param {string} locator - Locator of the element
+   * @returns {void}
+   * @memberof Page
+   * @example
+   * page.addElement('username', 'input[name="username"]');
+   */
+  addElement(name, locator) {
+    this.elements[name] = locator;
+  }
+  /**
+   * init context
+   */
+  static async init(navigate = true) {
+    const instance = new this();
+    instance.context = await getContext();
+    instance.page = instance.context.page;
+    instance.browser = instance.context.browser;
+    instance.stable = instance.context.stable;
+    if (navigate) {
+      await instance.navigate();
+    }
+    return instance;
+  }
+  static async initFromContext(context, navigate = true) {
+    const instance = new this();
+    instance.context = context;
+    instance.page = instance.context.page;
+    instance.browser = instance.context.browser;
+    instance.environment = instance.context.environment;
+    instance.stable = instance.context.stable;
+    if (navigate) {
+      await instance.navigate();
+    }
+    return instance;
+  }
+
+  /**
+   * Navigate to the page
+   * synchronize waiting the page to be loaded
+   * @param {Environment} environment - Environment object
+   */
+  async navigate() {
+    //console.log("navigate", this.context.environment.baseUrl + this.path);
+    await this.stable.goto(this.context.environment.baseUrl + this.path);
+    await this.stable.waitForPageLoad();
+  }
+}
+export default AutoPage;

package/bin/browser_manager.js

@@ -0,0 +1,85 @@
+import { chromium } from "playwright";
+class BrowserManager {
+  constructor() {
+    this.browsers = [];
+  }
+
+  async closeAll() {
+    await Promise.all(this.browsers.map((browser) => browser.close()));
+    this.browsers = [];
+  }
+  async closeBrowser(browser) {
+    if (browser !== null) {
+      await browser.close();
+      for (let i = 0; i < this.browsers.length; i++) {
+        if (
+          this.browsers[i].browser === browser ||
+          this.browsers[i] === browser
+        ) {
+          this.browsers.splice(i, 1);
+          i--;
+          break;
+        }
+      }
+    }
+  }
+
+  async createBrowser() {
+    const browser = new Browser();
+    await browser.init();
+    this.browsers.push(browser);
+    return browser;
+  }
+  async getBrowser() {
+    if (this.browsers.length === 0) {
+      return await this.createBrowser();
+    }
+    return this.browsers[0];
+  }
+}
+class Browser {
+  constructor() {
+    this.browser = null;
+    this.context = null;
+    this.page = null;
+  }
+
+  async init() {
+    //let port = 9222;
+    this.browser = await chromium.launch({
+      headless: false,
+      timeout: 0,
+      //args: ["--remote-debugging-port=" + port],
+    });
+    // const cdpBrowser = await chromium.connectOverCDP({
+    //   endpointURL: `http://127.0.0.1:${port}/`,
+    // });
+    // //let context = await browser.newContext();
+    // const context = cdpBrowser.contexts()[0];
+    // let page = await context.newPage();
+    // page.goto("https://www.cnn.com");
+    this.context = await this.browser.newContext();
+    this.page = await this.context.newPage();
+    //console.log("browser", this.browser);
+  }
+
+  async close() {
+    if (this.browser !== null) {
+      await this.browser.close();
+      this.browser = null;
+      this.context = null;
+      this.page = null;
+    }
+  }
+}
+const browserManager = new BrowserManager();
+
+export default browserManager;
+
+// let browser = await browserManager.createBrowser();
+// browser.page.goto("https://www.cnn.com");
+// let browser2 = await browserManager.createBrowser();
+// await browser2.page.goto("https://www.google.com");
+// // sleep for 2 seconds
+// await new Promise((r) => setTimeout(r, 1000));
+// await browserManager.closeAll();

package/bin/environment.js

@@ -0,0 +1,9 @@
+class Environment {
+  constructor() {
+    this.baseUrl = null;
+  }
+  setBaseUrl(url) {
+    this.baseUrl = url;
+  }
+}
+export default Environment;

package/bin/init_browser.js

@@ -0,0 +1,59 @@
+import fs from "node:fs";
+import Environment from "./environment.js";
+import browserManager from "./browser_manager.js";
+import TestContext from "./test_context.js";
+import { StableBrowser } from "./stable_browser.js";
+
+let environment = null;
+
+// init browser create context and page, if context and page are not null
+const getContext = async function (environment = null) {
+  if (environment === null) {
+    environment = initEnvoronment();
+  }
+  let browser = await browserManager.getBrowser();
+  let context = new TestContext();
+  context.browser = browser.browser;
+  context.playContext = browser.context;
+  context.page = browser.page;
+  context.environment = environment;
+  context.stable = new StableBrowser(context.browser, context.page);
+  await _initCookies(context);
+  return context;
+};
+const _initCookies = async function (context) {
+  if (context.environment.cookies) {
+    const cookies = [];
+    for (let i = 0; i < context.environment.cookies.length; i++) {
+      const cookie = context.environment.cookies[i];
+      if (cookie.expires && cookie.expires == "undefined") {
+        delete cookie.expires;
+      }
+      cookies.push(cookie);
+    }
+    await context.playContext.addCookies(cookies);
+  }
+};
+
+const closeBrowser = async function (browser) {
+  await browserManager.closeBrowser(browser);
+};
+
+const initEnvoronment = function () {
+  if (environment === null) {
+    environment = new Environment();
+    try {
+      const data = fs.readFileSync("env.json", "utf8");
+      //console.log("data", data);
+      const envObject = JSON.parse(data);
+      //console.log("envObject", envObject);
+      Object.assign(environment, envObject);
+      console.log("env", environment);
+    } catch (err) {
+      console.error("Error reading env.json", err);
+    }
+  }
+  return environment;
+};
+
+export { getContext, closeBrowser };

package/bin/stable_browser.js

@@ -0,0 +1,151 @@
+class StableBrowser {
+  constructor(browser, page) {
+    this.browser = browser;
+    this.page = page;
+  }
+
+  async goto(url) {
+    await this.page.goto(url, {
+      timeout: 60000,
+    });
+  }
+  async _locate(selector) {
+    if (selector.startsWith("{")) {
+      try {
+        const locatorObject = JSON.parse(selector);
+        let type = locatorObject.type;
+        if (!type) {
+          type = "css";
+        }
+        switch (type) {
+          case "css":
+            return await this.page.locator(locatorObject.locator);
+          case "role":
+            return await this.page.getByRole(
+              locatorObject.role,
+              locatorObject.options
+            );
+          case "text":
+            return await this.page.getByText(locatorObject.text);
+          default:
+            throw new Error(`Unknown locator type ${type}`);
+        }
+      } catch (e) {
+        console.log("invalid locator object, will try to parse as text");
+      }
+    }
+
+    if (selector.startsWith("TEXT=")) {
+      return await this.page.getByText(selector.substring("TEXT=".length));
+    } else {
+      return await this.page.locator(selector);
+    }
+  }
+
+  async click(selector) {
+    (await this._locate(selector)).click();
+  }
+  async fill(selector, value) {
+    let element = await this._locate(selector);
+    await element.fill(value);
+    await element.dispatchEvent("change");
+  }
+  async clickInTableRow(textInRow, actionLocator) {
+    const row = await page.evaluate(() => {
+      function isVisible(elem) {
+        if (!(elem instanceof Element)) {
+          return false;
+        }
+        const style = getComputedStyle(elem);
+        if (style.display === "none") return false;
+        if (style.visibility !== "visible") return false;
+        if (style.opacity < 0.1) return false;
+        if (
+          elem.offsetWidth +
+            elem.offsetHeight +
+            elem.getBoundingClientRect().height +
+            elem.getBoundingClientRect().width ===
+          0
+        ) {
+          return false;
+        }
+        const elemCenter = {
+          x: elem.getBoundingClientRect().left + elem.offsetWidth / 2,
+          y: elem.getBoundingClientRect().top + elem.offsetHeight / 2,
+        };
+        if (elemCenter.x < 0) return false;
+        if (
+          elemCenter.x >
+          (document.documentElement.clientWidth || window.innerWidth)
+        )
+          return false;
+        if (elemCenter.y < 0) return false;
+        if (
+          elemCenter.y >
+          (document.documentElement.clientHeight || window.innerHeight)
+        ) {
+          return false;
+        }
+        return true;
+      }
+      function isBackgrounElement(element) {
+        let rec = element.getBoundingClientRect();
+        let xCenter = rec.left + rec.width / 2;
+        let yCenter = rec.top + rec.height / 2;
+        let elementAtPoint = document.elementFromPoint(xCenter, yCenter);
+        if (!elementAtPoint) {
+          return false;
+        }
+        if (elementAtPoint.contains(element)) {
+          return false;
+        }
+        // check if the element is the same element or same as parent
+        let toCheck = elementAtPoint;
+        while (toCheck) {
+          if (toCheck === element) {
+            return false;
+          }
+          toCheck = toCheck.parentElement;
+        }
+
+        return true;
+      }
+
+      const rows = table.querySelectorAll('tr, role="row"');
+      let foundRow = null;
+      for (let i = 0; i < rows.length; i++) {
+        const row = rows[i];
+        const rowData = [];
+        const cells = row.querySelectorAll(
+          "td, th, [role='cell'], [role='columnheader']"
+        );
+        cells.forEach((cell) => {
+          if (!isVisible(cell) || isBackgrounElement(cell)) {
+            return;
+          }
+          const text = getTextFromElement(cell);
+          rowData.push(text);
+        });
+        if (rowData.includes(textInRow)) {
+          foundRow = row;
+          break;
+        }
+      }
+      return foundRow;
+    });
+    await foundRow.locator(actionLocator).click();
+  }
+  async waitForPageLoad() {
+    try {
+      await Promise.all([
+        this.page.waitForLoadState("networkidle"),
+        this.page.waitForLoadState("load"),
+        this.page.waitForLoadState("domcontentloaded"),
+      ]);
+    } catch (e) {
+      console.log("waitForPageLoad error, ignored");
+    }
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+  }
+}
+export { StableBrowser };

package/bin/test_context.js

@@ -0,0 +1,9 @@
+class TestContext {
+  constructor() {
+    this.browser = null;
+    this.playContext = null;
+    this.page = null;
+    this.environment = null;
+  }
+}
+export default TestContext;

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "automation_model",
+  "version": "1.0.0",
+  "description": "",
+  "main": "bin/index.js",
+  "type": "module",
+  "directories": {
+    "lib": "lib"
+  },
+  "scripts": {
+    "pack": "mkdir build && mkdir build/bin && cp ./src/auto_page.js ./build/bin/auto_page.js && cp ./src/environment.js ./build/bin/environment.js && cp ./src/browser_manager.js ./build/bin/browser_manager.js && cp ./src/test_context.js ./build/bin/test_context.js && cp ./src/init_browser.js ./build/bin/init_browser.js && cp ./src/stable_browser.js ./build/bin/stable_browser.js && cp ./package.json ./build/package.json",
+    "clean": "rm -rf ./build",
+    "build": "npm run clean && npm run pack"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "playwright": "^1.33.0"
+  }
+}