api_connect_nodejs 1.0.1 → 2.0.1

package/src/feed/feed.js

@@ -0,0 +1,139 @@
+const net = require("net");
+const configData = require("../iniparser");
+const log4js = require("../logger");
+const streamingConstants = require("../../enums/streamingConstants");
+class Feed {
+  /**
+   * Streamer
+   *
+   * To subscribe to the streamer, Create the single instance of this mentioning `callback` method. After successsful subscription, `callback` method will be called whenever packet is available at the streamer.
+   * @param {string} userid User ID
+   * @param {(err?, data?, close?: number) => void} callBack Callback to receive the Feed in
+   * @param {boolean} subscribe_order
+   * @param {boolean} subscribe_quote
+   */
+  constructor() {
+    this.sock = new net.Socket();
+    this.status = false;
+    this.init();
+    this.requestsList = {};
+  }
+
+  init = () => {
+    this.connect();
+  };
+
+  connect = () => {
+    const hostName = configData.hostName;
+    const port = configData.port;
+    try {
+      this.sock.connect(port, hostName, () => {
+        this.clearIntervalConnect();
+        console.log("connected to server!");
+        log4js.debug("connected to server!");
+      });
+    } catch (error) {
+      console.log("connect error is " + error);
+      log4js.debug("connect error is " + error);
+      this.reconnect();
+    }
+  };
+
+  clearIntervalConnect = () => {
+    if (false === this.status) return;
+    clearInterval(this.status);
+    this.status = false;
+  };
+
+  reconnect = () => {
+    console.log("reconnecting...");
+    log4js.debug("reconnecting...");
+
+    if (this.status) return;
+    this.status = setInterval(() => {
+      this.sock.removeAllListeners();
+      this.connect();
+    }, 3000);
+  };
+
+  subsribe = (streamingConstants, request, callBack) => {
+    const requestObj = {
+      request: request,
+      callback: callBack,
+    };
+    this.requestsList[streamingConstants] = requestObj;
+    this.readWriteStreamData(requestObj);
+  };
+
+  unsubsribe = (streamingConstants, request) => {
+    const requestObj = {
+      request: request,
+      callback: this.requestsList[streamingConstants].callback,
+    };
+    this.readWriteStreamData(requestObj);
+    delete this.requestsList[streamingConstants];
+  };
+
+  readWriteStreamData = (requestObj) => {
+    try {
+      this.sock.write(JSON.stringify(requestObj.request) + "\n");
+      this.sock.on("data", (data) => {
+        try {
+          let result = data.toString();
+          if (result) {
+            if (
+              result.match(new RegExp("orderFiler", "g")) &&
+              result.match(new RegExp("orderFiler", "g")).length > 0
+            ) {
+              let callbackMethod =
+                this.requestsList[streamingConstants.ORDER_STREAM_REQ_CODE][
+                  "callback"
+                ];
+              callbackMethod(null, result, null);
+            } else if (
+              result.match(new RegExp("quote3", "g")) &&
+              result.match(new RegExp("quote3", "g")).length > 0
+            ) {
+              let callbackMethod =
+                this.requestsList[streamingConstants.QUOTE_SREAM_REQ_CODE][
+                  "callback"
+                ];
+              callbackMethod(null, result, null);
+            } else if (
+              result.match(new RegExp("news", "g")) &&
+              result.match(new RegExp("news", "g")).length > 0
+            ) {
+              let callbackMethod =
+                this.requestsList[streamingConstants.LIVENEWS_STREAM_REQ_CODE][
+                  "callback"
+                ];
+              callbackMethod(null, result, null);
+            }
+          }
+        } catch (error) {
+          return false;
+        }
+      });
+
+      this.sock.on("end", (val) => {
+        console.log("Connection ended ");
+        this.reconnect();
+      });
+
+      this.sock.on("error", (err) => {
+        log4js.debug("connection error " + err);
+        requestObj.callback(err, null, null);
+        this.reconnect();
+      });
+
+      this.sock.on("close", (val) => {
+        log4js.debug("connection closed " + val);
+        this.reconnect();
+      });
+    } catch (error) {
+      console.log({ error });
+    }
+  };
+}
+
+module.exports = Feed;

