vku-sdk 1.0.0

package/src/core/http/base-request.ts

@@ -0,0 +1,124 @@
+import { IParser } from "../parser/parser.interface";
+
+export enum HttpMethod {
+  GET = "GET",
+  POST = "POST",
+  PUT = "PUT",
+  DELETE = "DELETE",
+  PATCH = "PATCH",
+}
+
+export class HttpRequest {
+  protected method: HttpMethod;
+  protected url: string;
+  protected headers: Record<string, string>;
+  protected body?: any;
+  protected params: Record<string, string | number>;
+  protected requireAuth: boolean = true;
+  protected noCache: boolean = false;
+  constructor(
+    method: HttpMethod,
+    url: string,
+    headers?: Record<string, string>,
+    body?: any,
+    params?: Record<string, string | number>,
+    noCache: boolean = false,
+  ) {
+    this.method = method;
+    this.url = url;
+    this.headers = headers || {};
+    this.body = body;
+    this.params = params || {};
+    this.noCache = noCache;
+  }
+
+  getMethod(): HttpMethod {
+    return this.method;
+  }
+
+  getUrl(): string {
+    return this.url;
+  }
+
+  getHeaders(): Record<string, string> {
+    return this.headers;
+  }
+
+  getBody(): any {
+    return this.body;
+  }
+
+  getParams(): Record<string, string | number> {
+    const urlObj = new URL(this.url, "http://dummybase");
+    urlObj.searchParams.forEach((value, key) => {
+      if (!(key in this.params)) {
+        this.params[key] = value;
+      }
+    });
+    return this.params;
+  }
+
+  setHeader(key: string, value: string): void {
+    this.headers[key] = value;
+  }
+
+  addCookie(name: string, value: string): void {
+    const cookieString = `${name}=${value}`;
+    if (this.headers["Cookie"]) {
+      this.headers["Cookie"] += `; ${cookieString}`;
+    } else {
+      this.headers["Cookie"] = cookieString;
+    }
+  }
+
+  mergeHeaders(headers: Record<string, string>): void {
+    this.headers = { ...this.headers, ...headers };
+  }
+
+  mergeParams(params: Record<string, string | number>): void {
+    this.params = { ...this.params, ...params };
+  }
+
+  setUrl(url: string): void {
+    this.url = url;
+  }
+
+  setHost(host: string): void {
+    if (this.url.startsWith("http://") || this.url.startsWith("https://")) {
+      const urlObj = new URL(this.url);
+      urlObj.host = host;
+      this.url = urlObj.toString();
+    } else {
+      this.url = `${host}${this.url}`;
+    }
+  }
+
+  turnOffAuth(): void {
+    this.requireAuth = false;
+  }
+
+  isAuthRequired(): boolean {
+    return this.requireAuth;
+  }
+
+  turnOnAuth(): void {
+    this.requireAuth = true;
+  }
+
+  isNoCache(): boolean {
+    return this.noCache;
+  }
+
+  enableCache(): void {
+    this.noCache = false;
+  }
+
+  disableCache(): void {
+    this.noCache = true;
+  }
+}
+
+export abstract class BaseRequest<T> {
+  abstract buildRequest(): HttpRequest;
+  abstract getParser(): IParser<T>;
+}

package/src/core/http/http-client.interface.ts

@@ -0,0 +1,5 @@
+import { HttpRequest } from "./base-request";
+
+export interface IHttpClient {
+  send(request: HttpRequest): Promise<string>;
+}

package/src/core/http/index.ts

@@ -0,0 +1,3 @@
+export * from "./http-client.interface";
+export * from "./base-request";
+export * from "./adapters";

package/src/core/index.ts

@@ -0,0 +1,6 @@
+export * from "./executor";
+export * from "./http";
+export * from "./parser";
+export * from "./utils";
+export * from "./auth";
+export * from './cache'

package/src/core/parser/index.ts

@@ -0,0 +1 @@
+export * from "./parser.interface";

package/src/core/parser/parser.interface.ts

@@ -0,0 +1,3 @@
+export interface IParser<T> {
+  parse(html: string): T;
+}

package/src/core/utils/html-detect.ts

