@team-internet/apiconnector 10.0.0

package/src/record.ts

@@ -0,0 +1,46 @@
+/**
+ * Record class
+ */
+export class Record {
+  /**
+   * row data container
+   */
+  private data: any;
+
+  /**
+   * Constructor
+   * @param data data object (use column names as object keys)
+   */
+  public constructor(data: any) {
+    this.data = data;
+  }
+
+  /**
+   * get row data
+   * @returns row data
+   */
+  public getData(): any {
+    return this.data;
+  }
+
+  /**
+   * get row data for given column
+   * @param key column name
+   * @returns row data for given column or null if column does not exist
+   */
+  public getDataByKey(key: string): string | null {
+    if (this.hasData(key)) {
+      return this.data[key];
+    }
+    return null;
+  }
+
+  /**
+   * check if record has data for given column
+   * @param key column name
+   * @returns boolean result
+   */
+  private hasData(key: string): boolean {
+    return Object.prototype.hasOwnProperty.call(this.data, key);
+  }
+}

package/src/response.ts

@@ -0,0 +1,562 @@
+import { Column } from "./column.js";
+import { Record } from "./record.js";
+import { ResponseTranslator as RT } from "./responsetranslator.js";
+import { ResponseParser as RP } from "./responseparser.js";
+
+/**
+ * Response Class
+ */
+export class Response {
+  /**
+   * plain API response
+   */
+  protected raw: string;
+  /**
+   * hash representation of plain API response
+   */
+  protected hash: any;
+  /**
+   * The API Command used within this request
+   */
+  private command: any;
+  /**
+   * Column names available in this responsse
+   * NOTE: this includes also FIRST, LAST, LIMIT, COUNT, TOTAL
+   * and maybe further specific columns in case of a list query
+   */
+  private columnkeys: string[];
+  /**
+   * Container of Column Instances
+   */
+  private columns: Column[];
+  /**
+   * Record Index we currently point to in record list
+   */
+  private recordIndex: number;
+  /**
+   * Record List (List of rows)
+   */
+  private records: Record[];
+
+  /**
+   * Constructor
+   * @param raw API plain response
+   * @param cmd API command used within this request
+   * @param ph placeholder array to get vars in response description dynamically replaced
+   */
+  public constructor(raw: string, cmd: any = {}, ph: any = {}) {
+    this.command = cmd;
+    if (
+      this.command &&
+      Object.prototype.hasOwnProperty.call(this.command, "PASSWORD")
+    ) {
+      // make password no longer accessible
+      this.command.PASSWORD = "***";
+    }
+
+    this.raw = RT.translate(raw, cmd, ph);
+    console.log(this.raw);
+    console.log("-----------------------------------------");
+    this.hash = RP.parse(this.raw);
+    this.columnkeys = [];
+    this.columns = [];
+    this.recordIndex = 0;
+    this.records = [];
+
+    if (Object.prototype.hasOwnProperty.call(this.hash, "PROPERTY")) {
+      const colKeys = Object.keys(this.hash.PROPERTY);
+      let count = 0;
+      colKeys.forEach((c: string) => {
+        const d = this.hash.PROPERTY[c];
+        this.addColumn(c, d);
+        if (d.length > count) {
+          count = d.length;
+        }
+      });
+      for (let i = 0; i < count; i++) {
+        const d: any = {};
+        colKeys.forEach((k: string) => {
+          const col = this.getColumn(k);
+          if (col) {
+            const v = col.getDataByIndex(i);
+            if (v !== null) {
+              d[k] = v;
+            }
+          }
+        });
+        this.addRecord(d);
+      }
+    }
+  }
+
+  /**
+   * Get API response code
+   * @returns API response code
+   */
+  public getCode(): number {
+    return parseInt(this.hash.CODE, 10);
+  }
+
+  /**
+   * Get API response description
+   * @returns API response description
+   */
+  public getDescription(): string {
+    return this.hash.DESCRIPTION;
+  }
+
+  /**
+   * Get Plain API response
+   * @returns Plain API response
+   */
+  public getPlain(): string {
+    return this.raw;
+  }
+
+  /**
+   * Get Queuetime of API response
+   * @returns Queuetime of API response
+   */
+  public getQueuetime(): number {
+    if (Object.prototype.hasOwnProperty.call(this.hash, "QUEUETIME")) {
+      return parseFloat(this.hash.QUEUETIME);
+    }
+    return 0.0;
+  }
+
+  /**
+   * Get API response as Hash
+   * @returns API response hash
+   */
+  public getHash(): any {
+    return this.hash;
+  }
+
+  /**
+   * Get Runtime of API response
+   * @returns Runtime of API response
+   */
+  public getRuntime(): number {
+    if (Object.prototype.hasOwnProperty.call(this.hash, "RUNTIME")) {
+      return parseFloat(this.hash.RUNTIME);
+    }
+    return 0.0;
+  }
+
+  /**
+   * Check if current API response represents an error case
+   * API response code is an 5xx code
+   * @returns boolean result
+   */
+  public isError(): boolean {
+    return this.hash.CODE.charAt(0) === "5";
+  }
+
+  /**
+   * Check if current API response represents a success case
+   * API response code is an 2xx code
+   * @returns boolean result
+   */
+  public isSuccess(): boolean {
+    return this.hash.CODE.charAt(0) === "2";
+  }
+
+  /**
+   * Check if current API response represents a temporary error case
+   * API response code is an 4xx code
+   * @returns boolean result
+   */
+  public isTmpError(): boolean {
+    return this.hash.CODE.charAt(0) === "4";
+  }
+
+  /**
+   * Check if current operation is returned as pending
+   * @returns boolean result
+   */
+  public isPending(): boolean {
+    const cmd = this.getCommand();
+
+    // Check if the COMMAND is AddDomain (case-insensitive)
+    if (!cmd.COMMAND || cmd.COMMAND.toLowerCase() !== "adddomain") {
+      return false;
+    }
+
+    // Retrieve the STATUS column and check if its data equals REQUESTED (case-insensitive)
+    const status = this.getColumn("STATUS");
+    if (status) {
+      const statusData = status.getDataByIndex(0);
+      if (statusData && statusData.toLowerCase() === "requested") {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Add a column to the column list
+   * @param key column name
+   * @param data array of column data
+   * @returns Current Response Instance for method chaining
+   */
+  public addColumn(key: string, data: string[]): Response {
+    const col = new Column(key, data);
+    this.columns.push(col);
+    this.columnkeys.push(key);
+    return this;
+  }
+
+  /**
+   * Add a record to the record list
+   * @param h row hash data
+   * @returns Current Response Instance for method chaining
+   */
+  public addRecord(h: any): Response {
+    this.records.push(new Record(h));
+    return this;
+  }
+
+  /**
+   * Get column by column name
+   * @param key column name
+   * @returns column instance or null if column does not exist
+   */
+  public getColumn(key: string): Column | null {
+    return this.hasColumn(key)
+      ? this.columns[this.columnkeys.indexOf(key)]
+      : null;
+  }
+
+  /**
+   * Get Data by Column Name and Index
+   * @param colkey column name
+   * @param index column data index
+   * @returns column data at index or null if not found
+   */
+  public getColumnIndex(colkey: string, index: number): string | null {
+    const col = this.getColumn(colkey);
+    return col ? col.getDataByIndex(index) : null;
+  }
+
+  /**
+   * Get Column Names
+   * @returns Array of Column Names
+   */
+  public getColumnKeys(): string[] {
+    return this.columnkeys;
+  }
+
+  /**
+   * Get List of Columns
+   * @returns Array of Columns
+   */
+  public getColumns(): Column[] {
+    return this.columns;
+  }
+
+  /**
+   * Get Command used in this request
+   * @returns command
+   */
+  public getCommand(): any {
+    return this.command;
+  }
+
+  /**
+   * Get Command used in this request in plain text format
+   * @return command as plain text
+   */
+  public getCommandPlain(): string {
+    let tmp = "";
+    Object.keys(this.command).forEach((key: string) => {
+      tmp += `${key} = ${this.command[key]}\n`;
+    });
+    return tmp;
+  }
+
+  /**
+   * Get Page Number of current List Query
+   * @returns page number or null in case of a non-list response
+   */
+  public getCurrentPageNumber(): number | null {
+    const first = this.getFirstRecordIndex();
+    const limit = this.getRecordsLimitation();
+    if (first !== null && limit) {
+      return Math.floor(first / limit) + 1;
+    }
+    return null;
+  }
+
+  /**
+   * Get Record of current record index
+   * @returns Record or null in case of a non-list response
+   */
+  public getCurrentRecord(): Record | null {
+    return this.hasCurrentRecord() ? this.records[this.recordIndex] : null;
+  }
+
+  /**
+   * Get Index of first row in this response
+   * @returns first row index
+   */
+  public getFirstRecordIndex(): number | null {
+    const col = this.getColumn("FIRST");
+    if (col) {
+      const f = col.getDataByIndex(0);
+      if (f !== null) {
+        return parseInt(f, 10);
+      }
+    }
+    if (this.records.length) {
+      return 0;
+    }
+    return null;
+  }
+
+  /**
+   * Get last record index of the current list query
+   * @returns record index or null for a non-list response
+   */
+  public getLastRecordIndex(): number | null {
+    const col = this.getColumn("LAST");
+    if (col) {
+      const l = col.getDataByIndex(0);
+      if (l !== null) {
+        return parseInt(l, 10);
+      }
+    }
+    const len = this.getRecordsCount();
+    if (len) {
+      return len - 1;
+    }
+    return null;
+  }
+
+  /**
+   * Get Response as List Hash including useful meta data for tables
+   * @returns hash including list meta data and array of rows in hash notation
+   */
+  public getListHash(): any {
+    const lh: any[] = [];
+    this.getRecords().forEach((rec) => {
+      lh.push(rec.getData());
+    });
+    return {
+      LIST: lh,
+      meta: {
+        columns: this.getColumnKeys(),
+        pg: this.getPagination(),
+      },
+    };
+  }
+
+  /**
+   * Get next record in record list
+   * @returns Record or null in case there's no further record
+   */
+  public getNextRecord(): Record | null {
+    if (this.hasNextRecord()) {
+      return this.records[++this.recordIndex];
+    }
+    return null;
+  }
+
+  /**
+   * Get Page Number of next list query
+   * @returns page number or null if there's no next page
+   */
+  public getNextPageNumber(): number | null {
+    const cp = this.getCurrentPageNumber();
+    if (cp === null) {
+      return null;
+    }
+    const page = cp + 1;
+    const pages = this.getNumberOfPages();
+    return page <= pages ? page : pages;
+  }
+
+  /**
+   * Get the number of pages available for this list query
+   * @returns number of pages
+   */
+  public getNumberOfPages(): number {
+    const t = this.getRecordsTotalCount();
+    const limit = this.getRecordsLimitation();
+    if (t && limit) {
+      return Math.ceil(t / this.getRecordsLimitation());
+    }
+    return 0;
+  }
+
+  /**
+   * Get object containing all paging data
+   * @returns paginator data
+   */
+  public getPagination(): any {
+    return {
+      COUNT: this.getRecordsCount(),
+      CURRENTPAGE: this.getCurrentPageNumber(),
+      FIRST: this.getFirstRecordIndex(),
+      LAST: this.getLastRecordIndex(),
+      LIMIT: this.getRecordsLimitation(),
+      NEXTPAGE: this.getNextPageNumber(),
+      PAGES: this.getNumberOfPages(),
+      PREVIOUSPAGE: this.getPreviousPageNumber(),
+      TOTAL: this.getRecordsTotalCount(),
+    };
+  }
+
+  /**
+   * Get Page Number of previous list query
+   * @returns page number or null if there's no previous page
+   */
+  public getPreviousPageNumber(): number | null {
+    const cp = this.getCurrentPageNumber();
+    if (cp === null) {
+      return null;
+    }
+    return cp - 1 || null;
+  }
+
+  /**
+   * Get previous record in record list
+   * @returns Record or null if there's no previous record
+   */
+  public getPreviousRecord(): Record | null {
+    if (this.hasPreviousRecord()) {
+      return this.records[--this.recordIndex];
+    }
+    return null;
+  }
+
+  /**
+   * Get Record at given index
+   * @param idx record index
+   * @returns Record or null if index does not exist
+   */
+  public getRecord(idx: number): Record | null {
+    if (idx >= 0 && this.records.length > idx) {
+      return this.records[idx];
+    }
+    return null;
+  }
+
+  /**
+   * Get all Records
+   * @returns array of records
+   */
+  public getRecords(): Record[] {
+    return this.records;
+  }
+
+  /**
+   * Get count of rows in this response
+   * @returns count of rows
+   */
+  public getRecordsCount(): number {
+    return this.records.length;
+  }
+
+  /**
+   * Get total count of records available for the list query
+   * @returns total count of records or count of records for a non-list response
+   */
+  public getRecordsTotalCount(): number {
+    const col = this.getColumn("TOTAL");
+    if (col) {
+      const t = col.getDataByIndex(0);
+      if (t !== null) {
+        return parseInt(t, 10);
+      }
+    }
+    return this.getRecordsCount();
+  }
+
+  /**
+   * Get limit(ation) setting of the current list query
+   * This is the count of requested rows
+   * @returns limit setting or count requested rows
+   */
+  public getRecordsLimitation(): number {
+    const col = this.getColumn("LIMIT");
+    if (col) {
+      const l = col.getDataByIndex(0);
+      if (l !== null) {
+        return parseInt(l, 10);
+      }
+    }
+    return this.getRecordsCount();
+  }
+
+  /**
+   * Check if this list query has a next page
+   * @returns boolean result
+   */
+  public hasNextPage(): boolean {
+    const cp = this.getCurrentPageNumber();
+    if (cp === null) {
+      return false;
+    }
+    return cp + 1 <= this.getNumberOfPages();
+  }
+
+  /**
+   * Check if this list query has a previous page
+   * @returns boolean result
+   */
+  public hasPreviousPage(): boolean {
+    const cp = this.getCurrentPageNumber();
+    if (cp === null) {
+      return false;
+    }
+    return cp - 1 > 0;
+  }
+
+  /**
+   * Reset index in record list back to zero
+   * @returns Current Response Instance for method chaining
+   */
+  public rewindRecordList(): Response {
+    this.recordIndex = 0;
+    return this;
+  }
+
+  /**
+   * Check if column exists in response
+   * @param key column name
+   * @returns boolean result
+   */
+  private hasColumn(key: string): boolean {
+    return this.columnkeys.indexOf(key) !== -1;
+  }
+
+  /**
+   * Check if the record list contains a record for the
+   * current record index in use
+   * @returns boolean result
+   */
+  private hasCurrentRecord(): boolean {
+    const len = this.records.length;
+    return len > 0 && this.recordIndex >= 0 && this.recordIndex < len;
+  }
+
+  /**
+   * Check if the record list contains a next record for the
+   * current record index in use
+   * @returns boolean result
+   */
+  private hasNextRecord(): boolean {
+    const next = this.recordIndex + 1;
+    return this.hasCurrentRecord() && next < this.records.length;
+  }
+
+  /**
+   * Check if the record list contains a previous record for the
+   * current record index in use
+   * @returns boolean result
+   */
+  private hasPreviousRecord(): boolean {
+    return this.recordIndex > 0 && this.hasCurrentRecord();
+  }
+}

package/src/responseparser.ts

@@ -0,0 +1,35 @@
+export const ResponseParser: any = {
+  /**
+   * Method to parse plain API response into js object
+   * @param raw API plain response
+   * @returns API response as JS Object (hash)
+   */
+  parse: (raw: string): any => {
+    const hash: any = {};
+    const regexp = /^([^=]*[^\t= ])[\t ]*=[\t ]*(.*)$/;
+    const r = raw.replace(/\r\n/g, "\n").split("\n");
+    while (r.length) {
+      const row = r.shift();
+      let m;
+      if (row) {
+        m = row.match(regexp);
+        if (m) {
+          const mm = m[1].match(/^property\[([^\]]*)\]/i);
+          if (mm) {
+            if (!Object.prototype.hasOwnProperty.call(hash, "PROPERTY")) {
+              hash.PROPERTY = {};
+            }
+            mm[1] = mm[1].toUpperCase().replace(/\s/g, "");
+            if (!Object.prototype.hasOwnProperty.call(hash.PROPERTY, mm[1])) {
+              hash.PROPERTY[mm[1]] = [];
+            }
+            hash.PROPERTY[mm[1]].push(m[2].replace(/[\t ]*$/, ""));
+          } else {
+            hash[m[1].toUpperCase()] = m[2].replace(/[\t ]*$/, "");
+          }
+        }
+      }
+    }
+    return hash;
+  },
+};