api_connect_nodejs 2.0.10 → 2.0.11

package/conf/settings.ini

@@ -6,10 +6,11 @@ BasePathEq = https://nc.nuvamawealth.com/edelmw-eq/eq/
 BasePathComm = https://nc.nuvamawealth.com/edelmw-comm/comm/
 BasePathMf = https://nc.nuvamawealth.com/edelmw-mf/mf/
 BasePathContent = https://nc.nuvamawealth.com/edelmw-content/content/
+BasePathReport = https://nc.nuvamawealth.com/app-report/equity/
 EquityContractURL = https://nc.nuvamawealth.com/app/toccontracts/instruments.zip
 MFContractURL = https://nc.nuvamawealth.com/app/toccontracts/mfInstruments.zip
 
-ApiIdKey = eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhcHAiOjAsImZmIjoiVyIsImJkIjoid2ViLXBjIiwibmJmIjoxNjk4OTk0MTM1LCJzcmMiOiJlbXRtdyIsImF2IjoiMi4wLjYiLCJhcHBpZCI6IjhjZmE0MGJiYmUxMjQ5MGM2YzhjYzMwOWNlZmViZGQzIiwiaXNzIjoiZW10IiwiZXhwIjoxNjk5MDM2MjAwLCJpYXQiOjE2OTg5OTQ0MzV9.rwTusEQqt0VuYlW1-MSsixJm3RJGQTj2AFt8e_GsY3o
+ApiIdKey = eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhcHAiOjAsImZmIjoiVyIsImJkIjoid2ViLXBjIiwibmJmIjoxNzAzODUxOTQyLCJzcmMiOiJlbXRtdyIsImF2IjoiMi4wLjExIiwiYXBwaWQiOiI2NDE2ODVkOTExNjc0OTgyZDFjMGI5YzQzMmMxYWIyYiIsImlzcyI6ImVtdCIsImV4cCI6MTcwMzg3NDYwMCwiaWF0IjoxNzAzODUyMjQyfQ.m4RBAPmJc0RF1c1aR45kpVM7xPegx_F01F3nX-Bmiag
 TlsVersion = 1.2
 LogLevel = All
 

package/enums/segmentType.js

