@refinitiv-ui/efx-grid 0.0.0-dev.12023565035.1

package/lib/tr-grid-util/es6/formula/TSISubscription.js

@@ -0,0 +1,1015 @@
+import {Ext} from "../Ext.js";
+import {Util} from "../Util.js";
+import {EventDispatcher} from "../EventDispatcher.js";
+import {RequestQueue} from "../RequestQueue.js";
+
+/** @constructor
+* @extends {EventDispatcher}
+*/
+let TSISubscription = function() {
+	this._refreshData = this._refreshData.bind(this);
+
+	// Old TSI service
+	this._onTSIUpdate = this._onTSIUpdate.bind(this);
+	this._requestTimeSeriesData = this._requestTimeSeriesData.bind(this);
+
+	// New metadata service
+	this._manageMetadataQ = this._manageMetadataQ.bind(this);
+	this._extractMetadata = this._extractMetadata.bind(this);
+	this._onRequestMetadata = this._onRequestMetadata.bind(this);
+
+	// New TSI service
+	this._manageTSIDataQ = this._manageTSIDataQ.bind(this);
+	this._extractTSIData = this._extractTSIData.bind(this);
+	this._onRequestTSIData = this._onRequestTSIData.bind(this);
+
+	// Temporary Map
+	this._metadataMap = {};
+	this._metadataPendingMap = {};
+	this._tsiDataMap = {};
+	this._tsiDataPendingMap = {};
+
+	// Data Map
+	this._tsiPeriodMap = {};
+	this._tsiMetadata = {};
+
+	this._metadataQ = new RequestQueue(this._onRequestMetadata, 80, 10000); // 80 requests in 10 seconds
+	this._metadataQ.setConcurrentLimit(2); // To prevent blocking request due to long running request time.
+
+	this._tsiDataQ = new RequestQueue(this._onRequestTSIData, 80, 10000); // 80 requests in 10 seconds
+	this._tsiDataQ.setConcurrentLimit(4); // To prevent blocking request due to long running request time.
+
+	this._oldTsiDataQ = new RequestQueue(this._requestTimeSeriesData, 80, 10000); // 80 requests in 10 seconds
+	this._oldTsiDataQ.setConcurrentLimit(4); // To prevent blocking request due to long running request time.
+};
+Ext.inherits(TSISubscription, EventDispatcher);
+
+
+/** @type {Object.<string, boolean>}
+* @private
+* @const
+*/
+TSISubscription.INTERVAL_MAIN = {
+	"Daily": true,
+	"Weekly": true,
+	"Monthly": true,
+	"Quarterly": true,
+	"Yearly": true
+};
+/** @type {Object.<string, number>}
+* @private
+* @const
+*/
+TSISubscription.INTERVAL_INDEX = {
+	"Daily": 0,
+	"Weekly": 1,
+	"Monthly": 2,
+	"4Monthly": 2, // WORKAROUND: Due to metadata on RIC USCONC=ECI, Time Series data provides monthly interval
+	"Quarterly": 3,
+	"Yearly": 4
+};
+/** @type {Object.<string, number>}
+* @private
+* @const
+*/
+TSISubscription.INTERVAL_ENUM = {
+	"Daily": 4,
+	"Weekly": 5,
+	"Monthly": 6,
+	"4Monthly": 6, // WORKAROUND: Due to metadata on RIC USCONC=ECI, Time Series data provides monthly interval
+	"Quarterly": 7,
+	"Yearly": 8
+};
+/** @type {Object.<string, number>}
+* @private
+* @const
+*/
+TSISubscription.COLUMN_MASK_ENUM = {
+	"CLOSE": 1,
+	"OPEN": 2,
+	"HIGH": 4,
+	"LOW": 8,
+	"VOLUME": 16,
+	"COUNT": 32,
+	"VALUE": 1 // WORKAROUND: Service return VALUE data in the factlist CLOSE
+};
+/** @type {number}
+* @private
+* @const
+*/
+TSISubscription.MAX_CONCURRENT_OBJECT = 300;
+/** @type {string}
+* @const
+*/
+TSISubscription.PENDING_DATA = "_PENDING♪_";
+
+
+/** @type {!Object}
+* @private
+*/
+TSISubscription.prototype._tsiMetadata;
+/** @type {!Object}
+* @private
+*/
+TSISubscription.prototype._tsiPeriodMap;
+
+/** @type {!RequestQueue}
+* @private
+*/
+TSISubscription.prototype._metadataQ;
+/** @type {number}
+* @private
+*/
+TSISubscription.prototype._metadataTimer = 0;
+/** @type {!Object.<string, *>}
+* @private
+*/
+TSISubscription.prototype._metadataMap;
+/** @type {!Object.<string, *>}
+* @private
+*/
+TSISubscription.prototype._metadataPendingMap;
+
+/** @type {!RequestQueue}
+* @private
+*/
+TSISubscription.prototype._tsiDataQ;
+/** @type {number}
+* @private
+*/
+TSISubscription.prototype._tsiDataTimer = 0;
+/** @type {!Object.<string, *>}
+* @private
+*/
+TSISubscription.prototype._tsiDataMap;
+/** @type {!Object.<string, *>}
+* @private
+*/
+TSISubscription.prototype._tsiDataPendingMap;
+
+/** @type {!RequestQueue}
+* @private
+*/
+TSISubscription.prototype._oldTsiDataQ;
+
+/** @type {string}
+* @private
+*/
+TSISubscription.prototype._state = "stop";
+/** @type {string}
+* @private
+*/
+TSISubscription.prototype._tsiTaServiceUrl = "/Apps/TAService";
+/** @type {string}
+* @private
+*/
+TSISubscription.prototype._tsiSharedServiceUrl = "/Apps/shared-services/service/TsMultiRICTimeSeries/GetMultiRICTimeSeries";
+/** @type {number}
+* @private
+*/
+TSISubscription.prototype._intervalId = 0;
+/** @type {number}
+* @private
+*/
+TSISubscription.prototype._intervalTime = 3600000; // 1 Hour
+
+
+//#region public function of TSI service
+/** Set the interval time for retrieving data
+* @public
+* @param {number} time Millisecond
+*/
+TSISubscription.prototype.setIntervalTime = function(time) {
+	time = +time;
+	if(!time) { // NaN or 0
+		return;
+	}
+	this._intervalTime = time;
+	this._stop();
+	this._start();
+};
+/** Set the settings of TSI
+* @public
+* @param {string=} sharedServiceUrl Url of TSI shared-service
+* @param {string=} taServiceUrl Url of TSI TAservice
+*/
+TSISubscription.prototype.setTSISettings = function(sharedServiceUrl, taServiceUrl) {
+	if(sharedServiceUrl != null) {
+		this._tsiSharedServiceUrl = sharedServiceUrl;
+	}
+	if(taServiceUrl != null) {
+		this._tsiTaServiceUrl = taServiceUrl;
+	}
+};
+/** Subscribe symbol and field to the specified period. This method will start the interval for retrieving data automatically.
+* @public
+* @param {string} symbol RIC
+* @param {string} field TSI field name
+* @param {string} period Specified Date(YYYY-MM-DD) or period (NNNNNP where N is a digit between 0 and 9, and P can be: D for days, W for weeks, M for months, Q for quarters, Y for years)
+* @return {*} Return the value if there is existing. Return undefined when requesting the invalid field.
+*/
+TSISubscription.prototype.addSymbolAndFieldToPeriod = function (symbol, field, period) {
+	let periodRIC = this._getPeriodRICData(period, symbol);
+	if(periodRIC.dataCache[field] != null) { // Already have data
+		return periodRIC.dataCache[field];
+	}
+
+	let periodMap = this._getPeriodMap(period);
+	let isNewSymbol = periodMap.symbol[symbol] == null;
+	if(isNewSymbol) {
+		periodMap.symbol[symbol] = true;
+	}
+
+	let isNewField = periodMap.field[field] == null;
+	if(isNewField) {
+		periodMap.field[field] = true;
+	}
+
+	if(isNewSymbol || isNewField) { // Request if it is new symbol or new field
+		this._oldTsiDataQ.add({ period: period });
+	}
+
+	this._start(); // Start interval
+
+	/*
+	 *  1: No valid data from service
+	 *  2: Waiting required data
+	 */
+	return TSISubscription.PENDING_DATA;
+};
+//#endregion public function of TSI service
+
+
+//#region public function of event
+/** Add the function handler into the specific event. This method will start interval automatically.
+* @override
+* @param {string} type Event name
+* @param {Function} handler Event handler
+*/
+TSISubscription.prototype.addEventListener = function(type, handler) {
+	TSISubscription.base(this, "addEventListener", type, handler);
+	this._start();
+};
+/** Remove the function handler from the specific event. If there is not any event handlers, the service will stop automatically.
+* @override
+* @param {string} type Event name
+* @param {Function} handler Event handler
+*/
+TSISubscription.prototype.removeEventListener = function(type, handler) {
+	TSISubscription.base(this, "removeEventListener", type, handler);
+	if(!this.hasListener()) {
+		this.removeAllEventListeners();
+	}
+};
+/** Remove all function handlers of all events and stop the interval of retrieving data of service.
+* @override
+*/
+TSISubscription.prototype.removeAllEventListeners = function() {
+	TSISubscription.base(this, "removeAllEventListeners");
+	this._stop();
+	if(this._metadataTimer > 0) {
+		window.clearTimeout(this._metadataTimer);
+	}
+	this._metadataTimer = 0;
+	if(this._tsiDataTimer > 0) {
+		window.clearTimeout(this._tsiDataTimer);
+	}
+	this._tsiDataTimer = 0;
+
+	this._tsiPeriodMap = {};
+	this._metadataMap = {};
+	this._tsiDataMap = {};
+	this._metadataQ.reset();
+	this._tsiDataQ.reset();
+};
+//#endregion public function of event
+
+
+//#region private function of TSI service
+/** Start the interval of retrieving data
+* @private
+*/
+TSISubscription.prototype._start = function() {
+	if(this._state === "start") {
+		return;
+	}
+	this._intervalId = window.setInterval(this._refreshData, this._intervalTime);
+	this._state = "start";
+};
+/** Stop the interval of retrieving data
+* @private
+*/
+TSISubscription.prototype._stop = function() {
+	if(this._intervalId > 0) {
+		window.clearInterval(this._intervalId);
+	}
+
+	this._intervalId = 0;
+	this._state = "stop";
+};
+/** Refresh all the TSI data that had been subscribed to the service.
+* @private
+*/
+TSISubscription.prototype._refreshData = function() {
+	for(let period in this._tsiPeriodMap) {
+		// Request to old TSI service
+		this._oldTsiDataQ.add({ period: period }); // If it has error code, it will fallback to new service automatically.
+	}
+};
+/** Get object that related to period. It has symbol and field properties to store the requested field and RIC to old service (shared-service).
+* @private
+* @param {string} period Specified Date(YYYY-MM-DD) or period (NNNNNP where N is a digit between 0 and 9, and P can be: D for days, W for weeks, M for months, Q for quarters, Y for years)
+* @return {Object} Object that related to period
+*/
+TSISubscription.prototype._getPeriodMap = function(period) {
+	if(!this._tsiPeriodMap[period]) {
+		this._tsiPeriodMap[period] = {
+			symbol: {}, // These 2 properties is used for requesting the old service (shared-service)
+			field: {}
+		};
+	}
+	return this._tsiPeriodMap[period];
+};
+/** Get data object that related to period and RIC. It has view property to store the requested view and dataCache property to store data.
+* @private
+* @param {string} period Specified Date(YYYY-MM-DD) or period (NNNNNP where N is a digit between 0 and 9, and P can be: D for days, W for weeks, M for months, Q for quarters, Y for years)
+* @param {string} symbol RIC
+* @return {Object} Object that related to period and RIC
+*/
+TSISubscription.prototype._getPeriodRICData = function(period, symbol) {
+	let tsiPeriodMap = this._getPeriodMap(period);
+	if(!tsiPeriodMap[symbol]) {
+		tsiPeriodMap[symbol] = {
+			view: {}, // This property will used for new TSI service
+			dataCache: {}
+		};
+	}
+
+	return tsiPeriodMap[symbol];
+};
+//#endregion private function of TSI service
+
+
+//#region private function of calling TS metadata service
+/** Check symbol has its metadata or not
+* @private
+* @param {string} symbol RIC
+* @return {boolean}
+*/
+TSISubscription.prototype._hasMetadata = function(symbol) {
+	return !symbol || (typeof this._tsiMetadata[symbol] === "object");
+};
+/** Method for requesting the metadata of symbol. Prevent requesting with duplicated RIC.
+* @private
+* @param {string} symbol RIC
+*/
+TSISubscription.prototype._requestMetadata = function(symbol) {
+	if(this._metadataPendingMap[symbol] || this._hasMetadata(symbol) || this._metadataMap[symbol]) { // Has metadata || pending request
+		return;
+	}
+
+	this._metadataMap[symbol] = true;
+	if(this._metadataTimer <= 0) {
+		this._metadataTimer = window.setTimeout(this._manageMetadataQ, 200);
+	}
+};
+/** Manage the request queue of TSI metadata. Split 300 RICs per request.
+* @private
+*/
+TSISubscription.prototype._manageMetadataQ = function() {
+	this._metadataTimer = 0; // Reset
+
+	let symbolMap = this._metadataMap;
+	this._metadataMap = {};
+
+	let symbols = [];
+	for(let key in symbolMap) {
+		if(this._metadataPendingMap[key]) {
+			continue;
+		}
+		symbols.push(key);
+		this._metadataPendingMap[key] = true;
+
+		if(symbols.length >= TSISubscription.MAX_CONCURRENT_OBJECT) {
+			this._metadataQ.add({ rics: symbols }); // Add full capcity to queue
+			symbols = [];
+		}
+	}
+	if(symbols.length > 0) {
+		this._metadataQ.add({ rics: symbols }); // Add remaining to queue
+	}
+};
+/** Publish TSI metadata request to server.
+* @private
+* @param {Object} obj Specified RICs
+* @param {Array.<Object>} q All RICs that are waiting in a queue
+* @return {Promise}
+*/
+TSISubscription.prototype._onRequestMetadata = function(obj, q) {
+	let reqRics = obj.rics;
+	let len = reqRics.length;
+	if(len <= 0) {
+		return Promise.resolve("");
+	}
+
+	// Merge request
+	let qi = q.length;
+	let remaining = TSISubscription.MAX_CONCURRENT_OBJECT - len;
+	while(remaining > 0  && --qi >= 0) {
+		let qObj = q[qi];
+		reqRics = reqRics.concat( qObj.rics.splice(0, remaining) );
+
+		len = reqRics.length; // Update length
+		remaining = TSISubscription.MAX_CONCURRENT_OBJECT - len;
+		if(qObj.rics.length === 0) { // No data anymore
+			q.pop();
+		}
+	}
+
+	let payload = { "rics": reqRics };
+	let pendingMap = this._metadataPendingMap;
+	return Util.post(this._tsiTaServiceUrl + "/GetMetadata", payload)
+		.then(this._extractMetadata)
+		.catch(function(err) {
+			for(let i = len; --i >= 0;) {
+				delete pendingMap[reqRics[i]]; // Remove key from pending list due to error
+			}
+		});
+};
+/** Extract the metadata response from service. This will trig to call service for getting data automatically.
+* @private
+* @param {Object} serviceResponse
+*/
+TSISubscription.prototype._extractMetadata = function(serviceResponse) {
+	let instruments = serviceResponse["instruments"];
+	if(instruments) { // Successful request
+		let aryLen = Object.keys(/** @type {!Object} */(TSISubscription.INTERVAL_INDEX)).length;
+		let ary = new Array(aryLen); // Reused array
+		for(let i = instruments.length; --i >= 0;) {
+			let instrument = instruments[i];
+
+			let data = null;
+			let viewList = instrument["viewList"] || [];
+			for(let j = viewList.length; --j >= 0;) {
+				let view = viewList[j];
+				let intervals = view["intervals"];
+				let k, interval, len;
+				for(k = 0, len = intervals.length; k < len; k++) {
+					interval = intervals[k];
+					let idx = TSISubscription.INTERVAL_INDEX[ interval["name"] ];
+					if(idx != null) {
+						if(ary[idx] == null || TSISubscription.INTERVAL_MAIN[ interval["name"] ]) { // Main interval has more priority than other interval in same category
+							ary[idx] = interval;
+						}
+					}
+				}
+
+				let viewData = null;
+				let columns;
+				for(k = 0; k < aryLen; k++) {
+					interval = ary[k];
+					ary[k] = null; // Clear array for reused
+					if(interval != null && viewData === null) {
+						columns = 0; // Reset
+
+						for(let l = interval["fields"].length; --l >= 0;) { // Column mask for view + interval
+							columns |= TSISubscription.COLUMN_MASK_ENUM[ interval["fields"][l] ]; // undefined will be same as 0
+						}
+
+						if(columns !== 0) { // Valid interval to retrieve data
+							viewData = {
+								interval: TSISubscription.INTERVAL_ENUM[ interval["name"] ],
+								columnMask: columns
+							};
+						}
+					}
+				}
+
+				if(viewData !== null) {
+					if(data === null) {
+						data = {};
+					}
+					data[view["name"]] = viewData;
+				}
+			}
+
+			this._tsiMetadata[instrument["ric"]] = data;
+			delete this._metadataPendingMap[instrument["ric"]]; // Remove RIC from pending list
+		}
+
+		// Trig to call service for getting data
+		if(this._tsiDataTimer <= 0) {
+			this._tsiDataTimer = window.setTimeout(this._manageTSIDataQ, 0);
+		}
+	}
+};
+//#endregion private function of calling TS metadata service
+
+
+//#region private function of calling new TS data service
+/** Get the string of key by symbol, view and period.
+* @private
+* @param {string} symbol RIC
+* @param {string} view TSI view name
+* @param {string} period Specified Date(YYYY-MM-DD) or period (NNNNNP where N is a digit between 0 and 9, and P can be: D for days, W for weeks, M for months, Q for quarters, Y for years)
+* @return {string} String of key
+*/
+TSISubscription.prototype._getKey = function(symbol, view, period) {
+	return symbol + "♫" + view + "♫" + period;
+};
+/** Build the request information for metadata
+* @private
+* @param {!Object} reqPayload Object that contains symbol, view and period
+* @param {!Object.<string, number>} dateMap Date calculation map. Reduce duplicated date to calculate.
+* @return {Object.<string, Array>}
+*/
+TSISubscription.prototype._buildRequestInfo = function(reqPayload, dateMap) {
+	let ric = reqPayload.ric;
+	let view = reqPayload.view;
+	let viewData = this._tsiMetadata[ric] && this._tsiMetadata[ric][view];
+	if(!viewData) {
+		return null;
+	}
+
+	let period = dateMap[reqPayload.period];
+	if(period == null) {
+		period = TSISubscription._dateCalculation(reqPayload.period).getTime();
+		dateMap[reqPayload.period] = period;
+	}
+
+	return {
+		"RequestInfos": [{
+			"__type": "TSRequest:http://www.thomsonreuters.com/ns/2012/01/01/webservices/TAService_1/",
+			"RIC": ric,
+			"Interval": viewData.interval,
+			"Field": view,
+			"ColumnMask": viewData.columnMask,
+			"DataPoints": "1",
+			"EndDate": "/Date(" + period + ")/"
+		}]
+	};
+};
+/** Method for requesting the data of symbol and view with specified period. Prevent requesting with duplicated symbol, view and period.
+* @private
+* @param {string} symbol RIC
+* @param {string} view TSI view name
+* @param {string} period Specified Date(YYYY-MM-DD) or period (NNNNNP where N is a digit between 0 and 9, and P can be: D for days, W for weeks, M for months, Q for quarters, Y for years)
+*/
+TSISubscription.prototype._requestTSIData = function(symbol, view, period) {
+	if(!symbol || !view || !period) {
+		return;
+	}
+
+	let key = this._getKey(symbol, view, period);
+	if(this._tsiDataPendingMap[key] || this._tsiDataMap[key]) { // Already in list
+		return;
+	}
+
+	this._tsiDataMap[key] = {
+		ric: symbol,
+		view: view,
+		period: period
+	};
+	if(this._tsiDataTimer <= 0) {
+		this._tsiDataTimer = window.setTimeout(this._manageTSIDataQ, 200);
+	}
+};
+/** Manage the request queue of TSI data. Split 300 objects per request. If the requested object dose not have metadata, it will request metadata first.
+* @private
+*/
+TSISubscription.prototype._manageTSIDataQ = function() {
+	this._tsiDataTimer = 0; // Reset
+
+	let listMap = this._tsiDataMap;
+	this._tsiDataMap = {};
+
+	let obj;
+	let listArr = [];
+	for(let key in listMap) {
+		obj = listMap[key];
+		if(this._hasMetadata(obj.ric)) {
+			if(this._tsiDataPendingMap[key]) {
+				continue;
+			}
+			listArr.push( obj );
+			this._tsiDataPendingMap[key] = true;
+		} else { // No metadata
+			this._requestMetadata(obj.ric);
+			this._tsiDataMap[key] = obj; // Add to pending list again
+			continue;
+		}
+
+		if(listArr.length >= TSISubscription.MAX_CONCURRENT_OBJECT) {
+			this._tsiDataQ.add({ list: listArr }); // Add full capcity to queue
+			listArr = [];
+		}
+	}
+	if(listArr.length > 0) {
+		this._tsiDataQ.add({ list: listArr }); // Add remaining to queue
+	}
+};
+/** Publish TSI data request to server.
+* @private
+* @param {Object} obj Specified list of objects
+* @param {Array.<Object>} q All list of objects that are waiting in a queue
+* @return {!Promise}
+*/
+TSISubscription.prototype._onRequestTSIData = function(obj, q) {
+	let reqPayloads = obj.list;
+	let len = reqPayloads.length;
+	if(len <= 0) {
+		return Promise.resolve("");
+	}
+
+	// Merge request
+	let qi = q.length;
+	let remaining = TSISubscription.MAX_CONCURRENT_OBJECT - len;
+	while(remaining > 0  && --qi >= 0) {
+		let qObj = q[qi];
+		reqPayloads = reqPayloads.concat( qObj.list.splice(0, remaining) );
+
+		len = reqPayloads.length; // Update length
+		remaining = TSISubscription.MAX_CONCURRENT_OBJECT - len;
+		if(qObj.list.length === 0) { // No data anymore
+			q.pop();
+		}
+	}
+
+	let dateMap = {};
+	let requestInfos = [];
+	let reqInfo;
+	for(let i = len; --i >= 0;) {
+		reqInfo = this._buildRequestInfo(reqPayloads[i], dateMap);
+		if(reqInfo) {
+			requestInfos.push( reqInfo ); // BEWARE: This is the reverse loop
+		} else {
+
+			/*
+			 * No metadata for request
+			 * Complete the request so that it will not stay indefinitely as "pending"
+			 * TRGRID-2335
+			 */
+			let key = this._getKey(reqPayloads[i].ric, reqPayloads[i].view, reqPayloads[i].period);
+			delete this._tsiDataPendingMap[key]; // Remove from pending map
+
+			let periodRIC = this._getPeriodRICData(reqPayloads[i].period, reqPayloads[i].ric);
+			let periodMap = this._getPeriodMap(reqPayloads[i].period);
+			let fields = periodMap.field;
+			let rowData = {};
+			for(let field in fields) {
+				if(!fields[field]) continue;
+				periodRIC.dataCache[field] = null;
+				rowData[reqPayloads[i].period + "♠" + field] = periodRIC.dataCache[field];
+			}
+			this._dispatch("dataChanged", { "ric": reqPayloads[i].ric, "values": rowData, "sender": this }); // Publish data
+			reqPayloads.splice(i, 1);
+		}
+	}
+
+	if(requestInfos.length === 0) {
+		return Promise.resolve("");
+	}
+
+	let self = this; // TODO: This is bad
+	let payload = { "messages": requestInfos.reverse() }; // Reverse array back for normal order
+	return Util.requestText(this._tsiTaServiceUrl + "/CalculateAllData", payload)
+		.then(function(serviceResponse) {
+			return {
+				payload: reqPayloads, // attached payload
+				response: serviceResponse
+			};
+		})
+		.then(this._extractTSIData)
+		.catch(function(err) { // TODO: This is bad
+			for(let i = len; --i >= 0;) { // eslint-disable-line
+				let key = self._getKey(reqPayloads[i].ric, reqPayloads[i].view, reqPayloads[i].period); // eslint-disable-line
+				delete self._tsiDataPendingMap[key]; // Remove from pending map
+			}
+		});
+};
+/** Extract the TSI data response from service. Cache the data and dispatch an event.
+* @private
+* @param {Object} res Object that contains response from service in response property and requested payload in payload property
+* @return {Object}
+*/
+TSISubscription.prototype._extractTSIData = function(res) {
+	let response = res.response.replace(/\[NaN(,NaN)*\]/g, "[]"); // Handler for return the invalid JSON syntax due to no data
+	let json;
+	try {
+		json = /** @type {Object} */(JSON.parse(response));
+	} catch(ex) {
+		console.log("Cannot parse TSI data: ", ex);
+		json = null;
+	}
+
+	if(json) {
+		let payload = res.payload;
+		let len = payload.length;
+		let periodRIC, dataCache, view, symbol, period, rowData, field, periodMap;
+		for(let i = 0; i < len; i++) {
+			view = payload[i].view;
+			symbol = payload[i].ric;
+			period = payload[i].period;
+
+			periodRIC = this._getPeriodRICData(period, symbol);
+			periodRIC.view[view] = true; // Mark as already requested
+			dataCache = periodRIC.dataCache;
+
+			let data = json[i]["Columns"] || [];
+			if(data.length === 0) {
+				continue;
+			}
+
+			rowData = {};
+			let val;
+			for(let j = 0, dataLen = data.length; j < dataLen; j++) {
+				val = data[j]["Values"][0];
+				if(val == null || val !== val) {
+					/*
+					 * undefined, null, NaN
+					 * Complete the request so that it will not stay indefinitely as "pending"
+					 * TRGRID-2335
+					*/
+					periodMap = this._getPeriodMap(period);
+					for(field in periodMap.field) {
+						if(!periodMap.field[field]) continue;
+						dataCache[field] = null;
+						rowData[period + "♠" + field] = dataCache[field];
+					}
+					continue;
+				}
+
+				switch(data[j]["Name"]) { // Cache the data in service
+				case "Date":
+					field = view + ".TIMESTAMP";
+					dataCache[field] = new Date(+val.substring(6, val.length - 2)).toJSON().substr(0, 19);
+					rowData[period + "♠" + field] = dataCache[field];
+					break;
+				case "Open":
+					field = view + ".OPEN";
+					dataCache[field] = val;
+					rowData[period + "♠" + field] = dataCache[field];
+					break;
+				case "High":
+					field = view + ".HIGH";
+					dataCache[field] = val;
+					rowData[period + "♠" + field] = dataCache[field];
+					break;
+				case "Low":
+					field = view + ".LOW";
+					dataCache[field] = val;
+					rowData[period + "♠" + field] = dataCache[field];
+					break;
+				case "Close":
+					field = view + ".CLOSE";
+					dataCache[field] = val;
+					rowData[period + "♠" + field] = dataCache[field];
+
+					field = view + ".VALUE";
+					dataCache[field] = val; // WORKAROUND: Service return VALUE in factlist CLOSE
+					rowData[period + "♠" + field] = dataCache[field];
+					break;
+				case "Volume":
+					field = view + ".VOLUME";
+					dataCache[field] = val;
+					rowData[period + "♠" + field] = dataCache[field];
+					break;
+				case "Count":
+					field = view + ".COUNT";
+					dataCache[field] = val;
+					rowData[period + "♠" + field] = dataCache[field];
+					break;
+				default:
+					field = (view + "." + data[j]["Name"]).toUpperCase();
+					dataCache[field] = val; // Rarely case: new fields
+					rowData[period + "♠" + field] = dataCache[field];
+				}
+			}
+
+			this._dispatch("dataChanged", { "ric": symbol, "values": rowData, "sender": this }); // Publish data
+			delete this._tsiDataPendingMap[ this._getKey(symbol, view, period) ]; // Remove from pending map
+		}
+	}
+
+	return json;
+};
+//#endregion private function of calling new TS data service
+
+
+//#region private function of calling old TS data service
+/** Publish the TSI request to the TSI server.
+* @private
+* @param {Object} obj Specified Date(YYYY-MM-DD) or period (NNNNNP where N is a digit between 0 and 9, and P can be: D for days, W for weeks, M for months, Q for quarters, Y for years)
+* @param {Array.<Object>} q All periods that are waiting in a queue
+* @return {Promise}
+*/
+TSISubscription.prototype._requestTimeSeriesData = function(obj, q) {
+	let period = obj.period;
+	for(let i = q.length; --i >= 0;) {
+		let qObj = q[i];
+		if(!qObj.rics && qObj.period === period) {
+			q.splice(i, 1); // Remove any duplicate period that is being queued
+		}
+	}
+
+	let periodMap = this._getPeriodMap(period);
+	let fields = Object.keys(periodMap.field);
+	let symbols = obj.rics ? obj.rics : Object.keys(periodMap.symbol);
+
+	if(fields.length === 0 || symbols.length === 0) {
+		return null;
+	}
+
+	let reqDate = TSISubscription._dateCalculation(period).toJSON();
+	if(reqDate === null) { // Invalid date/period parameter
+		return null;
+	} else {
+		reqDate = reqDate.slice(0, 10);
+	}
+
+	if(symbols.length > 300) { // TSI cannot handle more than 300 rics in a single request
+		obj.rics = symbols;
+		symbols = obj.rics.splice(0, 300); // Split the rics
+		q.unshift(obj); // Push the request back at the front of the queue
+	}
+
+	let payload = {
+		"rics": symbols.join(" "),
+		"factList": fields.join(","),
+		"date": reqDate
+	};
+
+	return Util.post(this._tsiSharedServiceUrl, payload)
+		.then(function(result) {
+			return {
+				"period": period, // Attach requested period
+				"reqDate": reqDate, // Attach requested date for comparison with the returned data
+				"result": result
+			};
+		})
+		.then(this._onTSIUpdate)
+		.catch(TSISubscription._emptyMethod); // Silent error handling
+};
+/** Function for processing the TSI response and publish the event to the listener.
+* @private
+* @param {Object} json JSON object of TSI response
+*/
+TSISubscription.prototype._onTSIUpdate = function(json) {
+	let period = json["period"];
+	let result = json["result"];
+	let periodMap = this._getPeriodMap(period);
+	let fields = periodMap["field"];
+
+	let header = result[0];
+	if(!header) {
+		throw("Invalid response from TSI service");
+	}
+
+	let ricIdx = -1;
+	let returnStatusIdx = -1;
+	// let timestampIdx = -1;
+	let fieldIdxMap = {};
+	for(let i = header.length; --i >= 0;) {
+		if(header[i] === "RIC") {
+			ricIdx = i;
+		} else if(header[i] === "ReturnStatus") {
+			returnStatusIdx = i;
+		} else if(header[i] === "TimeStamp") {
+			// timestampIdx = i;
+		} else if(fields[header[i]]) { // Requested fields
+			fieldIdxMap[header[i]] = i;
+		}
+	}
+	fields = Object.keys(fieldIdxMap); // Collect the fields of result
+
+	let rowLen = result.length;
+	let symbol, value, rowData, dataCache;
+	// let isCorrectDate;
+	for(i = 1; i < rowLen; i++) {
+		symbol = result[i][ricIdx];
+
+		if(result[i][returnStatusIdx] !== "0") { // Have an error in response, then fallback to new TS data service
+			// Request to new service
+			for(let k = fields.length; --k >= 0;) {
+				let view = fields[k].substring(0, fields[k].lastIndexOf("."));
+				if(!this._hasMetadata(symbol) || (this._tsiMetadata[symbol] && this._tsiMetadata[symbol][view])) { // No metadata || Ready to make a request
+					this._requestTSIData(symbol, view, period);
+				}
+			}
+			continue;
+		}
+
+		// isCorrectDate = (reqDate === result[i][timestampIdx]);
+		dataCache = this._getPeriodRICData(period, symbol).dataCache;
+		rowData = {};
+
+		for(let j = fields.length; --j >= 0;) {
+			// value = (isCorrectDate) ? (result[i][fieldIdxMap[fields[j]]] || null) : null; // If result is same as the requested timestamp then return the value. Otherwise return null.
+			value = result[i][fieldIdxMap[fields[j]]] || null; // If return empty string, it should be null
+			if(value !== null) {
+				value = +value; // Convert to number
+			}
+			dataCache[fields[j]] = value; // Cache the data in service
+			rowData[period + "♠" + fields[j]] = dataCache[fields[j]];
+		}
+
+		this._dispatch("dataChanged", { "ric": symbol, "values": rowData, "sender": this }); // Publish data
+	}
+};
+//#endregion private function of calling old TS data service
+
+
+//#region private function of date calculation
+/** Add/Subtract days to the given JS Date object.
+* @private
+* @param {!Date} date Javascript Date object
+* @param {number} day Day to add or subtract. Plus value is add operation. Minus value is subtract operation.
+* @return {!Date}
+*/
+TSISubscription._addDays = function(date, day) {
+	date.setDate(date.getDate() + day);
+
+	return date;
+};
+/** Add/Subtract months to the given JS Date object.
+* @private
+* @param {!Date} date Javascript Date object
+* @param {number} month Month to add or subtract. Plus value is add operation. Minus value is subtract operation.
+* @return {!Date}
+*/
+TSISubscription._addMonths = function(date, month) {
+	// Reference: http://stackoverflow.com/questions/7937233/how-do-i-calculate-the-date-in-javascript-three-months-prior-to-today
+	let expectedMonth = ((date.getMonth() + month) % 12 + 12) % 12;
+	date.setMonth(date.getMonth() + month);
+	if (date.getMonth() !== expectedMonth) { // If it has an error of native date subtraction
+		date.setDate(0); // Backward to the last day of previous month
+	}
+	return date;
+};
+/** Add/Subtract months to the given JS Date object.
+* @private
+* @param {!Date} date Javascript Date object
+* @param {number} num
+* @param {string=} dateUnit
+* @return {!Date}
+*/
+TSISubscription._addDate = function(date, num, dateUnit) {
+	if(dateUnit === "Y") {
+		return TSISubscription._addMonths(date, num * 12);
+	} else if(dateUnit === "Q") {
+		return TSISubscription._addMonths(date, num * 3);
+	} else if(dateUnit === "M") {
+		return TSISubscription._addMonths(date, num);
+	} else if(dateUnit === "W") {
+		return TSISubscription._addDays(date, num * 7);
+	}
+
+	return TSISubscription._addDays(date, num);
+};
+/** Calculate the given period or transform the given date to string of date
+* @private
+* @param {string} period Specified Date(YYYY-MM-DD) or period (NNNNNP where N is a digit between 0 and 9, and P can be: D for days, W for weeks, M for months, Q for quarters, Y for years)
+* @return {Date} Date object
+*/
+TSISubscription._dateCalculation = function(period) {
+	let goBackPeriods = period.match(/\d+(D|W|M|Q|Y)/g);
+	if(goBackPeriods) { // Relative date pattern
+		let now = new Date();
+		for(let i = goBackPeriods.length; --i >= 0;){
+			let p = goBackPeriods[i];
+			let dateUnit = p.substr(p.length - 1);
+			let num = -(p.substr(0, p.length - 1));
+			now = TSISubscription._addDate(now, num, dateUnit);
+		}
+		return now;
+	}
+
+	// Specified date
+	let temp = new Date(period);
+	if(temp.toJSON() === null) {
+		console.warn("Invalid period parameter: " + period);
+		return null;
+	}
+	let date = null;
+	if(period.match(/^\d{1,4}(-\d{2}(-\d{2})?)?$/)) { // If ISO format (YYYY-MM-DD)
+		date = temp;
+	} else { // If non ISO format
+		date = new Date(temp.getTime() - temp.getTimezoneOffset() * 60000); // Adjust timezone
+	}
+	return date; // Return the date in string format e.g. 2017-02-21
+};
+
+
+/** @private
+* @param {*} msg
+*/
+TSISubscription._log = function(msg) {
+	console.log("TSI: ", msg);
+};
+/** @private
+* @param {*} msg
+*/
+TSISubscription._emptyMethod = function(msg) {
+};
+
+export {TSISubscription};