package/src/feed/liveNewsFeed.js

@@ -0,0 +1,112 @@
+const log4js = require("../logger");
+const configData = require("../iniparser");
+const { LIVENEWS_STREAM_REQ_CODE } = require("../../enums/streamingConstants");
+const {
+  validateStreamerCallback,
+} = require("../../validations/feedStreamerValidator");
+
+class LiveNewsFeed {
+  /**
+   * Streamer
+   * LiveNewsFeed Class for subsribe or unsubsribe News
+   */
+  constructor(feed) {
+    this.feed = feed;
+  }
+
+  /**
+   * LiveNews Feed RequestBody Schema
+   * @function liveNewsRequestBody
+   * @returns object
+   */
+  requestBody = () => {
+    return {
+      request: {
+        streaming_type: "news",
+        formFactor: configData.formFactor,
+        appID: configData.ApiIdKey,
+        response_format: "json",
+        request_type: "",
+      },
+      echo: {},
+    };
+  };
+
+  /**
+   * Create LiveNews Request Body
+   * Returns liveNewsRequestBody
+   * @function createLivenewsRequest
+   * @param {boolean} subsribe - true for subsribe and false for unsubsribe
+   * @returns object
+   */
+  createLivenewsRequest = (subscribe = false) => {
+    let body = {};
+    try {
+      body = this.requestBody();
+      if (subscribe) {
+        body.request.request_type = "subscribe";
+      } else {
+        body.request.request_type = "unsubscribe";
+      }
+    } catch (error) {
+      log4js.debug("createLivenewsRequest error - " + error);
+    } finally {
+      return body;
+    }
+  };
+
+  /**
+   * Subsribe LiveNews
+   * To subscribe to the streamer, Create the single instance of this mentioning `callback` method. After successsful subscription, `callback` method will be called whenever packet is available at the streamer.
+   * @async
+   * @function subscribeLiveNewsFeed
+   * @param {(err?, data?, close?: number) => void} callBack Callback to receive the Feed in
+   * @returns
+   */
+  subscribeLiveNewsFeed = async (callback) => {
+    try {
+      /** Validation Start */
+      const validateResponse = validateStreamerCallback(callback);
+
+      if (validateResponse.error) {
+        log4js.debug(
+          "subscribeLiveNewsFeed validation error - " +
+            validateResponse.error.details
+        );
+        return Promise.reject(validateResponse.error.details);
+      }
+      /** Validation End */
+
+      /** Get LiveNews Request */
+      const liveNewsRequest = this.createLivenewsRequest(true);
+      /** Call connect method of Feed Class */
+      this.feed.subsribe(LIVENEWS_STREAM_REQ_CODE, liveNewsRequest, callback);
+    } catch (error) {
+      log4js.debug("subscribeLiveNewsFeed error - " + error);
+      console.log(error);
+    }
+  };
+
+  /**
+   * Unsubsribe LiveNews Feed
+   * This method will unsubscribe the symbols from the streamer. After successful invokation of this, will stop the streamer packets of these symbols.
+   * @async
+   * @function unsubscribeLiveNewsFeed
+   * @param {Object[]} - Array of unsubsribe Symbols
+   * @returns
+   */
+  unsubscribeLiveNewsFeed = async () => {
+    try {
+      /** Get LiveNews Request */
+      const liveNewsRequest = this.createLivenewsRequest();
+
+      /** Unsubscribe liveNews */
+      this.feed.unsubsribe(LIVENEWS_STREAM_REQ_CODE, liveNewsRequest);
+    } catch (error) {
+      log4js.debug("unsubscribeLiveNews error - " + error);
+      console.log(error);
+    }
+  };
+}
+
+module.exports = LiveNewsFeed;

package/src/feed/ordersFeed.js