@@ -0,0 +1,11 @@
+/**
+ * Define segmentType as enum
+ */
+
+const segmentType = Object.freeze({
+    EQUITY: "EQUITY",
+    COMMODITY: "COMMODITY",
+  });
+  
+  module.exports = segmentType;
+  

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "api_connect_nodejs",
-  "version": "2.0.10",
+  "version": "2.0.11",
   "description": "Command to run :",
   "main": "index.js",
   "directories": {

package/src/apiConnect.js

@@ -4,6 +4,7 @@ const log4js = require("./logger.js");
 const Order = require("./order");
 const Chart = require("./chart");
 const Quote = require("./quote");
+const Report = require("./report");
 const LiveNews = require("./liveNews");
 const Watchlist = require("./watchlist");
 const ResearchCalls = require("./researchCalls");
@@ -557,6 +558,41 @@ class APIConnect {
     return response;
   };
 
+  /**
+   *
+   * @param {"FUTSTK" | "FUTIDX" | "FUTCUR" | "FUTCOM" | "OPTIDX" | "OPTSTK" | "OPTCUR" | "OPTFUT" | "EQUITY" | "INDEX"} assetType
+   * @param {string} symbol
+   * @param {"NSE" | "BSE" | "NFO" |  "NFO" | "MCX" | "NCDEX" | "INDEX"} exchangeType
+   * @param {string} fromDate yyyy-MM-dd
+   * @param {string} toDate yyyy-MM-dd
+   * @param {boolean} includeContinuousFuture
+   * @returns
+   */
+  getCustomPeriodChart = (
+    assetType,
+    symbol,
+    exchangeType,
+    fromDate,
+    toDate,
+    includeContinuousFuture = false
+  ) => {
+    let response = {};
+    log4js.info("getCustomPeriodChart method is called.");
+    let interval = "D1";
+    const chartObj = new Chart(this.__http, this.__config, this.__constants);
+    response = chartObj.getCustomPeriodChartAPI(
+      interval,
+      assetType,
+      symbol,
+      exchangeType,
+      fromDate,
+      toDate,
+      includeContinuousFuture
+    );
+
+    return response;
+  };
+
   //Get News Categories
   getNewsCategories = () => {
     log4js.info("Inside getNewsCategories method");
@@ -1268,6 +1304,7 @@ class APIConnect {
       exc: Exchange,
       prdCode: this.__constants.getValidProductCode(this.fileName, Exchange, ProductCode),
       ordTyp: Order_Type,
+      curQty: CurrentQuantity,
     };
     
     if (Exchange == "MCX" || Exchange == "NCDEX") {
@@ -2476,6 +2513,27 @@ class APIConnect {
     return response;
   };
 
+  //Get TRansaction History
+  /**
+   *
+   * @param {string} segment
+   * @param {string} fromDate
+   * @param {string} toDate
+   * @returns
+   */
+  getTransactionHistory = (
+    segment, fromDate, toDate
+  ) => {
+    let response = {};
+    log4js.info("getTransactionHistory method is called.");
+    const reportObj = new Report(this.__http, this.__config, this.__constants);
+    response = reportObj.getTransactionHistoryAPI(
+      segment, fromDate, toDate
+    );
+
+    return response;
+  };
+
   //CheckDependentAndUpdateData
   /**
    *

package/src/chart.js

@@ -71,6 +71,66 @@ class Chart {
     }
   };
 
+  /**
+   * Modifying the response
+   */
+
+  datewithoutTime = function (inputDate) {
+    var d = new Date(inputDate);
+    d.setHours(0, 0, 0, 0);
+    return d;
+  }
+
+  modifyResponseForCustomPeriod = async (response, toDate) => {
+    
+    try {
+      const modifyResponse = {};
+      let msgID = "";
+      let srvTm = "";
+      var convertedToDate = new Date(toDate);
+      const charts = [];
+      if (Object.keys(response).length !== 0) {
+        msgID = response["msgID"];
+        srvTm = response["srvTm"];
+        const data = response.data;
+        const pltPnts = data.pltPnts;
+        if (
+          Object.keys(data).length !== 0 &&
+          Object.keys(pltPnts).length !== 0
+        ) {
+          const isArray = await this.checkResponseHaveArrayOrNot(pltPnts);
+          if (isArray && pltPnts.ltt.length > 0) {
+            modifyResponse["nextTillDate"] = pltPnts.ltt[0];
+            for (let i = 0; i < pltPnts.ltt.length; i++) {
+
+              var convertedPlotPointDate = new Date(pltPnts.ltt[i]);
+
+              if(this.datewithoutTime(convertedPlotPointDate) > this.datewithoutTime(convertedToDate)) {
+                break
+              }
+              const dataArray = [];
+              dataArray[0] = pltPnts.ltt[i];
+              dataArray[1] = pltPnts.open[i];
+              dataArray[2] = pltPnts.high[i];
+              dataArray[3] = pltPnts.low[i];
+              dataArray[4] = pltPnts.close[i];
+              dataArray[5] = pltPnts.vol[i];
+              charts.push(dataArray);
+            }
+          }
+        }
+      }
+
+      modifyResponse["data"] = charts;
+      modifyResponse["msgID"] = msgID;
+      modifyResponse["srvTm"] = srvTm;
+      log4js.debug("modifyResponse for Custom period:" + JSON.stringify(modifyResponse));
+      return modifyResponse;
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+
   convertToBoolean = async (value) => {
     if (value === "TRUE" || value === "true") {
       return true;
@@ -254,5 +314,91 @@ class Chart {
       return Promise.reject(error);
     }
   };
+
+  /**
+   *
+   * @param {"D1" | "W1" | "MN1"} interval
+   * @param {"FUTSTK" | "FUTIDX" | "FUTCUR" | "FUTCOM" | "OPTIDX" | "OPTSTK" | "OPTCUR" | "OPTFUT" | "EQUITY" | "INDEX"} assetType
+   * @param {string} symbol
+   * @param {"NSE" | "BSE" | "NFO" |  "NFO" | "MCX" | "NCDEX" | "INDEX"} exchangeType
+   * @param {string} fromDate yyyy-MM-dd
+   * @param {string} toDate yyyy-MM-dd
+   * @param {boolean} includeContinuousFuture
+   * @returns
+   */
+  getCustomPeriodChartAPI = async (
+    interval,
+    assetType,
+    symbol,
+    exchangeType,
+    fromDate,
+    toDate,
+    includeContinuousFuture
+  ) => {
+    let result = {};
+    try {
+      //Convert into boolean
+      includeContinuousFuture = await this.convertToBoolean(
+        includeContinuousFuture
+      );
+      interval = "D1"
+      /**
+       * Validate eod chart params
+       */
+      const validateResponse = validateChartCustomPeriod(
+        interval,
+        assetType,
+        symbol,
+        exchangeType,
+        fromDate,
+        toDate,
+        includeContinuousFuture
+      );
+      if (validateResponse.error) {
+        log4js.debug(
+          "CustomPeriod chart validation error - " + JSON.stringify(validateResponse.error.details)
+        );
+        return Promise.reject(validateResponse.error.details);
+      }
+
+      //Request Body
+      const requestBodyData = this.chartRequestBody();
+
+      /**
+       * If AssetType Amongst FUTIDX, FUTSTK,FUTCUR,FUTCOM then we take user input(includeContinuousFuture) otherwise set false
+       */
+      if (!Object.values(futureAssetType).includes(assetType)) {
+        includeContinuousFuture = false;
+      } else {
+        requestBodyData.conti = includeContinuousFuture;
+      }
+
+      requestBodyData.frmDt = fromDate;
+      requestBodyData.toDt = toDate;
+      requestBodyData.prdTyp = "CUST"
+      delete requestBodyData.ltt;
+      
+      const url = this.__config.ChartURL(
+        interval,
+        exchangeType,
+        assetType,
+        symbol
+      );
+      log4js.debug("EOD URL -" + url);
+
+      const response = await this.__http.PostMethod(url, requestBodyData);
+      if (result.length !== 0) {
+        result = this.modifyResponseForCustomPeriod(response, toDate);
+      } else {
+        result = response;
+      }
+      log4js.debug("EOD Result :" + JSON.stringify(result));
+      return result;
+    } catch (error) {
+      log4js.debug("EOD error - " + error);
+      return Promise.reject(error);
+    }
+  };
+
 }
 module.exports = Chart;

package/src/config.js

@@ -5,8 +5,10 @@ class __Config {
   baseurleq = "/edelmw-eq/eq/";
   baseurlcomm = "/edelmw-comm/comm/";
   baseurlcontent = "/edelmw-content/content/";
+  baseurlreport = "/app-report/equity/";
   baseurllogin = "/edelmw-login/login/";
   baseurlmf = "/edelmw-mf/mf/";
+
   EquityContractURL = "/app/toccontracts/instruments.zip";
   MFContractURL = "/app/toccontracts/mfInstruments.zip";
 
@@ -16,6 +18,7 @@ class __Config {
     this.baseurllogin = configData.BasePathLogin;
     this.baseurlmf = configData.BasePathMf;
     this.baseurlcontent = configData.BasePathContent;
+    this.baseurlreport = configData.BasePathReport;
   }
 
   ChartURL = function (interval, exc, aType, symbol) {
@@ -320,6 +323,20 @@ class __Config {
   MarketDepthURL = function (symbol) {
     return this.baseurlcontent + "quote/scrip/" + symbol;
   };
+
+  //TRANSACTION HISTORY
+  TransactionHistoryURL = function (accountCode, fromDate, toDate) {
+    return (
+      this.baseurlreport +
+      "pnl/transaction" +
+      "?accountId=" +
+      accountCode +
+      "&fromDate=" +
+      fromDate +
+      "&toDate=" +
+      toDate
+    );
+  };
 }
 
 module.exports = __Config;

package/src/http.js

@@ -43,7 +43,6 @@ class __Http {
         res.on("end", () => {
           try {
             body = JSON.parse(Buffer.concat(body).toString());
-
             if (res.headers.appidkey) {
               this.__constants.AppIdKey = res.headers.appidkey;
             }

package/src/iniparser.js

@@ -6,6 +6,7 @@ BasePathEq = "";
 BasePathComm = "";
 BasePathMf = "";
 BasePathContent = "";
+BasePathReport = "";
 ApiIdKey = "";
 LogLevel = "";
 hostName = "";
@@ -19,6 +20,7 @@ const ConfigParser = function () {
   BasePathComm = config.GLOBAL.BasePathComm;
   BasePathMf = config.GLOBAL.BasePathMf;
   BasePathContent = config.GLOBAL.BasePathContent;
+  BasePathReport = config.GLOBAL.BasePathReport;
   ApiIdKey = config.GLOBAL.ApiIdKey;
   LogLevel = config.GLOBAL.LogLevel;
   hostName = config.STREAM.hostName;
@@ -39,4 +41,5 @@ module.exports = {
   port,
   formFactor,
   BasePathContent,
+  BasePathReport,
 };

package/src/report.js

@@ -0,0 +1,49 @@
+const log4js = require("./logger.js");
+const {
+    validateTransactionHistory,
+} = require("../validations/reportValidator");
+const segmentType = require("../enums/segmentType.js");
+
+class Report {
+    constructor(http, config, constants) {
+      this.__http = http;
+      this.__config = config;
+      this.__constants = constants;
+    }
+
+   /**
+   *
+   * @param {string} symbol
+   * @returns
+   */
+  getTransactionHistoryAPI = async (segment, fromDate, toDate) => {
+    try {
+
+      /**
+       * Validate Transaction History params
+       */
+      const validateResponse = validateTransactionHistory(
+        segment,
+        fromDate,
+        toDate,
+      );
+      if (validateResponse.error) {
+        log4js.debug(
+          "Transaction History validation error - " + validateResponse.error.details
+        );
+        return Promise.reject(validateResponse.error.details);
+      }
+
+      const url = (segment == segmentType.EQUITY) 
+      ? this.__config.TransactionHistoryURL(this.__constants.eqAccId, fromDate, toDate) 
+      : this.__config.TransactionHistoryURL(this.__constants.coAccId, fromDate, toDate);
+      log4js.debug("Transaction History URL -" + url);
+      const response = await this.__http.GetMethod(url, false);
+      return response;
+    } catch (error) {
+      log4js.debug("Transaction History error - " + error);
+      return Promise.reject(error);
+    }
+  };
+}
+module.exports = Report;

package/test/unitTests/charts/customPeriodChartTest.test.js

@@ -0,0 +1,213 @@
+const assert = require("chai").assert;
+var { APIConnect } = require("../../../src/apiConnect");
+var testConfig = require("../config");
+
+const credentials = testConfig.equity;
+
+edelconnectObj = async() => {
+    const edelObj = new APIConnect(
+      credentials.apiKey,
+      credentials.password,
+      credentials.reqId,
+      credentials.downloadContract
+    );
+    const res = await edelObj.Init();
+    return edelObj;
+  }
+
+/**
+ * Command to run Test Cases "npm run testCustomPeriodChart"
+ */
+
+describe("CustomPeriod chartTest", async function () {
+
+    describe("testCustomPeriodIfExchangeTypeIsNull", async function () {
+        let result;
+        before(async () => {
+            const edelObj = await edelconnectObj();
+
+            try {
+                result = await edelObj.getCustomPeriodChart(
+                    "EQUITY", //assetType
+                    "11423_NSE", //symbol
+                    null, //exchangeType
+                    "2023-10-06", //fromDate
+                    "2023-11-06", //toDate
+                    false //includeContinuousFuture
+                );
+            } catch(error) {
+                result = error;
+            }
+        });
+
+        it('"exc" must be one of [NSE, BSE, NFO, CDS, MCX, NCDEX, INDEX]', async function () {
+            assert.equal(
+              result[0].message,
+              '"exc" must be one of [NSE, BSE, NFO, CDS, MCX, NCDEX, INDEX]'
+            );
+        });
+
+        it('"exc" must be a string', async function () {
+            assert.equal(result[1].message, '"exc" must be a string');
+        });
+    });
+
+    describe("testCustomPeriodIfAssetTypeIsNull", async function () {
+        let result;
+        before(async () => {
+            const edelObj = await edelconnectObj();
+
+            try {
+                result = await edelObj.getCustomPeriodChart(
+                    null, //assetType
+                    "11423_NSE", //symbol
+                    "NSE", //exchangeType
+                    "2023-10-06", //fromDate
+                    "2023-11-06", //toDate
+                    false //includeContinuousFuture
+                );
+            } catch(error) {
+                result = error;
+            }
+        });
+
+        it('"assetType" must be one of [FUTSTK, FUTIDX, FUTCUR, FUTCOM, OPTIDX, OPTSTK, OPTCUR, OPTFUT, EQUITY, INDEX]', async function () {
+            assert.equal(
+              result[0].message,
+              '"aType" must be one of [FUTSTK, FUTIDX, FUTCUR, FUTCOM, OPTIDX, OPTSTK, OPTCUR, OPTFUT, EQUITY, INDEX]'
+            );
+        });
+      
+        it('"assetType" must be a string', async function () {
+            assert.equal(result[1].message, '"aType" must be a string');
+        });
+    });
+
+    describe("testCustomPeriodIfFromDateIsNull", async function () {
+        let result;
+        before(async () => {
+          const edelObj = await edelconnectObj();
+          try {
+            result = await edelObj.getEODChart(
+              "EQUITY", //assetType
+              "11423_NSE", //symbol
+              "NSE", //exchangeType
+              null, //fromDate
+              "2023-11-06", //toDate
+              false //includeContinuousFuture
+            );
+          } catch (error) {
+            result = error;
+          }
+        });
+    
+        it("testCustomPeriodIfFromDateIsNull", async function () {
+          assert.equal(
+            result[0].message,
+            '"From date" should not be null'
+          );
+        });
+    
+        it('"From date" must be a string', async function () {
+          assert.equal(result[1].message, '"From date" must be a string');
+        });
+    });
+
+    describe("testCustomPeriodIfToDateIsNull", async function () {
+        let result;
+        before(async () => {
+          const edelObj = await edelconnectObj();
+          try {
+            result = await edelObj.getEODChart(
+              "EQUITY", //assetType
+              "11423_NSE", //symbol
+              "NSE", //exchangeType
+              "2023-11-06", //fromDate
+              null, //toDate
+              false //includeContinuousFuture
+            );
+          } catch (error) {
+            result = error;
+          }
+        });
+    
+        it("testCustomPeriodIfToDateIsNull", async function () {
+          assert.equal(
+            result[0].message,
+            '"To date" should not be null'
+          );
+        });
+    
+        it('"To date" must be a string', async function () {
+          assert.equal(result[1].message, '"To date" must be a string');
+        });
+    });
+
+    describe("testCustomPeriodIfSymbolIsNull", async function () {
+        let result;
+        before(async () => {
+          const edelObj = await edelconnectObj();
+          try {
+            result = await edelObj.getEODChart(
+              "EQUITY", //assetType
+              null, //symbol
+              "NSE", //exchangeType
+              "2023-10-06", //fromDate
+              "2023-11-06", //toDate
+              false //includeContinuousFuture
+            );
+          } catch (error) {
+            result = error;
+          }
+        });
+    
+        it('"symbol" must be a string', async function () {
+          assert.equal(result[0].message, '"symbol" must be a string');
+        });
+    });
+
+    describe("IfallInputParamsHaveCorrectParams", async function () {
+        try {
+          const requestBodyObj = {
+            assetType: "EQUITY",
+            symbol: "11423_NSE",
+            exchangeType: "NSE",
+            fromDate:"2023-10-06", //fromDate
+            toDate:"2023-11-06", //toDate
+            includeContinuousFuture: false,
+          };
+          let response = {};
+    
+          before(async () => {
+            const edelObj = await edelconnectObj();
+            try {
+              const result = await edelObj.getEODChart(
+                requestBodyObj.assetType,
+                requestBodyObj.symbol,
+                requestBodyObj.exchangeType,
+                requestBodyObj.fromDate,
+                requestBodyObj.toDate,
+                requestBodyObj.includeContinuousFuture
+              );
+              response = result;
+            } catch (error) {
+              console.log("error is ", error);
+            }
+          });
+    
+          it("Response is not empty", async function () {
+            assert.isNotEmpty(response);
+          });
+    
+          it("Response have msgID", async function () {
+            assert.isNotEmpty(response.msgID);
+          });
+    
+          it("Response have srvTm", async function () {
+            assert.isNotNull(response.srvTm);
+          });
+        } catch (error) {
+          console.log("error is ", error);
+        }
+    });
+});

package/validations/apiConnectValidator.js

@@ -30,11 +30,20 @@ validatePlaceTrade = (object, prds) => {
     ordTyp: Joi.string()
       .valid(...orderTypeArray)
       .required(),
-    qty: Joi.number().required(),
+    qty: Joi.number()
+    .positive()
+    .required(),
     sym: Joi.string().required(),
-    lmPrc: Joi.string().required(),
-    dscQty: Joi.string(),
-    trgPrc: Joi.string(),
+    lmPrc: Joi.string()
+    .pattern(new RegExp("^\\d+(\\.\\d+)?"))
+    .required()
+    .error(new Error('Parameter Limit Price cannot be Negative or non-numeric')),
+    dscQty: Joi.string()
+    .pattern(new RegExp("^\\d+(\\.\\d+)?"))
+    .error(new Error('Parameter Disclosed Quantity cannot be Negative or non-numeric')),
+    trgPrc: Joi.string()
+    .pattern(new RegExp("^\\d+(\\.\\d+)?"))
+    .error(new Error('Parameter Trigger price cannot be Negative or non-numeric')),
     prdCode: Joi.string()
       // .valid(...prdName)
       .required(),
@@ -63,18 +72,29 @@ validateModifyTrade = (object, prds) => {
     ordTyp: Joi.string()
       .valid(...orderTypeArray)
       .required(),
-    qty: Joi.number().required(),
+    qty: Joi.number()
+    .positive()
+    .required(),
     dscQty: Joi.string(),
     sym: Joi.string().required(),
-    lmPrc: Joi.number().required(),
-    trgPrc: Joi.string(),
+    lmPrc: Joi.number()
+    .min(0)
+    .required(),
+    trgPrc: Joi.string()
+    .pattern(new RegExp("^\\d+(\\.\\d+)?"))
+    .error(new Error('Parameter trigger price cannot be Negative or non-numeric')),
     prdCode: Joi.string()
       // .valid(...prdName)
       .required(),
     nstOID: Joi.string().required(),
-    curQty: Joi.string().required(),
+    curQty: Joi.string()
+    .pattern(new RegExp("^\\d+(\\.\\d+)?"))
+    .required()
+    .error(new Error('Parameter Current Quantity cannot be Negative or non-numeric')),
   }).options({ abortEarly: false });
 
+  const re = modifyTradeSchema.validate(object);
+  console.log(re);
   return modifyTradeSchema.validate(object);
 };
 
@@ -94,8 +114,13 @@ validateCancelPlaceTrade = (object, prds) => {
     prdCode: Joi.string()
       // .valid(...prdName)
       .required(),
+    curQty: Joi.string()
+    .pattern(new RegExp("^\\d+(\\.\\d+)?"))
+    .error(new Error('Parameter Current Quantity cannot be Negative or non-numeric'))
   }).options({ abortEarly: false });
 
+  const re = cancelPlaceTradeSchema.validate(object);
+  console.log(re);
   return cancelPlaceTradeSchema.validate(object);
 };
 
@@ -104,6 +129,7 @@ validateCancelPlaceTradeV1 = (object, prds) => {
   // if (prds.exc.includes(object.exc)) {
   //   prdName = prds.prd[object.exc];
   // }
+
   const cancelPlaceTradeSchema = Joi.object({
     nstOID: Joi.string().required(),
     exc: Joi.string()
@@ -115,8 +141,12 @@ validateCancelPlaceTradeV1 = (object, prds) => {
     prdCode: Joi.string()
       // .valid(...prdName)
       .required(),
-    curQty: Joi.string().required(),
-    flQty: Joi.string().required(),
+    curQty: Joi.string().required()
+    .pattern(new RegExp("^\\d+(\\.\\d+)?"))
+    .error(new Error('Parameter Current Quantity cannot be Negative or non-numeric')),
+    flQty: Joi.string().required()
+    .pattern(new RegExp("^\\d+(\\.\\d+)?"))
+    .error(new Error('Parameter Fill Quantity cannot be Negative or non-numeric')),
     trdSym: Joi.string().required(),
     action: Joi.string()
       .valid(...actionTypeArray)
@@ -124,6 +154,8 @@ validateCancelPlaceTradeV1 = (object, prds) => {
     sym: Joi.string().required(),
   }).options({ abortEarly: false });
 
+  const re = cancelPlaceTradeSchema.validate(object);
+  console.log(re);
   return cancelPlaceTradeSchema.validate(object);
 };
 
@@ -146,8 +178,12 @@ validatePlaceGtcGtdTrade = (object, prds) => {
     ordTyp: Joi.string()
       .valid(...orderTypeArray)
       .required(),
-    qty: Joi.number().required(),
-    lmPrc: Joi.number().required(),
+    qty: Joi.number()
+    .positive()
+    .required(),
+    lmPrc: Joi.number()
+    .min(0)
+    .required(),
     prdCode: Joi.string()
       // .valid(...prdName)
       .required(),
@@ -155,6 +191,8 @@ validatePlaceGtcGtdTrade = (object, prds) => {
     sym: Joi.string().required(),
   }).options({ abortEarly: false });
 
+  const re = PlaceGtcGtdTradeSchema.validate(object);
+  console.log(re);
   return PlaceGtcGtdTradeSchema.validate(object);
 };
 validatePlaceAMOTrade = (object, prds) => {
@@ -176,16 +214,24 @@ validatePlaceAMOTrade = (object, prds) => {
     ordTyp: Joi.string()
       .valid(...orderTypeArray)
       .required(),
-    qty: Joi.number().required(),
+    qty: Joi.number()
+    .positive()
+    .required(),
     dscQty: Joi.string(),
     sym: Joi.string().required(),
-    lmPrc: Joi.number().required(),
-    trgPrc: Joi.string(),
+    lmPrc: Joi.number()
+    .min(0)
+    .required(),
+    trgPrc: Joi.string()
+    .pattern(new RegExp("^\\d+(\\.\\d+)?"))
+    .error(new Error('Parameter trigger price cannot be Negative or non-numeric')),
     prdCode: Joi.string()
 //      .valid(...prdName)
       .required(),
   }).options({ abortEarly: false });
 
+  const re = placeAMOTradeSchema.validate(object);
+  console.log(re);
   return placeAMOTradeSchema.validate(object);
 };
 
@@ -208,18 +254,32 @@ validateModifyAMOTrade = (object, prds) => {
     ordTyp: Joi.string()
       .valid(...orderTypeArray)
       .required(),
-    qty: Joi.number().required(),
-    dscQty: Joi.string(),
-    lmPrc: Joi.number().required(),
-    trgPrc: Joi.string(),
+    qty: Joi.number()
+    .positive()
+    .required(),
+    dscQty: Joi.string()
+    .pattern(new RegExp("^\\d+(\\.\\d+)?"))
+    .error(new Error('Parameter Disclosed Quantity cannot be Negative or non-numeric')),
+    lmPrc: Joi.number()
+    .pattern(new RegExp("^\\d+(\\.\\d+)?"))
+    .required()
+    .error(new Error('Parameter limit price cannot be Negative or non-numeric')),
+    trgPrc: Joi.string()
+    .pattern(new RegExp("^\\d+(\\.\\d+)?"))
+    .error(new Error('Parameter trigger price cannot be Negative or non-numeric')),
     prdCode: Joi.string()
 //      .valid(...prdName)
       .required(),
     nstOID: Joi.string().required(),
     sym: Joi.string().required(),
-    curQty: Joi.string().required(),
+    curQty: Joi.string()
+    .pattern(new RegExp("^\\d+(\\.\\d+)?"))
+    .required()
+    .error(new Error('Parameter Current Quantity cannot be Negative or non-numeric')),
   }).options({ abortEarly: false });
 
+  const re = modifyAMOTradeSchema.validate(object);
+  console.log(re);
   return modifyAMOTradeSchema.validate(object);
 };
 
@@ -239,8 +299,13 @@ validateCancelAMOTrade = (object, prds) => {
     prdCode: Joi.string()
 //      .valid(...prdName)
       .required(),
+    curQty: Joi.string()
+      .pattern(new RegExp("^\\d+(\\.\\d+)?"))
+      .error(new Error('Parameter Current Quantity cannot be Negative or non-numeric')),
   }).options({ abortEarly: false });
 
+  const re = cancelAMOTradeSchema.validate(object);
+  console.log(re);
   return cancelAMOTradeSchema.validate(object);
 };
 
@@ -269,6 +334,8 @@ validateCancelAMOTradeV1 = (object, prds) => {
      sym: Joi.string().required(),
    }).options({ abortEarly: false });
  
+   const re = cancelAMOTradeSchema.validate(object);
+   console.log(re);
    return cancelAMOTradeSchema.validate(object);
  };
 
@@ -280,7 +347,10 @@ validateConvertPositionCOMM = (object, prds) => {
   const ConvertPositionCOMMSchema = Joi.object({
     sym: Joi.string().required(),
     cnvTyp: Joi.string().valid("D", "C").required(),
-    qty: Joi.string().required(),
+    qty: Joi.string()
+    .pattern(new RegExp("^\\d+(\\.\\d+)?"))
+    .required()
+    .error(new Error('Parameter Quantity cannot be Negative or non-numeric')),
     action: Joi.string().valid("B", "S").required(),
     prdCode: Joi.string()
 //      .valid(...prdName)
@@ -295,6 +365,8 @@ validateConvertPositionCOMM = (object, prds) => {
     trdSym: Joi.string().required(),
   }).options({ abortEarly: false });
 
+  const re = ConvertPositionCOMMSchema.validate(object);
+  console.log(re);
   return ConvertPositionCOMMSchema.validate(object);
 };
 
@@ -321,7 +393,9 @@ validatePlaceMF = (object) => {
     isin: Joi.string().required(),
     txnTyp: Joi.string().required(),
     clientCode: Joi.string().required(),
-    qty: Joi.number().required(),
+    qty: Joi.number()
+    .positive()
+    .required(),
     amt: Joi.number().positive().required(),
     reInvFlg: Joi.string().required(),
     folioNo: Joi.any().when("txnTyp", {
@@ -349,7 +423,9 @@ validateModifyMF = (object) => {
     isin: Joi.string().required(),
     txnTyp: Joi.string().required(),
     clientCode: Joi.string().required(),
-    qty: Joi.number().required(),
+    qty: Joi.number()
+    .positive()
+    .required(),
     amt: Joi.number().positive().required(),
     reInvFlg: Joi.string().required(),
     folioNo: Joi.any().when("txnTyp", {
@@ -408,16 +484,33 @@ validatePlaceBracketTrade = (object, prds) => {
       .required(),
     sym: Joi.string().required(),
     trnsTyp: Joi.string().required(),
-    qty: Joi.number().required(),
+    qty: Joi.number()
+    .positive()
+    .required(),
     dur: Joi.string().required(),
-    dsQty: Joi.string().required(),
-    prc: Joi.number().required(),
-    slVal: Joi.string().required(),
-    trlSl: Joi.string(),
-    trlSlVal: Joi.string(),
-    sqOffVal: Joi.string().required(),
+    dsQty: Joi.string()
+    .pattern(new RegExp("^\\d+(\\.\\d+)?"))
+    .required()
+    .error(new Error('Parameter Disclosed Quantity cannot be Negative or non-numeric')),
+    prc: Joi.number()
+    .min(0)
+    .required(),
+    slVal: Joi.string()
+    .pattern(new RegExp("^\\d+(\\.\\d+)?"))
+    .required()
+    .error(new Error('Parameter Stop Loss cannot be Negative or non-numeric')),
+    trlSl: Joi.string().valid("Y", "N").required(),
+    trlSlVal: Joi.string()
+    .pattern(new RegExp("^\\d+(\\.\\d+)?"))
+    .error(new Error('Parameter Trailing stop loss value cannot be Negative or non-numeric')),
+    sqOffVal: Joi.string()
+    .pattern(new RegExp("^\\d+(\\.\\d+)?"))
+    .required()
+    .error(new Error('Parameter Square off cannot be Negative or non-numeric')),
   }).options({ abortEarly: false });
 
+  const re = PlaceBracketTradeSchema.validate(object);
+  console.log(re);
   return PlaceBracketTradeSchema.validate(object);
 };
 
@@ -483,15 +576,26 @@ validatePlaceBasketTrade = (orderList, prds) => {
         dur: Joi.string()
           .valid(...validityArray)
           .required(),
-        price: Joi.string().required(),
+        price: Joi.string()
+        .pattern(new RegExp("^\\d+(\\.\\d+)?"))
+        .required()
+        .error(new Error('Parameter Price cannot be Negative or non-numeric')),
         trgPrc: Joi.string().required(),
-        qty: Joi.number().required(),
-        dscQty: Joi.string().required(),
+        qty: Joi.number()
+        .positive()
+        .required(),
+        dscQty: Joi.string()
+        .pattern(new RegExp("^\\d+(\\.\\d+)?"))
+        .required()
+        .error(new Error('Parameter Disclosed Quantity cannot be Negative or non-numeric')),
         GTDDate: Joi.string().required(),
         rmk: Joi.string().allow("").required(),
         sym: Joi.string().required(),
       })
       .options({ abortEarly: false });
+
+      const re = orderListSchema.validate(item);
+      console.log(re);
     return orderListSchema.validate(item);
   });
 };
@@ -517,11 +621,23 @@ validatePositionSquareOff = (orderList, prds) => {
         ordTyp: Joi.string()
           .valid(...orderTypeArray)
           .required(),
-        qty: Joi.string().required(),
-        dscQty: Joi.string().required(),
+        qty: Joi.string()
+        .pattern(new RegExp("^\\d+(\\.\\d+)?"))
+        .required()
+        .error(new Error('Parameter Quantity cannot be Negative or non-numeric')),
+        dscQty: Joi.string()
+        .pattern(new RegExp("^\\d+(\\.\\d+)?"))
+        .required()
+        .error(new Error('Parameter Disclosed Quantity cannot be Negative or non-numeric')),
         sym: Joi.string().required(),
-        trgPrc: Joi.string().required(),
-        price: Joi.string().required(),
+        trgPrc: Joi.string()
+        .pattern(new RegExp("^\\d+(\\.\\d+)?"))
+        .required()
+        .error(new Error('Parameter Trigger price cannot be Negative or non-numeric')),
+        price: Joi.string()
+        .pattern(new RegExp("^\\d+(\\.\\d+)?"))
+        .required()
+        .error(new Error('Parameter Price cannot be Negative or non-numeric')),
         prdCode: Joi.string()
     //      .valid(...prdName)
           .required(),
@@ -529,6 +645,9 @@ validatePositionSquareOff = (orderList, prds) => {
         GTDDate: Joi.string().required(),
       })
       .options({ abortEarly: false });
+
+      const re = orderListSchema.validate(item);
+      console.log(re);
     return orderListSchema.validate(item);
   });
 };

package/validations/chartValidator.js

@@ -79,7 +79,47 @@ validateChartEOD = (interval, aType, symbol, exc, tillDate, conti) => {
   return chartSchema.validate(paramsObject);
 };
 
+/**
+ * Validate Chart CustomPeriod input params
+ */
+validateChartCustomPeriod = (interval, aType, symbol, exc, fromDate, toDate, conti) => {
+  const paramsObject = {
+    interval: interval,
+    aType: aType,
+    symbol: symbol,
+    exc: exc,
+    fromDate: fromDate,
+    toDate: toDate,
+    conti: conti,
+  };
+
+  const chartSchema = Joi.object({
+    interval: Joi.string()
+      .valid(...eodIntervalTypeArray)
+      .required(),
+    aType: Joi.string()
+      .valid(...assetTypeArray)
+      .required(),
+    symbol: Joi.string().required(),
+    exc: Joi.string()
+      .valid(...chartExchangeTypeArray)
+      .required(),
+    fromDate: Joi.alternatives().try(
+      JoiDate.date().format("YYYY-MM-DD").utc(),
+      Joi.string().required()
+    ),
+    toDate: Joi.alternatives().try(
+      JoiDate.date().format("YYYY-MM-DD").utc(),
+      Joi.string().required()
+    ),
+    conti: Joi.boolean().strict(),
+  }).options({ abortEarly: false });
+
+  return chartSchema.validate(paramsObject);
+};
+
 module.exports = {
   validateChartIntraday,
   validateChartEOD,
+  validateChartCustomPeriod,
 };

package/validations/reportValidator.js

@@ -0,0 +1,35 @@
+const Joi = require("Joi");
+
+const enumSegmentType = require("../enums/segmentType");
+const JoiDate = require("Joi").extend(require("@joi/date"));
+const segmentTypeArray = Object.values(enumSegmentType);
+
+/**
+ * Validate Transaction History input params
+ */
+validateTransactionHistory = (segment,fromDate,toDate) => {
+  const paramsObject = {
+    segment,
+    fromDate,
+    toDate
+  };
+  const transactionHistoryParamsSchema = Joi.object({
+    segment: Joi.string()
+      .valid(...segmentTypeArray)
+      .required(),
+    fromDate: Joi.alternatives().try(
+        JoiDate.date().format("YYYY-MM-DD").utc(),
+        Joi.string().required()
+      ),
+    toDate: Joi.alternatives().try(
+        JoiDate.date().format("YYYY-MM-DD").utc(),
+        Joi.string().required()
+      ),
+  }).options({ abortEarly: false });
+
+  return transactionHistoryParamsSchema.validate(paramsObject);
+};
+
+module.exports = {
+    validateTransactionHistory
+};