@team-internet/apiconnector 10.0.0

package/dist/response.js

@@ -0,0 +1,512 @@
+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
+     */
+    raw;
+    /**
+     * hash representation of plain API response
+     */
+    hash;
+    /**
+     * The API Command used within this request
+     */
+    command;
+    /**
+     * 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
+     */
+    columnkeys;
+    /**
+     * Container of Column Instances
+     */
+    columns;
+    /**
+     * Record Index we currently point to in record list
+     */
+    recordIndex;
+    /**
+     * Record List (List of rows)
+     */
+    records;
+    /**
+     * 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
+     */
+    constructor(raw, cmd = {}, ph = {}) {
+        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) => {
+                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 = {};
+                colKeys.forEach((k) => {
+                    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
+     */
+    getCode() {
+        return parseInt(this.hash.CODE, 10);
+    }
+    /**
+     * Get API response description
+     * @returns API response description
+     */
+    getDescription() {
+        return this.hash.DESCRIPTION;
+    }
+    /**
+     * Get Plain API response
+     * @returns Plain API response
+     */
+    getPlain() {
+        return this.raw;
+    }
+    /**
+     * Get Queuetime of API response
+     * @returns Queuetime of API response
+     */
+    getQueuetime() {
+        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
+     */
+    getHash() {
+        return this.hash;
+    }
+    /**
+     * Get Runtime of API response
+     * @returns Runtime of API response
+     */
+    getRuntime() {
+        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
+     */
+    isError() {
+        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
+     */
+    isSuccess() {
+        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
+     */
+    isTmpError() {
+        return this.hash.CODE.charAt(0) === "4";
+    }
+    /**
+     * Check if current operation is returned as pending
+     * @returns boolean result
+     */
+    isPending() {
+        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
+     */
+    addColumn(key, data) {
+        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
+     */
+    addRecord(h) {
+        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
+     */
+    getColumn(key) {
+        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
+     */
+    getColumnIndex(colkey, index) {
+        const col = this.getColumn(colkey);
+        return col ? col.getDataByIndex(index) : null;
+    }
+    /**
+     * Get Column Names
+     * @returns Array of Column Names
+     */
+    getColumnKeys() {
+        return this.columnkeys;
+    }
+    /**
+     * Get List of Columns
+     * @returns Array of Columns
+     */
+    getColumns() {
+        return this.columns;
+    }
+    /**
+     * Get Command used in this request
+     * @returns command
+     */
+    getCommand() {
+        return this.command;
+    }
+    /**
+     * Get Command used in this request in plain text format
+     * @return command as plain text
+     */
+    getCommandPlain() {
+        let tmp = "";
+        Object.keys(this.command).forEach((key) => {
+            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
+     */
+    getCurrentPageNumber() {
+        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
+     */
+    getCurrentRecord() {
+        return this.hasCurrentRecord() ? this.records[this.recordIndex] : null;
+    }
+    /**
+     * Get Index of first row in this response
+     * @returns first row index
+     */
+    getFirstRecordIndex() {
+        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
+     */
+    getLastRecordIndex() {
+        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
+     */
+    getListHash() {
+        const lh = [];
+        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
+     */
+    getNextRecord() {
+        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
+     */
+    getNextPageNumber() {
+        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
+     */
+    getNumberOfPages() {
+        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
+     */
+    getPagination() {
+        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
+     */
+    getPreviousPageNumber() {
+        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
+     */
+    getPreviousRecord() {
+        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
+     */
+    getRecord(idx) {
+        if (idx >= 0 && this.records.length > idx) {
+            return this.records[idx];
+        }
+        return null;
+    }
+    /**
+     * Get all Records
+     * @returns array of records
+     */
+    getRecords() {
+        return this.records;
+    }
+    /**
+     * Get count of rows in this response
+     * @returns count of rows
+     */
+    getRecordsCount() {
+        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
+     */
+    getRecordsTotalCount() {
+        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
+     */
+    getRecordsLimitation() {
+        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
+     */
+    hasNextPage() {
+        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
+     */
+    hasPreviousPage() {
+        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
+     */
+    rewindRecordList() {
+        this.recordIndex = 0;
+        return this;
+    }
+    /**
+     * Check if column exists in response
+     * @param key column name
+     * @returns boolean result
+     */
+    hasColumn(key) {
+        return this.columnkeys.indexOf(key) !== -1;
+    }
+    /**
+     * Check if the record list contains a record for the
+     * current record index in use
+     * @returns boolean result
+     */
+    hasCurrentRecord() {
+        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
+     */
+    hasNextRecord() {
+        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
+     */
+    hasPreviousRecord() {
+        return this.recordIndex > 0 && this.hasCurrentRecord();
+    }
+}

package/dist/responseparser.d.ts

@@ -0,0 +1 @@
+export declare const ResponseParser: any;

package/dist/responseparser.js

@@ -0,0 +1,36 @@
+export const ResponseParser = {
+    /**
+     * Method to parse plain API response into js object
+     * @param raw API plain response
+     * @returns API response as JS Object (hash)
+     */
+    parse: (raw) => {
+        const hash = {};
+        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;
+    },
+};

package/dist/responsetemplatemanager.d.ts

@@ -0,0 +1,65 @@
+import { Response } from "./response.js";
+/**
+ * ResponseTemplateManager Singleton Class
+ */
+export declare class ResponseTemplateManager {
+    /**
+     * Get ResponseTemplateManager Instance
+     * @returns ResponseTemplateManager Instance
+     */
+    static getInstance(): ResponseTemplateManager;
+    /**
+     * ResponseTemplateManager Instance
+     */
+    private static instance;
+    /**
+     * template container
+     */
+    templates: any;
+    private constructor();
+    /**
+     * Generate API response template string for given code and description
+     * @param code API response code
+     * @param description API response description
+     * @returns generate response template string
+     */
+    generateTemplate(code: string, description: string): string;
+    /**
+     * Add response template to template container
+     * @param id template id
+     * @param plain API plain response
+     * @returns ResponseTemplateManager instance for method chaining
+     */
+    addTemplate(id: string, plain: string): ResponseTemplateManager;
+    /**
+     * Get response template instance from template container
+     * @param id template id
+     * @returns template instance
+     */
+    getTemplate(id: string): Response;
+    /**
+     * Return all available response templates
+     * @returns all available response template instances
+     */
+    getTemplates(): any;
+    /**
+     * Check if given template exists in template container
+     * @param id template id
+     * @returns boolean result
+     */
+    hasTemplate(id: string): boolean;
+    /**
+     * Check if given API response hash matches a given template by code and description
+     * @param tpl2 api response hash
+     * @param id template id
+     * @returns boolean result
+     */
+    isTemplateMatchHash(tpl2: any, id: string): boolean;
+    /**
+     * Check if given API plain response matches a given template by code and description
+     * @param plain API plain response
+     * @param id template id
+     * @returns boolean result
+     */
+    isTemplateMatchPlain(plain: string, id: string): boolean;
+}