@@ -0,0 +1,13 @@
+import * as cheerio from "cheerio";
+
+export class HtmlDetect {
+  static isLoginPage(html: string): boolean {
+    const $ = HtmlDetect.load(html);
+    const loginBtn = $("button#logIn");
+    return loginBtn.length > 0;
+  }
+
+  static load(html: string): cheerio.CheerioAPI {
+    return cheerio.load(html);
+  }
+}

package/src/core/utils/index.ts

@@ -0,0 +1 @@
+export * from "./html-detect";

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./core";
+export * from "./modules";
+
+export { default as VkuSDK } from "./VkuSDK";

package/src/modules/accounts/domain/account.entity.ts

@@ -0,0 +1,45 @@
+export enum AccountHost {
+  DAOTAO = "https://daotao.vku.udn.vn",
+  DK1 = "https://dk1.vku.udn.vn",
+  DK2 = "https://dk2.vku.udn.vn",
+}
+
+export class Account {
+  private host: AccountHost;
+  private cookie: string;
+  constructor(cookie: string);
+  constructor(cookie: string, host: AccountHost);
+  constructor(cookie: string, host?: AccountHost) {
+    this.cookie = cookie;
+    if (host) {
+      this.host = host;
+    } else {
+      this.host = AccountHost.DAOTAO;
+    }
+  }
+
+  getHost(): AccountHost {
+    return this.host;
+  }
+
+  useDaoTaoHost(): Account {
+    this.host = AccountHost.DAOTAO;
+    return this;
+  }
+
+  useDK1Host(): Account {
+    this.host = AccountHost.DK1;
+    return this;
+  }
+
+  useDK2Host(): Account {
+    this.host = AccountHost.DK2;
+    return this;
+  }
+
+  getCookie(): string {
+    if (this.cookie.includes("=")) return this.cookie;
+
+    return `laravel_session=${this.cookie}`;
+  }
+}

package/src/modules/accounts/domain/index.ts

@@ -0,0 +1 @@
+export * from "./account.entity";

package/src/modules/accounts/index.ts

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

package/src/modules/accounts/infra/account-session.provider.ts

@@ -0,0 +1,17 @@
+import { ISessionProvider } from "../../../core/auth/session-provider.interface";
+import { Account } from "../domain/account.entity";
+
+export class AccountSessionProvider implements ISessionProvider {
+  constructor(private account: Account) {}
+  getAuthHeader(): Promise<Record<string, string>> {
+    return Promise.resolve({
+      Cookie: this.account.getCookie(),
+    });
+  }
+  getHost(): string {
+    return this.account.getHost();
+  }
+  isAuthenticated(): boolean {
+    return this.account.getCookie().length > 0;
+  }
+}

package/src/modules/accounts/infra/account.factory.ts

@@ -0,0 +1,48 @@
+import { ISessionProvider } from "../../../core";
+import { Account, AccountHost } from "../domain";
+import { AccountSessionProvider } from "./account-session.provider";
+import { ChromeCdpLogin } from "./chrome-cdp-login";
+
+export interface GoogleAccountData {
+  email: string;
+  password: string;
+  host?: AccountHost;
+}
+
+export interface SessionAccountData {
+  session: string;
+  host?: AccountHost;
+}
+
+export class AccountFactory {
+  static createAccount(
+    data: GoogleAccountData | SessionAccountData,
+  ): ISessionProvider {
+    if (isGoogleAccountData(data)) {
+      return new ChromeCdpLogin(
+        data.email,
+        data.password,
+        data.host || AccountHost.DAOTAO,
+      );
+    }
+    if (isSessionAccountData(data)) {
+      return new AccountSessionProvider(
+        new Account(data.session, data.host || AccountHost.DAOTAO),
+      );
+    }
+
+    throw new Error("Invalid account data");
+  }
+}
+
+export function isGoogleAccountData(
+  data: GoogleAccountData | SessionAccountData,
+): data is GoogleAccountData {
+  return (data as GoogleAccountData).email !== undefined;
+}
+
+export function isSessionAccountData(
+  data: GoogleAccountData | SessionAccountData,
+): data is SessionAccountData {
+  return (data as SessionAccountData).session !== undefined;
+}

package/src/modules/accounts/infra/chrome-cdp-login.ts

