vku-sdk 1.0.0

package/src/modules/enrollment/requests/index.ts

@@ -0,0 +1,4 @@
+export * from "./get-subject-classes.request";
+export * from "./register-subject-class.request";
+export * from "./unregister-subject-class.request";
+export * from "./get-registered-subject-class.request";

package/src/modules/enrollment/requests/register-subject-class.request.ts

@@ -0,0 +1,21 @@
+import { BaseRequest, HttpMethod, HttpRequest, IParser } from "../../../core";
+import { ClassSession, CourseSection, SubjectActionResponse } from "../domain";
+import { ClassSessionParser } from "../parsers";
+
+export class RegisterSubjectClassRequest extends BaseRequest<ClassSession[]> {
+  constructor(private courseSection: CourseSection) {
+    super();
+  }
+  buildRequest(): HttpRequest {
+    return new HttpRequest(
+      HttpMethod.GET,
+      "/sv/dang-ky-tung-lophp",
+      {},
+      undefined,
+      this.courseSection.parseToRegistrationPayload(),
+    );
+  }
+  getParser(): IParser<ClassSession[]> {
+    return new ClassSessionParser();
+  }
+}

package/src/modules/enrollment/requests/unregister-subject-class.request.ts

@@ -0,0 +1,24 @@
+import { BaseRequest, HttpMethod, HttpRequest, IParser } from "../../../core";
+import { ClassSession } from "../domain";
+import { ClassSessionParser } from "../parsers";
+
+export class UnregisterSubjectClassRequest extends BaseRequest<ClassSession[]> {
+  constructor(public readonly classRegistrationId: number) {
+    super();
+  }
+  buildRequest(): HttpRequest {
+    return new HttpRequest(
+      HttpMethod.GET,
+      `/sv/xoa-dang-ky-tung-lophp`,
+      {},
+      undefined,
+      {
+        id: this.classRegistrationId,
+      },
+    );
+  }
+
+  getParser(): IParser<ClassSession[]> {
+    return new ClassSessionParser();
+  }
+}

package/src/modules/index.ts

@@ -0,0 +1,3 @@
+export * from "./accounts";
+export * from "./enrollment";
+export * from "./shared";

package/src/modules/shared/index.ts

@@ -0,0 +1,2 @@
+export * from "./parsers";
+export * from "./infra";

package/src/modules/shared/infra/chrome-wrapper.ts

