@team-internet/apiconnector 10.0.0

package/src/apiclient.ts

@@ -0,0 +1,579 @@
+import fetch from "cross-fetch";
+import { Logger } from "./logger.js";
+import { Response } from "./response.js";
+import { ResponseTemplateManager } from "./responsetemplatemanager.js";
+import { fixedURLEnc, SocketConfig } from "./socketconfig.js";
+import { toAscii } from "idna-uts46-hx";
+
+export const CNR_CONNECTION_URL_PROXY = "http://10.0.0.1/api/call.cgi";
+export const CNR_CONNECTION_URL_LIVE = "https://api.rrpproxy.net/api/call.cgi";
+export const CNR_CONNECTION_URL_OTE =
+  "https://api-ote.rrpproxy.net/api/call.cgi";
+
+const rtm = ResponseTemplateManager.getInstance();
+
+/**
+ * APIClient class
+ */
+export class APIClient {
+  /**
+   * API connection timeout setting
+   */
+  public static readonly socketTimeout: number = 300000;
+  /**
+   * User Agent string
+   */
+  private ua: string;
+  /**
+   * API connection url
+   */
+  private socketURL: string;
+  /**
+   * Object covering API connection data
+   */
+  private socketConfig: SocketConfig;
+  /**
+   * activity flag for debug mode
+   */
+  private debugMode: boolean;
+  /**
+   * additional connection settings
+   */
+  private curlopts: any;
+  /**
+   * logger function for debug mode
+   */
+  private logger: Logger | null;
+  /**
+   * set sub user account
+   */
+  private subUser: string;
+  /**
+   * set sub user account role seperater
+   */
+  private readonly roleSeparator: string = ":";
+
+  public constructor() {
+    this.ua = "";
+    this.socketURL = "";
+    this.debugMode = false;
+    this.setURL(CNR_CONNECTION_URL_LIVE);
+    this.socketConfig = new SocketConfig();
+    this.useLIVESystem();
+    this.curlopts = {};
+    this.logger = null;
+    this.subUser = "";
+    this.roleSeparator = ":";
+    this.setDefaultLogger();
+  }
+
+  /**
+   * set custom logger to use instead of default one
+   * @param customLogger
+   * @returns Current APIClient instance for method chaining
+   */
+  public setCustomLogger(customLogger: Logger): APIClient {
+    this.logger = customLogger;
+    return this;
+  }
+  /**
+   * set default logger to use
+   * @returns Current APIClient instance for method chaining
+   */
+  public setDefaultLogger(): APIClient {
+    this.logger = new Logger();
+    return this;
+  }
+  /**
+   * Enable Debug Output to STDOUT
+   * @returns Current APIClient instance for method chaining
+   */
+  public enableDebugMode(): APIClient {
+    this.debugMode = true;
+    return this;
+  }
+
+  /**
+   * Disable Debug Output
+   * @returns Current APIClient instance for method chaining
+   */
+  public disableDebugMode(): APIClient {
+    this.debugMode = false;
+    return this;
+  }
+
+  /**
+   * Get the API connection url that is currently set
+   * @returns API connection url currently in use
+   */
+  public getURL(): string {
+    return this.socketURL;
+  }
+
+  /**
+   * Possibility to customize default user agent to fit your needs
+   * @param str user agent label
+   * @param rv revision of user agent
+   * @param modules further modules to add to user agent string, format: ["<mod1>/<rev>", "<mod2>/<rev>", ... ]
+   * @returns Current APIClient instance for method chaining
+   */
+  public setUserAgent(str: string, rv: string, modules: any = []): APIClient {
+    const mods = modules.length ? " " + modules.join(" ") : "";
+    this.ua =
+      `${str} ` +
+      `(${process.platform}; ${process.arch}; rv:${rv})` +
+      mods +
+      ` node-sdk/${this.getVersion()} ` +
+      `node/${process.version}`;
+    return this;
+  }
+
+  /**
+   * Get the User Agent
+   * @returns User Agent string
+   */
+  public getUserAgent(): string {
+    if (!this.ua.length) {
+      this.ua =
+        `NODE-SDK (${process.platform}; ${
+          process.arch
+        }; rv:${this.getVersion()}) ` + `node/${process.version}`;
+    }
+    return this.ua;
+  }
+
+  /**
+   * Set the proxy server to use for API communication
+   * @param proxy proxy server to use for communicatio
+   * @returns Current APIClient instance for method chaining
+   */
+  public setProxy(proxy: string): APIClient {
+    this.curlopts.proxy = proxy;
+    return this;
+  }
+
+  /**
+   * Get the proxy server configuration
+   * @returns proxy server configuration value or null if not set
+   */
+  public getProxy(): string | null {
+    if (Object.prototype.hasOwnProperty.call(this.curlopts, "proxy")) {
+      return this.curlopts.proxy;
+    }
+    return null;
+  }
+
+  /**
+   * Set the referer to use for API communication
+   * @param referer Referer
+   * @returns Current APIClient instance for method chaining
+   */
+  public setReferer(referer: string): APIClient {
+    this.curlopts.referer = referer;
+    return this;
+  }
+
+  /**
+   * Get the referer configuration
+   * @returns referer configuration value or null if not set
+   */
+  public getReferer(): string | null {
+    if (Object.prototype.hasOwnProperty.call(this.curlopts, "referer")) {
+      return this.curlopts.referer;
+    }
+    return null;
+  }
+
+  /**
+   * Get the current module version
+   * @returns module version
+   */
+  public getVersion(): string {
+    return "10.0.0";
+  }
+
+  /**
+   * Apply session data (session id and system entity) to given client request session
+   * @param session ClientRequest session instance
+   * @returns Current APIClient instance for method chaining
+   */
+  public saveSession(session: any): APIClient {
+    session.socketcfg = {
+      login: this.socketConfig.getLogin(),
+      session: this.socketConfig.getSession(),
+    };
+    return this;
+  }
+
+  /**
+   * Use existing configuration out of ClientRequest session
+   * to rebuild and reuse connection settings
+   * @param session ClientRequest session instance
+   * @returns Current APIClient instance for method chaining
+   */
+  public reuseSession(session: any): APIClient {
+    if (
+      !session ||
+      !session.socketcfg ||
+      !session.socketcfg.login ||
+      !session.socketcfg.session
+    ) {
+      return this;
+    }
+    this.setCredentials(session.socketcfg.login);
+    this.socketConfig.setSession(session.socketcfg.session);
+    return this;
+  }
+
+  /**
+   * Set another connection url to be used for API communication
+   * @param value API connection url to set
+   * @returns Current APIClient instance for method chaining
+   */
+  public setURL(value: string): APIClient {
+    this.socketURL = value;
+    return this;
+  }
+
+  /**
+   * Set Persistent to request session id for API communication
+   * @param value API session id
+   * @returns Current APIClient instance for method chaining
+   */
+  public setPersistent(): APIClient {
+    this.socketConfig.setPersistent();
+    return this;
+  }
+
+  /**
+   * Set Credentials to be used for API communication
+   * @param uid account name
+   * @param pw account password
+   * @returns Current APIClient instance for method chaining
+   */
+  public setCredentials(uid: string, pw: string = ""): APIClient {
+    this.socketConfig.setLogin(uid);
+    this.socketConfig.setPassword(pw);
+    return this;
+  }
+
+  /**
+   * Set Credentials to be used for API communication
+   * @param uid account name
+   * @param role role user id
+   * @param pw role user password
+   * @returns Current APIClient instance for method chaining
+   */
+  public setRoleCredentials(
+    uid: string,
+    role: string,
+    pw: string = "",
+  ): APIClient {
+    return this.setCredentials(
+      role ? `${uid}${this.roleSeparator}${role}` : uid,
+      pw,
+    );
+  }
+
+  /**
+   * Perform API login to start session-based communication
+   * @param otp optional one time password
+   * @returns Promise resolving with API Response
+   */
+  public async login(): Promise<Response> {
+    this.setPersistent();
+    const rr = await this.request({}, false);
+    this.socketConfig.setSession("");
+    if (rr.isSuccess()) {
+      const col = rr.getColumn("SESSIONID");
+      this.socketConfig.setSession(col ? col.getData()[0] : "");
+    }
+    return rr;
+  }
+
+  /**
+   * Perform API logout to close API session in use
+   * @returns Promise resolving with API Response
+   */
+  public async logout(): Promise<Response> {
+    const rr = await this.request(
+      {
+        COMMAND: "StopSession",
+      },
+      false,
+    );
+    if (rr.isSuccess()) {
+      this.socketConfig.setSession("");
+    }
+    return rr;
+  }
+
+  /**
+   * Perform API request using the given command
+   * @param cmd API command to request
+   * @returns Promise resolving with API Response
+   */
+  public async request(cmd: any, setUserView = true): Promise<Response> {
+    // set sub user id if available
+    if (setUserView && this.subUser !== "") {
+      cmd.SUBUSER = this.subUser;
+    }
+
+    // flatten nested api command bulk parameters
+    let mycmd = this.flattenCommand(cmd);
+
+    // auto convert umlaut names to punycode
+    mycmd = await this.autoIDNConvert(mycmd);
+
+    // request command to API
+    const cfg: any = {
+      CONNECTION_URL: this.socketURL,
+    };
+    // TODO: 300s (to be sure to get an API response)
+    const reqCfg: any = {
+      // encoding: "utf8", //default for type string
+      // gzip: true,
+      body: this.getPOSTData(mycmd),
+      headers: {
+        "User-Agent": this.getUserAgent(),
+      },
+      method: "POST",
+      timeout: APIClient.socketTimeout,
+      url: cfg.CONNECTION_URL,
+    };
+    const proxy = this.getProxy();
+    if (proxy) {
+      reqCfg.proxy = proxy;
+    }
+    const referer = this.getReferer();
+    if (referer) {
+      reqCfg.headers.Referer = referer;
+    }
+    return fetch(cfg.CONNECTION_URL, reqCfg)
+      .then(async (res: any) => {
+        let error = null;
+        let body;
+        if (res.ok) {
+          // res.status >= 200 && res.status < 300
+          body = await res.text();
+        } else {
+          error = res.status + (res.statusText ? " " + res.statusText : "");
+          body = rtm.getTemplate("httperror").getPlain();
+        }
+        const rr = new Response(body, mycmd, cfg);
+        if (this.debugMode && this.logger) {
+          this.logger.log(this.getPOSTData(mycmd, true), rr, error);
+        }
+        return rr;
+      })
+      .catch((err) => {
+        const body = rtm.getTemplate("httperror").getPlain();
+        const rr = new Response(body, mycmd, cfg);
+        if (this.debugMode && this.logger) {
+          this.logger.log(this.getPOSTData(mycmd, true), rr, err.message);
+        }
+        return rr;
+      });
+  }
+
+  /**
+   * Request the next page of list entries for the current list query
+   * Useful for tables
+   * @param rr API Response of current page
+   * @returns Promise resolving with API Response or null in case there are no further list entries
+   */
+  public async requestNextResponsePage(rr: Response): Promise<Response | null> {
+    const mycmd = rr.getCommand();
+    if (Object.prototype.hasOwnProperty.call(mycmd, "LAST")) {
+      throw new Error(
+        "Parameter LAST in use. Please remove it to avoid issues in requestNextPage.",
+      );
+    }
+    let first = 0;
+    if (Object.prototype.hasOwnProperty.call(mycmd, "FIRST")) {
+      first = mycmd.FIRST;
+    }
+    const total = rr.getRecordsTotalCount();
+    const limit = rr.getRecordsLimitation();
+    first += limit;
+    if (first < total) {
+      mycmd.FIRST = first;
+      mycmd.LIMIT = limit;
+      return this.request(mycmd);
+    }
+
+    return null;
+  }
+
+  /**
+   * Request all pages/entries for the given query command
+   * @param cmd API list command to use
+   * @returns Promise resolving with array of API Responses
+   */
+  public async requestAllResponsePages(cmd: any): Promise<Response[]> {
+    const responses: Response[] = [];
+    let rr: Response | null = await this.request({ ...cmd, FIRST: 0 });
+
+    while (rr !== null) {
+      responses.push(rr);
+      rr = await this.requestNextResponsePage(rr);
+    }
+
+    return responses;
+  }
+
+  /**
+   * Set a data view to a given subuser
+   * @param uid subuser account name
+   * @returns Current APIClient instance for method chaining
+   */
+  public setUserView(uid: string): APIClient {
+    this.subUser = uid;
+    return this;
+  }
+
+  /**
+   * Reset data view back from subuser to user
+   * @returns Current APIClient instance for method chaining
+   */
+  public resetUserView(): APIClient {
+    this.subUser = "";
+    return this;
+  }
+
+  /**
+   * Activate High Performance Connection Setup
+   * @see https://github.com/centralnicgroup-opensource/rtldev-middleware-node-sdk/blob/master/README.md
+   * @returns Current APIClient instance for method chaining
+   */
+  public useHighPerformanceConnectionSetup(): APIClient {
+    this.setURL(CNR_CONNECTION_URL_PROXY);
+    return this;
+  }
+
+  /**
+   * Activate Default Connection Setup (the default)
+   * @returns Current APIClient instance for method chaining
+   */
+  public useDefaultConnectionSetup(): APIClient {
+    this.setURL(CNR_CONNECTION_URL_LIVE);
+    return this;
+  }
+
+  /**
+   * Set OT&E System for API communication
+   * @returns Current APIClient instance for method chaining
+   */
+  public useOTESystem(): APIClient {
+    this.setURL(CNR_CONNECTION_URL_OTE);
+    return this;
+  }
+
+  /**
+   * Set LIVE System for API communication (this is the default setting)
+   * @returns Current APIClient instance for method chaining
+   */
+  public useLIVESystem(): APIClient {
+    this.setURL(CNR_CONNECTION_URL_LIVE);
+    return this;
+  }
+
+  /**
+   * Serialize given command for POST request including connection configuration data
+   * @param cmd API command to encode
+   * @returns encoded POST data string
+   */
+  public getPOSTData(cmd: any, secured = false): string {
+    let data = this.socketConfig.getPOSTData();
+    if (secured) {
+      data = data.replace(/s_pw=[^&]+/, "s_pw=***");
+    }
+
+    let tmp = "";
+    if (!(typeof cmd === "string" || cmd instanceof String)) {
+      Object.keys(cmd).forEach((key: string) => {
+        if (cmd[key] !== null && cmd[key] !== undefined) {
+          tmp += `${key}=${cmd[key].toString().replace(/\r|\n/g, "")}\n`;
+        }
+      });
+    } else {
+      tmp = "" + cmd;
+    }
+    if (secured) {
+      tmp = tmp.replace(/PASSWORD=[^\n]+/, "PASSWORD=***");
+    }
+    tmp = tmp.replace(/\n$/, "");
+    if (Object.keys(cmd).length > 0) {
+      data += `${fixedURLEnc("s_command")}=${fixedURLEnc(tmp)}`;
+    }
+
+    return data.endsWith("&") ? data.slice(0, -1) : data;
+  }
+
+  /**
+   * Flatten nested arrays in command
+   * @param cmd api command
+   * @returns api command with flattended parameters
+   */
+  private flattenCommand(cmd: any): any {
+    const newcmd: any = {};
+    Object.keys(cmd).forEach((key: string) => {
+      const val = cmd[key];
+      const newKey = key.toUpperCase();
+      if (val !== null && val !== undefined) {
+        if (Array.isArray(val)) {
+          let index = 0;
+          for (const row of val) {
+            newcmd[`${newKey}${index}`] = (row + "").replace(/\r|\n/g, "");
+            index++;
+          }
+        } else {
+          if (typeof val === "string" || val instanceof String) {
+            newcmd[newKey] = val.replace(/\r|\n/g, "");
+          } else {
+            newcmd[newKey] = val;
+          }
+        }
+      }
+    });
+    return newcmd;
+  }
+
+  /**
+   * Auto convert API command parameters to punycode, if necessary.
+   * @param cmd api command
+   * @returns Promise resolving with api command with IDN values replaced to punycode
+   */
+  private async autoIDNConvert(cmd: any): Promise<any> {
+    const keyPattern = /^(NAMESERVER|NS|DNSZONE)([0-9]*)$/i;
+    const objClassPattern =
+      /^(DOMAIN(APPLICATION|BLOCKING)?|NAMESERVER|NS|DNSZONE)$/i;
+    const asciiPattern = /^[A-Za-z0-9.\-]+$/;
+
+    const toConvert: string[] = [];
+    const idxs: string[] = [];
+
+    Object.keys(cmd).forEach((key) => {
+      const val = cmd[key];
+      if (
+        (keyPattern.test(key) ||
+          (key.toUpperCase() === "OBJECTID" &&
+            cmd.OBJECTCLASS &&
+            objClassPattern.test(cmd.OBJECTCLASS))) &&
+        !asciiPattern.test(val)
+      ) {
+        toConvert.push(val);
+        idxs.push(key);
+      }
+    });
+
+    if (toConvert.length > 0) {
+      const convertedValues = toConvert.map((value) => toAscii(value));
+      convertedValues.forEach((convertedValue, idx) => {
+        cmd[idxs[idx]] = convertedValue;
+      });
+    }
+
+    return cmd;
+  }
+}