@@ -0,0 +1,62 @@
+import { ISessionProvider } from "../../../core";
+export class ChromeCdpLogin implements ISessionProvider {
+  private cookie: string = "";
+  constructor(
+    private readonly email: string,
+    private readonly password: string,
+    private readonly host: string,
+    private readonly userDataDir?: string,
+  ) {
+    throw new Error("Not implemented yet! Please create account with session cookie");
+  }
+
+  async getAuthHeader(): Promise<Record<string, string>> {
+    console.log("[ChromeCdpLogin] start");
+    if (this.cookie) {
+      return {
+        Cookie: this.cookie,
+      };
+    }
+
+    return {
+      Cookie: await this.getCookie(),
+    };
+  }
+
+  getHost(): string {
+    return this.host;
+  }
+  isAuthenticated(): boolean {
+    return true;
+  }
+
+  private async getCookie(): Promise<string> {
+    const { ChromeWrapper } = await import("../../../modules/shared/infra/chrome-wrapper.js");
+    const chrome = await this.launchChrome();
+    const browser = new ChromeWrapper();
+    await browser.connect({ port: chrome.port });
+    try {
+      await browser.navigate(this.host + "/sv");
+      await browser.click("#logIn");
+      await browser.wait(3000);
+    } catch {
+      throw new Error("Login failed");
+    } finally {
+      await browser.disconnect();
+      chrome.kill();
+    }
+
+    return "";
+  }
+
+  private async launchChrome() {
+    const ChromeLauncher = await import("chrome-launcher");
+    const chrome = await ChromeLauncher.launch({
+      chromeFlags: [
+        "--user-data-dir=" + (this.userDataDir || "./chrome-user-data"),
+      ],
+    });
+
+    return chrome;
+  }
+}

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

@@ -0,0 +1,3 @@
+export * from "./account-session.provider";
+export * from "./chrome-cdp-login";
+export * from "./account.factory";

package/src/modules/enrollment/domain/class-session.entity.ts

@@ -0,0 +1,13 @@
+export class ClassSession {
+  constructor(
+    public readonly subjectClassName: string,
+    public readonly teacher: string,
+    public readonly weeksRaw: string,
+    public readonly room: string,
+    public readonly dayOfWeek: string,
+    public readonly period: string,
+    public readonly credit?: number,
+    public readonly timeSlot?: string,
+    public readonly id?: number,
+  ) {}
+}

package/src/modules/enrollment/domain/course-section.entity.ts

@@ -0,0 +1,19 @@
+export class CourseSection {
+  constructor(
+    public readonly id: number,
+    public readonly courseId: number,
+    public readonly maxCapacity: number,
+  ) {}
+
+  isValid(): boolean {
+    return this.id !== -1 && this.courseId !== -1;
+  }
+
+  parseToRegistrationPayload() {
+    return {
+      hocphan_id: this.id,
+      idlop: this.courseId,
+      m: this.maxCapacity,
+    };
+  }
+}

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

@@ -0,0 +1,4 @@
+export * from "./course-section.entity";
+export * from "./subject-class.entity";
+export * from "./subject-action-response.entity";
+export * from "./class-session.entity";

package/src/modules/enrollment/domain/subject-action-response.entity.ts

@@ -0,0 +1,6 @@
+export class SubjectActionResponse {
+  constructor(
+    public readonly success: boolean,
+    public readonly message: string,
+  ) {}
+}

package/src/modules/enrollment/domain/subject-class.entity.ts