@@ -0,0 +1,380 @@
+import CDP from "chrome-remote-interface";
+
+interface NavigationOptions {
+  timeout?: number;
+  waitUntil?: "load" | "domcontentloaded" | "networkidle";
+}
+
+interface WaitForSelectorOptions {
+  timeout?: number;
+  visible?: boolean;
+}
+
+export class ChromeWrapper {
+  private client: CDP.Client | null = null;
+  private navigationPromise: Promise<void> | null = null;
+
+  async connect(options?: CDP.Options): Promise<void> {
+    this.client = await CDP(options);
+    const { Page, Runtime, DOM, Network } = this.client;
+
+    await Promise.all([
+      Page.enable(),
+      Runtime.enable(),
+      DOM.enable(),
+      Network.enable(),
+    ]);
+  }
+
+  async disconnect(): Promise<void> {
+    if (this.client) {
+      await this.client.close();
+      this.client = null;
+    }
+  }
+
+  async navigate(url: string, options: NavigationOptions = {}): Promise<void> {
+    if (!this.client) throw new Error("Not connected");
+
+    const { timeout = 30000, waitUntil = "load" } = options;
+    const { Page } = this.client;
+
+    try {
+      this.navigationPromise = this.waitForNavigation(waitUntil, timeout);
+
+      await Page.navigate({ url });
+
+      await this.navigationPromise;
+    } catch (error) {
+      throw new Error(`Navigation to ${url} failed: ${error}`);
+    } finally {
+      this.navigationPromise = null;
+    }
+  }
+
+  private waitForNavigation(waitUntil: string, timeout: number): Promise<void> {
+    if (!this.client) throw new Error("Not connected");
+
+    const { Page, Network } = this.client;
+
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        reject(new Error("Navigation timeout"));
+      }, timeout);
+
+      const cleanup = () => {
+        clearTimeout(timeoutId);
+      };
+
+      if (waitUntil === "load") {
+        Page.loadEventFired(() => {
+          cleanup();
+          resolve();
+        });
+      } else if (waitUntil === "domcontentloaded") {
+        Page.domContentEventFired(() => {
+          cleanup();
+          resolve();
+        });
+      } else if (waitUntil === "networkidle") {
+        let idleTimeout: NodeJS.Timeout;
+        let requestCount = 0;
+
+        const checkIdle = () => {
+          if (requestCount === 0) {
+            clearTimeout(idleTimeout);
+            idleTimeout = setTimeout(() => {
+              cleanup();
+              resolve();
+            }, 500);
+          }
+        };
+
+        Network.requestWillBeSent(() => {
+          requestCount++;
+        });
+
+        Network.loadingFinished(() => {
+          requestCount--;
+          checkIdle();
+        });
+
+        Network.loadingFailed(() => {
+          requestCount--;
+          checkIdle();
+        });
+      }
+    });
+  }
+
+  async waitForSelector(
+    selector: string,
+    options: WaitForSelectorOptions = {},
+  ): Promise<number> {
+    if (!this.client) throw new Error("Not connected");
+
+    const { timeout = 30000, visible = true } = options;
+    const { Runtime, DOM } = this.client;
+
+    const startTime = Date.now();
+
+    while (Date.now() - startTime < timeout) {
+      try {
+        const result = await Runtime.evaluate({
+          expression: `document.querySelector('${selector}')`,
+          returnByValue: false,
+        });
+
+        if (result.result.objectId) {
+          const { node } = await DOM.describeNode({
+            objectId: result.result.objectId,
+          });
+
+          if (visible) {
+            const isVisible = await this.isElementVisible(
+              result.result.objectId,
+            );
+            if (isVisible) {
+              return node.backendNodeId;
+            }
+          } else {
+            return node.backendNodeId;
+          }
+        }
+      } catch (error) {
+        // Ignore errors and retry
+      }
+
+      await this.sleep(100);
+    }
+
+    throw new Error(`Timeout waiting for selector: ${selector}`);
+  }
+
+  /**
+   * Kiểm tra element có visible không
+   */
+  private async isElementVisible(objectId: string): Promise<boolean> {
+    if (!this.client) throw new Error("Not connected");
+
+    const { Runtime } = this.client;
+
+    const result = await Runtime.callFunctionOn({
+      objectId,
+      functionDeclaration: `function() {
+        const rect = this.getBoundingClientRect();
+        const style = window.getComputedStyle(this);
+        return rect.width > 0 &&
+               rect.height > 0 &&
+               style.visibility !== 'hidden' &&
+               style.display !== 'none';
+      }`,
+      returnByValue: true,
+    });
+
+    return result.result.value === true;
+  }
+
+  async click(
+    selector: string,
+    options: WaitForSelectorOptions = {},
+  ): Promise<void> {
+    if (!this.client) throw new Error("Not connected");
+
+    await this.waitForSelector(selector, options);
+
+    const { Runtime } = this.client;
+
+    const result = await Runtime.evaluate({
+      expression: `
+        (function() {
+          const element = document.querySelector('${selector}');
+          if (!element) throw new Error('Element not found');
+          element.click();
+          return true;
+        })()
+      `,
+      returnByValue: true,
+    });
+
+    if (result.exceptionDetails) {
+      throw new Error(
+        `Click failed ${result.exceptionDetails.exception?.description}`,
+      );
+    }
+  }
+
+  async fill(
+    selector: string,
+    text: string,
+    options: WaitForSelectorOptions = {},
+  ): Promise<void> {
+    if (!this.client) throw new Error("Not connected");
+
+    await this.waitForSelector(selector, options);
+
+    const { Runtime } = this.client;
+
+    await Runtime.evaluate({
+      expression: `
+        (function() {
+          const element = document.querySelector('${selector}');
+          if (!element) throw new Error('Element not found');
+          element.value = '';
+          element.dispatchEvent(new Event('input', { bubbles: true }));
+        })()
+      `,
+    });
+
+    const escapedText = text.replace(/'/g, "\\'").replace(/\n/g, "\\n");
+
+    const result = await Runtime.evaluate({
+      expression: `
+        (function() {
+          const element = document.querySelector('${selector}');
+          if (!element) throw new Error('Element not found');
+          element.value = '${escapedText}';
+          element.dispatchEvent(new Event('input', { bubbles: true }));
+          element.dispatchEvent(new Event('change', { bubbles: true }));
+          return true;
+        })()
+      `,
+      returnByValue: true,
+    });
+
+    if (result.exceptionDetails) {
+      throw new Error(
+        `Fill failed: ${result.exceptionDetails.exception?.description}`,
+      );
+    }
+  }
+
+  async getText(
+    selector: string,
+    options: WaitForSelectorOptions = {},
+  ): Promise<string> {
+    if (!this.client) throw new Error("Not connected");
+
+    await this.waitForSelector(selector, options);
+
+    const { Runtime } = this.client;
+
+    const result = await Runtime.evaluate({
+      expression: `
+        (function() {
+          const element = document.querySelector('${selector}');
+          if (!element) throw new Error('Element not found');
+          return element.textContent || element.innerText || '';
+        })()
+      `,
+      returnByValue: true,
+    });
+
+    if (result.exceptionDetails) {
+      throw new Error(
+        `Get text failed: ${result.exceptionDetails.exception?.description}`,
+      );
+    }
+
+    return result.result.value as string;
+  }
+
+  async getAttribute(
+    selector: string,
+    attribute: string,
+    options: WaitForSelectorOptions = {},
+  ): Promise<string | null> {
+    if (!this.client) throw new Error("Not connected");
+
+    await this.waitForSelector(selector, options);
+
+    const { Runtime } = this.client;
+
+    const result = await Runtime.evaluate({
+      expression: `
+        (function() {
+          const element = document.querySelector('${selector}');
+          if (!element) throw new Error('Element not found');
+          return element.getAttribute('${attribute}');
+        })()
+      `,
+      returnByValue: true,
+    });
+
+    if (result.exceptionDetails) {
+      throw new Error(
+        `Get attribute failed: ${result.exceptionDetails.exception?.description}`,
+      );
+    }
+
+    return result.result.value as string | null;
+  }
+
+  async screenshot(
+    options: { path?: string; fullPage?: boolean } = {},
+  ): Promise<string> {
+    if (!this.client) throw new Error("Not connected");
+
+    const { Page } = this.client;
+    const { fullPage = false } = options;
+
+    const screenshot = await Page.captureScreenshot({
+      format: "png",
+      captureBeyondViewport: fullPage,
+    });
+
+    return screenshot.data;
+  }
+
+  async evaluate<T>(
+    fn: string | ((...args: any[]) => T),
+    ...args: any[]
+  ): Promise<T> {
+    if (!this.client) throw new Error("Not connected");
+
+    const { Runtime } = this.client;
+
+    const expression =
+      typeof fn === "function"
+        ? `(${fn.toString()})(${args.map((arg) => JSON.stringify(arg)).join(",")})`
+        : fn;
+
+    const result = await Runtime.evaluate({
+      expression,
+      returnByValue: true,
+      awaitPromise: true,
+    });
+
+    if (result.exceptionDetails) {
+      throw new Error(
+        `Evaluate failed: ${result.exceptionDetails.exception?.description}`,
+      );
+    }
+
+    return result.result.value as T;
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  async wait(ms: number): Promise<void> {
+    await this.sleep(ms);
+  }
+  async reload(options: NavigationOptions = {}): Promise<void> {
+    if (!this.client) throw new Error("Not connected");
+
+    const { timeout = 30000, waitUntil = "load" } = options;
+    const { Page } = this.client;
+
+    try {
+      this.navigationPromise = this.waitForNavigation(waitUntil, timeout);
+      await Page.reload();
+      await this.navigationPromise;
+    } catch (error) {
+      throw new Error(`Reload failed: ${error}`);
+    } finally {
+      this.navigationPromise = null;
+    }
+  }
+}

package/src/modules/shared/infra/index.ts

@@ -0,0 +1 @@
+export * from "./chrome-wrapper";