@refinitiv-ui/efx-grid 6.0.0-next.0

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

@@ -0,0 +1,317 @@
+import {Ext} from "../Ext.js";
+import {Util} from "../Util.js";
+import {EventDispatcher} from "../EventDispatcher.js";
+
+/** @constructor
+* @extends {EventDispatcher}
+*/
+var ADCSubscription = function() {
+	this._adcFieldMap = {};
+	this._queue = {};
+	this._onADCUpdate = this._onADCUpdate.bind(this);
+	this._refreshData = this._refreshData.bind(this);
+	this._processQueue = this._processQueue.bind(this);
+};
+Ext.inherits(ADCSubscription, EventDispatcher);
+
+
+/** @type {Object}
+* @private
+*/
+ADCSubscription.prototype._adcFieldMap = null;
+/** @type {Object}
+* @private
+*/
+ADCSubscription.prototype._queue = null;
+/** @type {string}
+* @private
+*/
+ADCSubscription.prototype._state = "stop";
+/** @type {string}
+* @private
+*/
+ADCSubscription.prototype._userId = "GUEST";
+/** @type {string}
+* @private
+*/
+ADCSubscription.prototype._productId = "ANONYMOUS";
+/** @type {string}
+* @private
+*/
+ADCSubscription.prototype._adcUrl = "/datacloud/rest/select";
+/** @type {number|null}
+* @private
+*/
+ADCSubscription.prototype._intervalId = null;
+/** @type {number}
+* @private
+*/
+ADCSubscription.prototype._intervalTime = 3600000; // 1 Hour
+/** @type {number|null}
+* @private
+*/
+ADCSubscription.prototype._timerId = null;
+/** @type {string}
+* @private
+*/
+ADCSubscription.prototype._lang = "";
+/** @static
+* @constant {string}
+*/
+ADCSubscription.PENDING_DATA = "_PENDING♪_";
+
+
+//#region public function of ADC service
+/** Set the settings of ADC
+* @public
+* @param {string} userId UUID
+* @param {string} productId Application name
+* @param {string} url Url of ADC server
+* @param {string=} opt_lang Language of Eikon UI
+*/
+ADCSubscription.prototype.setDataCloudSettings = function (userId, productId, url, opt_lang) {
+	if(userId != null) {
+		this._userId = userId;
+	}
+	if(productId != null) {
+		this._productId = productId;
+	}
+	if(url != null) {
+		this._adcUrl = url;
+	}
+	if(opt_lang) {
+		this._lang = opt_lang;
+	}
+};
+/** Set the interval time for retrieving data
+* @public
+* @param {number} time Millisecond
+*/
+ADCSubscription.prototype.setIntervalTime = function(time) {
+	time = +time;
+	if(!time) { // NaN or 0
+		return;
+	}
+	this._intervalTime = time;
+	this._stop();
+	this._start();
+};
+/** Subscribe symbol to the spcified field. This method will start the interval for retrieving data automatically.
+* @public
+* @param {string} symbol RIC
+* @param {string} field ADC field name
+* @return {*} Return the value if there is existing. Return undefined when requesting the invalid field.
+*/
+ADCSubscription.prototype.addSymbolToField = function (symbol, field) {
+	if(field.indexOf("undefined") >= 0) { // Invalid field name
+		return;
+	}
+
+	var fieldMap = this._adcFieldMap[field];
+	if(!fieldMap) {
+		fieldMap = {};
+		this._adcFieldMap[field] = fieldMap;
+	}
+
+	var value = fieldMap[symbol];
+	if(value != null) {
+		return value; // eslint-disable-line
+	}
+
+	fieldMap[symbol] = ADCSubscription.PENDING_DATA; // First value to cache
+	this._addQueue(field);
+	return ADCSubscription.PENDING_DATA; // eslint-disable-line
+};
+//#endregion public function of ADC 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
+*/
+ADCSubscription.prototype.addEventListener = function(type, handler) {
+	ADCSubscription.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
+*/
+ADCSubscription.prototype.removeEventListener = function(type, handler) {
+	ADCSubscription.base(this, "removeEventListener", type, handler);
+	if(!this.hasListener()) {
+		this._stop();
+		this._adcFieldMap = {};
+		this._queue = {};
+	}
+};
+/** Remove all function handlers of all events and stop the interval of retrieving data of service.
+* @override
+*/
+ADCSubscription.prototype.removeAllEventListeners = function() {
+	ADCSubscription.base(this, "removeAllEventListeners");
+	this._stop();
+	this._adcFieldMap = {};
+	this._queue = {};
+};
+//#endregion public function of event
+
+
+//#region private function of ADC service
+/** Start the interval of retrieving data
+* @private
+*/
+ADCSubscription.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
+*/
+ADCSubscription.prototype._stop = function() {
+	if(this._timerId !== null) {
+		window.clearTimeout(this._timerId);
+	}
+	if(this._intervalId !== null) {
+		window.clearInterval(this._intervalId);
+	}
+	this._timerId = null;
+	this._intervalId = null;
+	this._state = "stop";
+};
+/** Refresh all the ADC data that had been subscribed to the service.
+* @private
+*/
+ADCSubscription.prototype._refreshData = function() {
+	this._addQueue(Object.keys(/** @type{!Object} */(this._adcFieldMap)));
+};
+/** Manage the queue to retrieve the ADC data. Prevent to call the same ADC field multiple time.
+* @private
+* @param {string|Array.<string>} fields
+*/
+ADCSubscription.prototype._addQueue = function(fields) {
+	if(this._timerId !== null) {
+		window.clearTimeout(this._timerId);
+	}
+
+	if(!Array.isArray(fields)) {
+		fields = [fields];
+	}
+	if(!this._queue) {
+		this._queue = {};
+	}
+	for(var i = fields.length; --i >= 0;) {
+		this._queue[fields[i]] = true;
+	}
+	this._timerId = window.setTimeout(this._processQueue, 0);
+};
+/** Process the data queue to retrieve ADC data.
+* @private
+*/
+ADCSubscription.prototype._processQueue = function() {
+	var fields = Object.keys(/** @type{!Object} */(this._queue));
+	for(var j = fields.length; --j >= 0;) {
+		this._requestDataCloud(fields[j]);
+	}
+	this._queue = {}; // Clear queue
+	this._timerId = null; // Clear timeout id
+};
+/** Publish the ADC request to the ADC server.
+* @private
+* @param {string} field ADC field name
+* @return {Promise}
+*/
+ADCSubscription.prototype._requestDataCloud = function(field) {
+	var RICs = Object.keys(this._adcFieldMap[field]);
+	var payload = "formula=" + field + "&identifiers=" + RICs;
+	if(this._productId) {
+		payload += '&productid=' + this._productId;
+	}
+	if(this._userId) {
+		payload += '&uuid=' + this._userId;
+	}
+	if(this._lang) {
+		payload += '&lang=' + this._lang;
+	}
+
+	return Util.requestByUrlEncoded(this._adcUrl, payload)
+		.then(function(json) {
+			json["requestField"] = field; // Attached requested field
+			return json;
+		})
+		.then(this._onADCUpdate)
+		.catch(function(err) {
+			console.log("ADC: ", err);
+		});
+};
+/** Validate type of value that are number, string, boolean or not.
+* @private
+* @param {*} value
+* @return {boolean}
+*/
+ADCSubscription.prototype._isValidValueType = function(value) {
+	var t = typeof value;
+	return (value === null || t == "string" || t == "number" || t == "boolean");
+};
+/** Function for processing the ADC response and publish the event to the listener.
+* @private
+* @param {Object} json JSON object of ADC response
+*/
+ADCSubscription.prototype._onADCUpdate = function(json) {
+	if(json["status"] && json["status"].toLowerCase() !== "ok") {
+		console.warn("Response status is not ready");
+		return;
+	}
+
+	var rows = json["rows"];
+	var reqField = json["requestField"];
+	var header = rows[0];
+	var ricIndex = -1, fieldIndex = -1;
+
+	var type, field;
+	for(var idx in header) {
+		type = header[idx]["i"];
+		field = header[idx]["r"];
+		if(type === "instrument") {
+			ricIndex = idx;
+		}
+		if (type === "value" && reqField === field) {
+			fieldIndex = idx;
+		}
+	}
+
+	var outputHash = {};
+	var rowsLen = rows.length;
+	var symbol, value, rowData;
+	for(var i = 1; i < rowsLen; i++) {
+		symbol = rows[i][ricIndex];
+		value = rows[i][fieldIndex];
+
+		rowData = outputHash[symbol];
+		if (!rowData) {
+			rowData = {};
+			outputHash[symbol] = rowData;
+		}
+
+		if(rowData[reqField] == null && this._isValidValueType(value)) {
+			rowData[reqField] = value;
+		}
+	}
+
+	// Publish data
+	for(symbol in outputHash) {
+		rowData = outputHash[symbol];
+		if(rowData[reqField]) { // Have the data to be updated
+			this._adcFieldMap[reqField][symbol] = rowData[reqField]; // Cache the data in service
+			this._dispatch("dataChanged", { "ric": symbol, "values": rowData, "sender": this });
+		}
+	}
+};
+
+export {ADCSubscription};

package/lib/tr-grid-util/es6/formula/AdFinService.d.ts

@@ -0,0 +1,12 @@
+import {AdFinSubscription} from "./AdFinSubscription.js";
+
+declare namespace AdFinService {
+
+    function create(): any;
+
+    function setAdFinSettings(uuid?: (string|null), productId?: (string|null), adfinUrl?: (string|null)): void;
+
+}
+
+export default AdFinService;
+export { AdFinService };

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

@@ -0,0 +1,61 @@
+import {AdFinSubscription} from "./AdFinSubscription.js";
+
+/** @namespace */
+var AdFinService = {};
+
+/** @type {string}
+* @private
+*/
+AdFinService._uuid = "GUEST";
+/** @type {string}
+* @private
+*/
+AdFinService._adfinProductId = "TMON";
+/** @type {Object}
+* @private
+*/
+AdFinService._adFinSubscription = null;
+/** @type {string|null}
+* @private
+*/
+AdFinService._tracsPlugInUrl = null;
+
+/** @public
+* @return {Object}
+*/
+AdFinService.create = function() {
+	var adfinSub = AdFinService._adFinSubscription;
+	if (!adfinSub) {
+		adfinSub = new AdFinSubscription();
+		AdFinService._adFinSubscription = adfinSub;
+		AdFinService.setAdFinSettings();
+	}
+	return adfinSub;
+};
+
+/** @public
+* @param {(string|null)=} uuid
+* @param {(string|null)=} productId
+* @param {(string|null)=} adfinUrl
+*/
+AdFinService.setAdFinSettings = function(uuid, productId, adfinUrl) {
+	if(uuid) {
+		AdFinService._uuid = uuid;
+	}
+	if(productId) {
+		AdFinService._adfinProductId = productId;
+	}
+	if(adfinUrl) {
+		AdFinService._tracsPlugInUrl = adfinUrl;
+	}
+	if(AdFinService._adFinSubscription) { // In case set the settings after the service was created.
+		uuid = AdFinService._uuid;
+		productId = AdFinService._adfinProductId;
+		adfinUrl = AdFinService._tracsPlugInUrl;
+
+		AdFinService._adFinSubscription.setAdFinSettings(uuid, productId, adfinUrl);
+	}
+};
+
+export default AdFinService;
+export { AdFinService };

package/lib/tr-grid-util/es6/formula/AdFinSubscription.d.ts

@@ -0,0 +1,19 @@
+import {Ext} from "../Ext.js";
+import {Util} from "../Util.js";
+import {EventDispatcher} from "../EventDispatcher.js";
+
+declare class AdFinSubscription extends EventDispatcher {
+
+    constructor();
+
+    public static readonly ConflatorDelay: number;
+
+    public setAdFinSettings(userId: string, productId: string, url: string): void;
+
+    public setIntervalTime(time: number): void;
+
+    public call(name: string, parameters: (string|number|null)[][]): any;
+
+}
+
+export {AdFinSubscription};