@@ -0,0 +1,66 @@
+import { CourseSection } from "./course-section.entity";
+
+export enum SubjectClassStatus {
+  CAN_REGISTER = "CAN_REGISTER",
+  FULL = "FULL",
+  TIME_CONFLICT = "TIME_CONFLICT",
+  NOT_ELIGIBLE = "NOT_ELIGIBLE",
+  REGISTRATION_CLOSED = "REGISTRATION_CLOSED",
+}
+
+export class SubjectClass {
+  constructor(
+    public readonly id: string,
+    public readonly subjectName: string,
+
+    public readonly teacher: string,
+    public readonly timeTable: string,
+    public readonly weeks: string,
+
+    public readonly capacity: number,
+    public readonly registeredCount: number,
+
+    public readonly enrollmentParams: CourseSection | null,
+
+    public readonly statusMessage: SubjectClassStatus,
+  ) {
+    if (this.isFull()) this.statusMessage = SubjectClassStatus.FULL;
+    if (this.getAvailableSlots() === 0)
+      this.statusMessage = SubjectClassStatus.FULL;
+  }
+
+  public isOpenForRegistration(): boolean {
+    return this.enrollmentParams !== null;
+  }
+
+  public isFull(): boolean {
+    return this.registeredCount >= this.capacity;
+  }
+
+  public getAvailableSlots(): number {
+    return Math.max(0, this.capacity - this.registeredCount);
+  }
+
+  public getEnrollmentParamsOrThrow(): CourseSection {
+    if (!this.enrollmentParams) {
+      throw new Error(
+        `Cannot register for class ${this.id}. Reason: ${this.statusMessage}`,
+      );
+    }
+    return this.enrollmentParams;
+  }
+
+  clone(overrides: Partial<SubjectClass> = {}) {
+    return new SubjectClass(
+      overrides.id ?? this.id,
+      overrides.subjectName ?? this.subjectName,
+      overrides.teacher ?? this.teacher,
+      overrides.timeTable ?? this.timeTable,
+      overrides.weeks ?? this.weeks,
+      overrides.capacity ?? this.capacity,
+      overrides.registeredCount ?? this.registeredCount,
+      overrides.enrollmentParams ?? this.enrollmentParams,
+      overrides.statusMessage ?? this.statusMessage,
+    );
+  }
+}

package/src/modules/enrollment/index.ts

@@ -0,0 +1,3 @@
+export * from "./requests";
+export * from "./domain";
+export * from "./parsers";

package/src/modules/enrollment/parsers/class-session.parser.ts

@@ -0,0 +1,79 @@
+import { HtmlDetect, IParser } from "../../../core";
+import { HtmlTableParser } from "../../shared";
+import { ClassSession } from "../domain";
+
+export class ClassSessionParser implements IParser<ClassSession[]> {
+  private htmlTableParser = new HtmlTableParser();
+  parse(html: string): ClassSession[] {
+    const $ = HtmlDetect.load(html);
+    if (html.length === 0) {
+      return []
+    }
+
+    let table = $(".table-responsive.today table")
+
+    if (table.length > 0) {
+      return this.parseFromSchedule($.html(table));
+    }
+
+    table = $("body > div > div > div.right_col > div > div > div > div > div > div.x_content > div > table.hientai.table.table-striped.jambo_table.bulk_action")
+
+    return this.parseFromScheduleV2($.html(table));
+  }
+
+  private parseFromScheduleV2(raw: string): ClassSession[] {
+    const result: ClassSession[] = [];
+    
+    const data = this.htmlTableParser.parse(raw);
+    for (const item of data) {
+      if (!item["Thời khóa biểu"]) continue;
+      const [dayOfWeek, period] = item["Thời khóa biểu"].split(" ")
+
+      const $ = HtmlDetect.load(item.rawHTML)
+      const link = $("a").attr("href") || ""
+      const id = this.extractClassIdFromLink(link) ?? undefined
+
+      result.push(
+        new ClassSession(
+          item["Tên học phần"],
+          item["Giảng viên"],
+          item["Tuần học"],
+          "",
+          dayOfWeek,
+          period,
+          Number(item["Số TC"]),
+          item["Thời gian ĐK"],
+          id,
+        )
+      )
+    }
+    return result
+  }
+
+  private extractClassIdFromLink(link: string): number | null {
+    const urlParams = new URLSearchParams(link.split("?")[1]);
+    const idParam = urlParams.get("id");
+    return idParam ? Number(idParam) : null;
+  }
+
+  private parseFromSchedule(raw: string): ClassSession[] {
+    const result: ClassSession[] = [];
+
+    const data = this.htmlTableParser.parse(raw);
+
+    for (const item of data) {
+      const classSession = new ClassSession(
+        item["Tên lớp học phần"],
+        item["Giảng viên"],
+        item["Tuần"],
+        item["Phòng"],
+        item["Thứ"],
+        item["Tiết"],
+      );
+
+      result.push(classSession);
+    }
+
+    return result;
+  }
+}

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

@@ -0,0 +1,2 @@
+export * from "./subject-class.parser";
+export * from "./class-session.parser";

package/src/modules/enrollment/parsers/subject-class.parser.ts