package/src/column.ts

@@ -0,0 +1,57 @@
+/**
+ * Column class
+ */
+export class Column {
+  /**
+   * count of column data entries
+   */
+  public length: number;
+  /**
+   * column key name
+   */
+  private key: string;
+  /**
+   * column data container
+   */
+  private data: string[];
+
+  public constructor(key: string, data: string[]) {
+    this.key = key;
+    this.data = data;
+    this.length = data.length;
+  }
+
+  /**
+   * Get column name
+   * @returns column name
+   */
+  public getKey(): string {
+    return this.key;
+  }
+
+  /**
+   * Get column data
+   * @returns column data
+   */
+  public getData(): string[] {
+    return this.data;
+  }
+
+  /**
+   * Get column data at given index
+   * @param idx data index
+   * @returns data at given index
+   */
+  public getDataByIndex(idx: number): string | null {
+    return this.hasDataIndex(idx) ? this.data[idx] : null;
+  }
+
+  /**
+   * Check if column has a given data index
+   * @param idx data index
+   * @returns boolean result
+   */
+  private hasDataIndex(idx: number): boolean {
+    return idx >= 0 && idx < this.length;
+  }
+}

package/src/customlogger.ts

@@ -0,0 +1,29 @@
+import { Logger } from "./logger.js";
+import { Response } from "./response.js";
+
+/**
+ * Logger class
+ */
+export class CustomLogger extends Logger {
+  /**
+   * output/log given data
+   * @param post request string used
+   * @param r Response object
+   * @param error error message or null
+   * @return current Logger instance for method chaining
+   */
+  public log(
+    post: string,
+    r: Response,
+    error: string | null = null,
+  ): CustomLogger {
+    // apply here whatever you need e.g.
+    console.log(post);
+    console.dir(r.getCommand());
+    if (error) {
+      console.error(error);
+    }
+    console.log(r.getPlain());
+    return this;
+  }
+}

package/src/index.ts

@@ -0,0 +1,18 @@
+import { APIClient } from "./apiclient.js";
+import { Response } from "./response.js";
+import { ResponseTemplateManager } from "./responsetemplatemanager.js";
+
+export {
+  /**
+   * APIClient class
+   */
+  APIClient,
+  /**
+   * Response class
+   */
+  Response, // need this to replace 'applyCustomChanges'
+  /**
+   * ResponseTemplateManager class
+   */
+  ResponseTemplateManager,
+};

package/src/logger.ts

@@ -0,0 +1,23 @@
+import { Response } from "./response.js";
+
+/**
+ * Logger class
+ */
+export class Logger {
+  /**
+   * output/log given data
+   * @param post request string used
+   * @param r Response object
+   * @param error error message or null
+   * @return current Logger instance for method chaining
+   */
+  public log(post: string, r: Response, error: string | null = null): Logger {
+    console.dir(r.getCommand());
+    console.log(post);
+    if (error) {
+      console.error(`HTTP communication failed: ${error}`);
+    }
+    console.log(r.getPlain());
+    return this;
+  }
+}