@@ -0,0 +1,124 @@
+const log4js = require("../logger");
+const configData = require("../iniparser");
+const { ORDER_STREAM_REQ_CODE } = require("../../enums/streamingConstants");
+const {
+  validateSubscribeOrdersFeed,
+} = require("../../validations/feedStreamerValidator");
+class OrdersFeed {
+  /**
+   * Streamer
+   * OrderFeed Class for subsribe or unsubsribe order
+   * @param {string} accid Customer Account ID
+   * @param {string} userid User ID
+   */
+  constructor(feed, accountId, userId) {
+    this.feed = feed;
+    this.accountId = accountId;
+    this.userId = userId;
+  }
+
+  /**
+   * Orders Feed RequestBody Structure
+   * Return OrderFeed RequestBody Structure
+   * @function ordersFeedRequestBody
+   * @returns object
+   */
+  ordersFeedRequestBody = () => {
+    return {
+      request: {
+        streaming_type: "orderFiler",
+        data: {
+          accType: "EQ",
+          userID: this.userId,
+          accID: this.accountId,
+          responseType: ["ORDER_UPDATE", "TRADE_UPDATE"],
+        },
+        formFactor: configData.formFactor,
+        appID: configData.ApiIdKey,
+        response_format: "json",
+        request_type: "",
+      },
+      echo: {},
+    };
+  };
+
+  /**
+   * Create OrdersFeed Request Body
+   * @param {boolean} subscribe - true for subsribe and false for unsubsribe
+   * @returns object
+   */
+  createOrderRequest = (subscribe = false) => {
+    let body = {};
+    try {
+      body = this.ordersFeedRequestBody();
+      if (subscribe) {
+        body.request.request_type = "subscribe";
+      } else {
+        body.request.request_type = "unsubscribe";
+      }
+    } catch (error) {
+      log4js.debug("createOrderRequest error - " + error);
+    } finally {
+      return body;
+    }
+  };
+
+  /**
+   * Subsribe Order Feed
+   * To subscribe to the streamer, Create the single instance of this mentioning `callback` method. After successsful subscription, `callback` method will be called whenever packet is available at the streamer.
+   * @async
+   * @function subscribeOrdersFeed
+   * @param {(err?, data?, close?: number) => void} callBack Callback to receive the Feed in
+   * @returns
+   */
+  subscribeOrdersFeed = async (callback) => {
+    try {
+      /** Validation Start */
+      const validateResponse = validateSubscribeOrdersFeed(
+        this.accountId,
+        this.userId,
+        callback
+      );
+
+      if (validateResponse.error) {
+        log4js.debug(
+          "SubscribeOrdersFeed validation error - " +
+            validateResponse.error.details
+        );
+        return Promise.reject(validateResponse.error.details);
+      }
+      /** Validation End */
+
+      /** Get Order Request */
+      let orderRequest = this.createOrderRequest(true);
+
+      /** Call connect method of Feed Class */
+      this.feed.subsribe(ORDER_STREAM_REQ_CODE, orderRequest, callback);
+    } catch (error) {
+      log4js.debug("SubscribeOrdersFeed error - " + error);
+      console.log(error);
+    }
+  };
+
+  /**
+   * Unsubsribe Order Feed
+   * This method will unsubscribe the streamer. After successful invokation of this, will stop the streamer.
+   * @async
+   * @function unsubscribeOrdersFeed
+   * @returns
+   */
+  unsubscribeOrdersFeed = async () => {
+    try {
+      /** Get Order Request */
+      const orderRequest = this.createOrderRequest();
+
+      /** Unsubsribe OrderFeed */
+      this.feed.unsubsribe(ORDER_STREAM_REQ_CODE, orderRequest);
+    } catch (error) {
+      log4js.debug("unsubscribeOrdersFeed error - " + error);
+      console.log(error);
+    }
+  };
+}
+
+module.exports = OrdersFeed;

package/src/feed/quotesFeed.js