@@ -0,0 +1,72 @@
+import { IParser } from "../../../core";
+import {
+  HtmlTableParser,
+  TableCellWithRawHTML,
+} from "../../shared/parsers/html-table.parser";
+import { CourseSection } from "../domain";
+import {
+  SubjectClass,
+  SubjectClassStatus,
+} from "../domain/subject-class.entity";
+import * as cheerio from "cheerio";
+export class SubjectClassParser implements IParser<SubjectClass[]> {
+  private tableParser: HtmlTableParser = new HtmlTableParser();
+  parse(html: string): SubjectClass[] {
+    const $ = cheerio.load(html);
+    const data = this.tableParser.parse($.html()) as TableCellWithRawHTML[];
+    const result: SubjectClass[] = [];
+    for (const item of data) {
+      if (item["STT"] === "") continue;
+      const rawHTML = item.rawHTML;
+      const courseSection = this.parseCourseSections(rawHTML);
+      const status = this.parseStatus(item["Tùy chọn"] || "");
+      const subjectClass = new SubjectClass(
+        courseSection?.id.toString() || "",
+        item["Tên học phần"],
+        item["Giảng viên"],
+        item["Thời khóa biểu"],
+        item["Tuần học"],
+        parseInt(item["Sỉ số"], 10),
+        parseInt(item["Số lượng đăng ký"], 10),
+        courseSection,
+        status,
+      );
+
+      result.push(subjectClass);
+    }
+
+    return result;
+  }
+
+  private parseCourseSections(raw: string): CourseSection | null {
+    const $ = cheerio.load(raw);
+    const link = $("a");
+    const el = link.first();
+    const href = el.attr("href") || "";
+    const regex = /hocphan_id=(\d+)&idlop=(\d+)&m=(\d+)/;
+    const match = href.match(regex);
+    if (match) {
+      const courseSection = new CourseSection(
+        parseInt(match[1], 10),
+        parseInt(match[2], 10),
+        parseInt(match[3], 10),
+      );
+
+      return courseSection;
+    }
+
+    return null;
+  }
+
+  private parseStatus(message: string): SubjectClassStatus {
+    message = message.toLowerCase();
+    if (message.includes("chọn")) return SubjectClassStatus.CAN_REGISTER;
+    if (message.includes("đầy")) return SubjectClassStatus.FULL;
+    if (message.includes("trùng")) return SubjectClassStatus.TIME_CONFLICT;
+    if (message.includes("không đủ điều kiện"))
+      return SubjectClassStatus.NOT_ELIGIBLE;
+    if (message.includes("đóng đăng ký"))
+      return SubjectClassStatus.REGISTRATION_CLOSED;
+    return SubjectClassStatus.NOT_ELIGIBLE;
+  }
+}

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

@@ -0,0 +1,14 @@
+import { BaseRequest, HttpMethod, HttpRequest, IParser } from "../../../core";
+import { ClassSession } from "../domain";
+import { ClassSessionParser } from "../parsers/class-session.parser";
+
+export class GetRegisteredSubjectClassRequest extends BaseRequest<
+  ClassSession[]
+> {
+  buildRequest(): HttpRequest {
+    return new HttpRequest(HttpMethod.GET, "/sv/dang-ky-tin-chi");
+  }
+  getParser(): IParser<ClassSession[]> {
+    return new ClassSessionParser();
+  }
+}

package/src/modules/enrollment/requests/get-subject-classes.request.ts

@@ -0,0 +1,28 @@
+import { BaseRequest, HttpMethod, HttpRequest, IParser } from "../../../core";
+import { SubjectClass } from "../domain/subject-class.entity";
+import { SubjectClassParser } from "../parsers/subject-class.parser";
+
+export class GetSubjectClassesRequest extends BaseRequest<SubjectClass[]> {
+  constructor(public readonly courseId: number) {
+    super();
+  }
+  buildRequest(): HttpRequest {
+    // return {
+    //   method: "GET",
+    //   url: `/sv/tin-chi-xem-chi-tiet?id=${this.courseId}`,
+    // };
+    //
+    return new HttpRequest(
+      HttpMethod.GET,
+      `/sv/tin-chi-xem-chi-tiet`,
+      {},
+      undefined,
+      {
+        id: this.courseId,
+      },
+    );
+  }
+  getParser(): IParser<SubjectClass[]> {
+    return new SubjectClassParser();
+  }
+}