@@ -0,0 +1,121 @@
+const log4js = require("../logger");
+const configData = require("../iniparser");
+const { QUOTE_SREAM_REQ_CODE } = require("../../enums/streamingConstants");
+const {
+  validateSubscribeQuotesFeed,
+  validateUnsubscribeQuotesFeed,
+} = require("../../validations/feedStreamerValidator");
+
+class QuotesFeed {
+  /**
+   * Streamer
+   * QuotesFeed Class for subsribe or unsubsribe Quotes
+   */
+  constructor(feed) {
+    this.feed = feed;
+  }
+
+  /**
+   * QutoesFeed RequestBody Structure
+   * Return QuotesFeed RequestBody Structure
+   * @function quotesFeedRequestBody
+   * @returns object
+   */
+  requestBody = () => {
+    return {
+      request: {
+        streaming_type: "quote3",
+        data: {
+          "accType": "EQ",
+          symbols: [],
+        },
+        formFactor: configData.formFactor,
+        appID: configData.ApiIdKey,
+        response_format: "json",
+        request_type: "",
+      },
+      echo: {},
+    };
+  };
+
+  /**
+   * Create QuotesFeed RequestBody
+   * Return QuotesFeed RequestBody
+   * @function createQuotesFeedRequest
+   * @param {Object[]} symbols - Array of subsribe Symbols
+   * @param {boolean} order - true for subsribe and false for unsubsribe
+   * @returns object
+   */
+  createQuotesFeedRequest = (symbols, quote = false) => {
+    let body = {};
+    try {
+      body = this.requestBody();
+      const symset = symbols.map((sym) => ({ symbol: sym.trim() }));
+     
+      body.request.data.symbols = symset;
+
+      if (quote) {
+        body.request.request_type = "subscribe";
+      } else {
+        body.request.request_type = "unsubscribe";
+      }
+    } catch (error) {
+      log4js.debug("createQuotesFeedRequest error - " + error);
+    } finally {
+      return body;
+    }
+  };
+
+  /**
+   * To subscribe to the streamer, Create the single instance of this mentioning `callback` method. After successsful subscription, `callback` method will be called whenever packet is available at the streamer.
+   * @async
+   * @function subscribeQuotesFeed
+   * @param {(err?, data?, close?: number) => void} callBack Callback to receive the Feed in
+   * @param {Array<string>} symbols Symbol list for subscription: Symbol_exchange to be obtained from Contract File
+   * @returns
+   */
+  subscribeQuotesFeed = async (symbols, callback) => {
+    try {
+      /** Validation Start */
+      const validateResponse = validateSubscribeQuotesFeed(callback, symbols);
+
+      if (validateResponse.error) {
+        log4js.debug(
+          "subscribeQuotesFeed validation error - " +
+            validateResponse.error.details
+        );
+        return Promise.reject(validateResponse.error.details);
+      }
+      /** Validation End */
+
+      /** Create Streaming Quote Request */
+      let quoteRequest = this.createQuotesFeedRequest(symbols, true);
+      /** Call connect method of Feed Class */
+      this.feed.subsribe(QUOTE_SREAM_REQ_CODE, quoteRequest, callback);
+    } catch (error) {
+      log4js.debug("subscribeQuotesFeed error - " + error);
+      console.log(error);
+    }
+  };
+
+  /**
+   * This method will unsubscribe the symbols from the streamer. After successful invokation of this, will stop the streamer packets of these symbols.
+   * @async
+   * @function unsubscribeQuotesFeed
+   * @returns
+   */
+  unsubscribeQuotesFeed = async () => {
+    try {
+      /** Get Streaming Quote Request */
+      const quoteRequest = this.createQuotesFeedRequest([]);
+
+      /** Unsubsribe symbols */
+      this.feed.unsubsribe(QUOTE_SREAM_REQ_CODE, quoteRequest);
+    } catch (error) {
+      log4js.debug("unsubscribeQuotesFeed error - " + error);
+      console.log(error);
+    }
+  };
+}
+
+module.exports = QuotesFeed;