metaapi.cloud-sdk
Version:
SDK for MetaApi, a professional cloud forex API which includes MetaTrader REST API and MetaTrader websocket API. Supports both MetaTrader 5 (MT5) and MetaTrader 4 (MT4). CopyFactory copy trading API included. (https://metaapi.cloud)
420 lines (419 loc) • 72.4 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return PeriodStatisticsStreamManager;
}
});
const _randomstring = /*#__PURE__*/ _interop_require_default(require("randomstring"));
const _synchronizationListener = /*#__PURE__*/ _interop_require_default(require("../../../clients/metaApi/synchronizationListener"));
const _logger = /*#__PURE__*/ _interop_require_default(require("../../../logger"));
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
let PeriodStatisticsStreamManager = class PeriodStatisticsStreamManager {
/**
* Returns listeners for a tracker
* @param {string} accountId account id to return listeners for
* @param {string} trackerId tracker id to return listeners for
* @returns {{[listenerId: string]: PeriodStatisticsListener}} dictionary of period statistics listeners
*/ getTrackerListeners(accountId, trackerId) {
if (!this._periodStatisticsListeners[accountId] || !this._periodStatisticsListeners[accountId][trackerId]) {
return {};
} else {
return this._periodStatisticsListeners[accountId][trackerId];
}
}
/**
* Adds a period statistics event listener
* @param {PeriodStatisticsListener} listener period statistics event listener
* @param {String} accountId account id
* @param {String} trackerId tracker id
* @returns {String} listener id
*/ // eslint-disable-next-line complexity, max-statements
async addPeriodStatisticsListener(listener, accountId, trackerId) {
let newTracker = false;
if (!this._periodStatisticsCaches[accountId]) {
this._periodStatisticsCaches[accountId] = {};
}
if (!this._periodStatisticsCaches[accountId][trackerId]) {
newTracker = true;
this._periodStatisticsCaches[accountId][trackerId] = {
trackerData: {},
record: {},
lastPeriod: {},
equityAdjustments: {}
};
}
const cache = this._periodStatisticsCaches[accountId][trackerId];
let connection = null;
let retryIntervalInSeconds = this._retryIntervalInSeconds;
const equityTrackingClient = this._equityTrackingClient;
const listenerId = _randomstring.default.generate(10);
const removePeriodStatisticsListener = this.removePeriodStatisticsListener;
const getTrackerListeners = ()=>this.getTrackerListeners(accountId, trackerId);
const pendingInitalizationResolves = this._pendingInitalizationResolves;
const synchronizationFlags = this._accountSynchronizationFlags;
let PeriodStatisticsStreamListener = class PeriodStatisticsStreamListener extends _synchronizationListener.default {
async onDealsSynchronized(instanceIndex, synchronizationId) {
try {
if (!synchronizationFlags[accountId]) {
synchronizationFlags[accountId] = true;
Object.values(getTrackerListeners()).forEach((accountListener)=>{
accountListener.onConnected();
});
if (pendingInitalizationResolves[accountId]) {
pendingInitalizationResolves[accountId].forEach((resolve)=>resolve());
delete pendingInitalizationResolves[accountId];
}
}
} catch (err) {
listener.onError(err);
this._logger.error("Error processing onDealsSynchronized event for " + `equity chart listener for account ${accountId}`, err);
}
}
async onDisconnected(instanceIndex) {
try {
if (synchronizationFlags[accountId] && !connection.healthMonitor.healthStatus.synchronized) {
synchronizationFlags[accountId] = false;
Object.values(getTrackerListeners()).forEach((trackerListener)=>{
trackerListener.onDisconnected();
});
}
} catch (err) {
Object.values(getTrackerListeners()).forEach((trackerListener)=>{
trackerListener.onError(err);
});
this._logger.error("Error processing onDisconnected event for " + `equity chart listener for account ${accountId}`, err);
}
}
// eslint-disable-next-line complexity, max-statements
async onSymbolPriceUpdated(instanceIndex, price) {
try {
if (pendingInitalizationResolves[accountId]) {
pendingInitalizationResolves[accountId].forEach((resolve)=>resolve());
delete pendingInitalizationResolves[accountId];
}
if (!cache.lastPeriod) {
return;
}
/**
* Process brokerTime:
* - smaller than tracker startBrokerTime -> ignore
* - bigger than tracker endBrokerTime -> send onTrackerCompleted, close connection
* - bigger than period endBrokerTime -> send onPeriodStatisticsCompleted
* - normal -> compare to previous data, if different -> send onPeriodStatisticsUpdated
*/ const equity = price.equity - Object.values(cache.equityAdjustments).reduce((a, b)=>a + b, 0);
const brokerTime = price.brokerTime;
if (brokerTime > cache.lastPeriod.endBrokerTime) {
Object.values(getTrackerListeners()).forEach((trackerListener)=>{
trackerListener.onPeriodStatisticsCompleted();
});
cache.equityAdjustments = {};
const startBrokerTime = cache.lastPeriod.startBrokerTime;
cache.lastPeriod = null;
// eslint-disable-next-line no-constant-condition
while(true){
let periods = await equityTrackingClient.getTrackingStatistics(accountId, trackerId, undefined, 2, true);
if (periods[0].startBrokerTime === startBrokerTime) {
await new Promise((res)=>setTimeout(res, 10000));
} else {
cache.lastPeriod = periods[0];
periods.reverse();
Object.values(getTrackerListeners()).forEach((trackerListener)=>{
trackerListener.onPeriodStatisticsUpdated(periods);
});
break;
}
}
} else {
if (cache.trackerData.startBrokerTime && brokerTime < cache.trackerData.startBrokerTime) {
return;
}
if (cache.trackerData.endBrokerTime && brokerTime > cache.trackerData.endBrokerTime) {
Object.values(getTrackerListeners()).forEach((trackerListener)=>{
trackerListener.onTrackerCompleted();
});
cache.equityAdjustments = {};
Object.keys(getTrackerListeners()).forEach((trackerListenerId)=>{
removePeriodStatisticsListener(trackerListenerId);
});
}
let absoluteDrawdown = Math.max(0, cache.lastPeriod.initialBalance - equity);
let relativeDrawdown = absoluteDrawdown / cache.lastPeriod.initialBalance;
let absoluteProfit = Math.max(0, equity - cache.lastPeriod.initialBalance);
let relativeProfit = absoluteProfit / cache.lastPeriod.initialBalance;
const previousRecord = JSON.stringify(cache.record);
if (!cache.record.thresholdExceeded) {
if (cache.record.maxAbsoluteDrawdown < absoluteDrawdown) {
cache.record.maxAbsoluteDrawdown = absoluteDrawdown;
cache.record.maxRelativeDrawdown = relativeDrawdown;
cache.record.maxDrawdownTime = brokerTime;
if (cache.trackerData.relativeDrawdownThreshold && cache.trackerData.relativeDrawdownThreshold < relativeDrawdown || cache.trackerData.absoluteDrawdownThreshold && cache.trackerData.absoluteDrawdownThreshold < absoluteDrawdown) {
cache.record.thresholdExceeded = true;
cache.record.exceededThresholdType = "drawdown";
}
}
if (cache.record.maxAbsoluteProfit < absoluteProfit) {
cache.record.maxAbsoluteProfit = absoluteProfit;
cache.record.maxRelativeProfit = relativeProfit;
cache.record.maxProfitTime = brokerTime;
if (cache.trackerData.relativeProfitThreshold && cache.trackerData.relativeProfitThreshold < relativeProfit || cache.trackerData.absoluteProfitThreshold && cache.trackerData.absoluteProfitThreshold < absoluteProfit) {
cache.record.thresholdExceeded = true;
cache.record.exceededThresholdType = "profit";
}
}
if (JSON.stringify(cache.record) !== previousRecord) {
Object.values(getTrackerListeners()).forEach((trackerListener)=>{
trackerListener.onPeriodStatisticsUpdated([
{
startBrokerTime: cache.lastPeriod.startBrokerTime,
endBrokerTime: cache.lastPeriod.endBrokerTime,
initialBalance: cache.lastPeriod.initialBalance,
maxAbsoluteDrawdown: cache.record.maxAbsoluteDrawdown,
maxAbsoluteProfit: cache.record.maxAbsoluteProfit,
maxDrawdownTime: cache.record.maxDrawdownTime,
maxProfitTime: cache.record.maxProfitTime,
maxRelativeDrawdown: cache.record.maxRelativeDrawdown,
maxRelativeProfit: cache.record.maxRelativeProfit,
period: cache.lastPeriod.period,
exceededThresholdType: cache.record.exceededThresholdType,
thresholdExceeded: cache.record.thresholdExceeded,
tradeDayCount: cache.record.tradeDayCount
}
]);
});
}
}
}
} catch (err) {
Object.values(getTrackerListeners()).forEach((trackerListener)=>{
trackerListener.onError(err);
});
this._logger.error("Error processing onSymbolPriceUpdated event for " + `period statistics listener for account ${accountId}`, err);
}
}
async onDealAdded(instanceIndex, deal) {
try {
if (!cache.lastPeriod || !Object.keys(cache.lastPeriod).length) {
return;
}
if (deal.type === "DEAL_TYPE_BALANCE") {
cache.equityAdjustments[deal.id] = deal.profit;
}
const ignoredDealTypes = [
"DEAL_TYPE_BALANCE",
"DEAL_TYPE_CREDIT"
];
if (!ignoredDealTypes.includes(deal.type)) {
const timeDiff = new Date(deal.time).getTime() - new Date(deal.brokerTime).getTime();
const startSearchDate = new Date(new Date(cache.lastPeriod.startBrokerTime).getTime() + timeDiff);
const deals = connection.historyStorage.getDealsByTimeRange(startSearchDate, new Date(8640000000000000)).filter((dealItem)=>!ignoredDealTypes.includes(dealItem.type));
deals.push(deal);
const tradedDays = {};
deals.forEach((dealItem)=>{
tradedDays[dealItem.brokerTime.slice(0, 10)] = true;
});
const tradeDayCount = Object.keys(tradedDays).length;
if (cache.record.tradeDayCount !== tradeDayCount) {
cache.record.tradeDayCount = tradeDayCount;
Object.values(getTrackerListeners()).forEach((trackerListener)=>{
trackerListener.onPeriodStatisticsUpdated([
{
startBrokerTime: cache.lastPeriod.startBrokerTime,
endBrokerTime: cache.lastPeriod.endBrokerTime,
initialBalance: cache.lastPeriod.initialBalance,
maxAbsoluteDrawdown: cache.record.maxAbsoluteDrawdown,
maxAbsoluteProfit: cache.record.maxAbsoluteProfit,
maxDrawdownTime: cache.record.maxDrawdownTime,
maxProfitTime: cache.record.maxProfitTime,
maxRelativeDrawdown: cache.record.maxRelativeDrawdown,
maxRelativeProfit: cache.record.maxRelativeProfit,
period: cache.lastPeriod.period,
exceededThresholdType: cache.record.exceededThresholdType,
thresholdExceeded: cache.record.thresholdExceeded,
tradeDayCount: cache.record.tradeDayCount
}
]);
});
}
}
} catch (err) {
Object.values(getTrackerListeners()).forEach((trackerListener)=>{
trackerListener.onError(err);
});
this._logger.error("Error processing onDealAdded event for " + `period statistics listener for account ${accountId}`, err);
}
}
};
const account = await this._metaApi.metatraderAccountApi.getAccount(accountId);
const tracker = await equityTrackingClient.getTracker(accountId, trackerId);
cache.trackerData = tracker;
if (!this._periodStatisticsListeners[accountId]) {
this._periodStatisticsListeners[accountId] = {};
}
if (!this._periodStatisticsListeners[accountId][trackerId]) {
this._periodStatisticsListeners[accountId][trackerId] = {};
}
const accountListeners = this._periodStatisticsListeners[accountId][trackerId];
accountListeners[listenerId] = listener;
this._accountsByListenerId[listenerId] = accountId;
this._trackersByListenerId[listenerId] = trackerId;
let isDeployed = false;
while(!isDeployed){
try {
await account.waitDeployed();
isDeployed = true;
} catch (err) {
listener.onError(err);
this._logger.error(`Error wait for account ${accountId} to deploy, retrying`, err);
await new Promise((res)=>setTimeout(res, retryIntervalInSeconds * 1000));
retryIntervalInSeconds = Math.min(retryIntervalInSeconds * 2, 300);
}
}
if (!this._periodStatisticsConnections[accountId]) {
retryIntervalInSeconds = this._retryIntervalInSeconds;
connection = account.getStreamingConnection();
const syncListener = new PeriodStatisticsStreamListener();
connection.addSynchronizationListener(syncListener);
this._periodStatisticsConnections[accountId] = connection;
this._syncListeners[trackerId] = syncListener;
let isSynchronized = false;
while(!isSynchronized){
try {
await connection.connect();
await connection.waitSynchronized();
isSynchronized = true;
} catch (err) {
listener.onError(err);
this._logger.error("Error configuring period statistics stream listener for " + `account ${accountId}, retrying`, err);
await new Promise((res)=>setTimeout(res, retryIntervalInSeconds * 1000));
retryIntervalInSeconds = Math.min(retryIntervalInSeconds * 2, 300);
}
}
retryIntervalInSeconds = this._retryIntervalInSeconds;
} else {
connection = this._periodStatisticsConnections[accountId];
if (newTracker) {
const syncListener = new PeriodStatisticsStreamListener();
connection.addSynchronizationListener(syncListener);
this._syncListeners[trackerId] = syncListener;
}
if (!connection.healthMonitor.healthStatus.synchronized) {
if (!this._pendingInitalizationResolves[accountId]) {
this._pendingInitalizationResolves[accountId] = [];
}
let resolveInitialize;
let initializePromise = new Promise((res, rej)=>{
resolveInitialize = res;
});
this._pendingInitalizationResolves[accountId].push(resolveInitialize);
await initializePromise;
}
}
let initialData = [];
const fetchInitialData = async ()=>{
try {
initialData = await equityTrackingClient.getTrackingStatistics(accountId, trackerId, undefined, undefined, true);
if (initialData.length) {
const lastItem = initialData[0];
if (this._fetchInitialDataIntervalId[listenerId]) {
clearInterval(this._fetchInitialDataIntervalId[listenerId]);
delete this._fetchInitialDataIntervalId[listenerId];
}
listener.onPeriodStatisticsUpdated(initialData);
cache.lastPeriod = {
startBrokerTime: lastItem.startBrokerTime,
endBrokerTime: lastItem.endBrokerTime,
period: lastItem.period,
initialBalance: lastItem.initialBalance,
maxDrawdownTime: lastItem.maxDrawdownTime,
maxAbsoluteDrawdown: lastItem.maxAbsoluteDrawdown,
maxRelativeDrawdown: lastItem.maxRelativeDrawdown,
maxProfitTime: lastItem.maxProfitTime,
maxAbsoluteProfit: lastItem.maxAbsoluteProfit,
maxRelativeProfit: lastItem.maxRelativeProfit,
thresholdExceeded: lastItem.thresholdExceeded,
exceededThresholdType: lastItem.exceededThresholdType,
tradeDayCount: lastItem.tradeDayCount
};
cache.record = cache.lastPeriod;
}
} catch (err) {
listener.onError(err);
this._logger.error(`Failed to initialize tracking statistics data for account ${accountId}`, err);
await new Promise((res)=>setTimeout(res, retryIntervalInSeconds * 1000));
retryIntervalInSeconds = Math.min(retryIntervalInSeconds * 2, 300);
}
};
retryIntervalInSeconds = this._retryIntervalInSeconds;
this._fetchInitialDataIntervalId[listenerId] = setInterval(fetchInitialData, retryIntervalInSeconds * 1000 * 2 * 60);
fetchInitialData();
return listenerId;
}
/**
* Removes period statistics event listener by id
* @param {String} listenerId listener id
*/ // eslint-disable-next-line complexity
removePeriodStatisticsListener(listenerId) {
if (this._accountsByListenerId[listenerId] && this._trackersByListenerId[listenerId]) {
if (this._fetchInitialDataIntervalId[listenerId]) {
clearInterval(this._fetchInitialDataIntervalId[listenerId]);
delete this._fetchInitialDataIntervalId[listenerId];
}
const accountId = this._accountsByListenerId[listenerId];
const trackerId = this._trackersByListenerId[listenerId];
delete this._accountsByListenerId[listenerId];
delete this._trackersByListenerId[listenerId];
if (this._periodStatisticsListeners[accountId]) {
if (this._periodStatisticsListeners[accountId][trackerId]) {
delete this._periodStatisticsListeners[accountId][trackerId][listenerId];
if (!Object.keys(this._periodStatisticsListeners[accountId][trackerId]).length) {
delete this._periodStatisticsListeners[accountId][trackerId];
if (this._periodStatisticsConnections[accountId] && this._syncListeners[trackerId]) {
this._periodStatisticsConnections[accountId].removeSynchronizationListener(this._syncListeners[trackerId]);
delete this._syncListeners[trackerId];
}
}
}
if (!Object.keys(this._periodStatisticsListeners[accountId]).length) {
delete this._periodStatisticsListeners[accountId];
}
}
if (this._periodStatisticsConnections[accountId] && !this._periodStatisticsListeners[accountId]) {
delete this._accountSynchronizationFlags[accountId];
this._periodStatisticsConnections[accountId].close();
delete this._periodStatisticsConnections[accountId];
}
}
}
/**
* Constructs period statistics event listener manager instance
* @param {DomainClient} domainClient domain client
* @param {EquityTrackingClient} equityTrackingClient equity tracking client
* @param {MetaApi} metaApi metaApi SDK instance
*/ constructor(domainClient, equityTrackingClient, metaApi){
this._domainClient = domainClient;
this._equityTrackingClient = equityTrackingClient;
this._metaApi = metaApi;
this._periodStatisticsListeners = {};
this._accountsByListenerId = {};
this._trackersByListenerId = {};
this._trackerSyncListeners = {};
this._periodStatisticsConnections = {};
this._periodStatisticsCaches = {};
this._accountSynchronizationFlags = {};
this._pendingInitalizationResolves = {};
this._syncListeners = {};
this._retryIntervalInSeconds = 1;
this._fetchInitialDataIntervalId = {};
this.removePeriodStatisticsListener = this.removePeriodStatisticsListener.bind(this);
this._logger = _logger.default.getLogger("PeriodStatisticsStreamManager");
}
};
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["<anon>"],"sourcesContent":["'use strict';\n\nimport randomstring from 'randomstring';\nimport SynchronizationListener from '../../../clients/metaApi/synchronizationListener';\n// import {NotFoundError} from '../../../clients/errorHandler';\nimport LoggerManager from '../../../logger';\n\n/**\n * Manager for handling period statistics event listeners\n */\nexport default class PeriodStatisticsStreamManager {\n\n  /**\n   * Constructs period statistics event listener manager instance\n   * @param {DomainClient} domainClient domain client\n   * @param {EquityTrackingClient} equityTrackingClient equity tracking client\n   * @param {MetaApi} metaApi metaApi SDK instance\n   */\n  constructor(domainClient, equityTrackingClient, metaApi) {\n    this._domainClient = domainClient;\n    this._equityTrackingClient = equityTrackingClient;\n    this._metaApi = metaApi;\n    this._periodStatisticsListeners = {};\n    this._accountsByListenerId = {};\n    this._trackersByListenerId = {};\n    this._trackerSyncListeners = {};\n    this._periodStatisticsConnections = {};\n    this._periodStatisticsCaches = {};\n    this._accountSynchronizationFlags = {};\n    this._pendingInitalizationResolves = {};\n    this._syncListeners = {};\n    this._retryIntervalInSeconds = 1;\n    this._fetchInitialDataIntervalId = {};\n    this.removePeriodStatisticsListener = this.removePeriodStatisticsListener.bind(this);\n    this._logger = LoggerManager.getLogger('PeriodStatisticsStreamManager');\n  }\n\n  /**\n   * Returns listeners for a tracker\n   * @param {string} accountId account id to return listeners for\n   * @param {string} trackerId tracker id to return listeners for\n   * @returns {{[listenerId: string]: PeriodStatisticsListener}} dictionary of period statistics listeners\n   */\n  getTrackerListeners(accountId, trackerId) {\n    if(!this._periodStatisticsListeners[accountId] || !this._periodStatisticsListeners[accountId][trackerId]) {\n      return {};\n    } else {\n      return this._periodStatisticsListeners[accountId][trackerId];\n    }\n  }\n\n  /**\n   * Adds a period statistics event listener\n   * @param {PeriodStatisticsListener} listener period statistics event listener\n   * @param {String} accountId account id\n   * @param {String} trackerId tracker id\n   * @returns {String} listener id\n   */\n  // eslint-disable-next-line complexity, max-statements\n  async addPeriodStatisticsListener(listener, accountId, trackerId) {\n    let newTracker = false;\n    if(!this._periodStatisticsCaches[accountId]) {\n      this._periodStatisticsCaches[accountId] = {};\n    }\n    if(!this._periodStatisticsCaches[accountId][trackerId]) {\n      newTracker = true;\n      this._periodStatisticsCaches[accountId][trackerId] = {\n        trackerData: {},\n        record: {},\n        lastPeriod: {},\n        equityAdjustments: {}\n      };\n    }\n    const cache = this._periodStatisticsCaches[accountId][trackerId];\n    let connection = null;\n    let retryIntervalInSeconds = this._retryIntervalInSeconds;\n    const equityTrackingClient = this._equityTrackingClient;\n    const listenerId = randomstring.generate(10);\n    const removePeriodStatisticsListener = this.removePeriodStatisticsListener;\n    const getTrackerListeners = () => this.getTrackerListeners(accountId, trackerId);\n    const pendingInitalizationResolves = this._pendingInitalizationResolves;\n    const synchronizationFlags = this._accountSynchronizationFlags;\n\n    class PeriodStatisticsStreamListener extends SynchronizationListener {\n\n      async onDealsSynchronized(instanceIndex, synchronizationId) {\n        try {\n          if(!synchronizationFlags[accountId]) {\n            synchronizationFlags[accountId] = true;\n            Object.values(getTrackerListeners()).forEach(accountListener => {\n              accountListener.onConnected();\n            });\n            if(pendingInitalizationResolves[accountId]) {\n              pendingInitalizationResolves[accountId].forEach(resolve => resolve());\n              delete pendingInitalizationResolves[accountId];\n            }\n          }\n        } catch (err) {\n          listener.onError(err);\n          this._logger.error('Error processing onDealsSynchronized event for ' +\n          `equity chart listener for account ${accountId}`, err);\n        }\n      }\n\n      async onDisconnected(instanceIndex) {\n        try {\n          if(synchronizationFlags[accountId] && !connection.healthMonitor.healthStatus.synchronized) {\n            synchronizationFlags[accountId] = false;\n            Object.values(getTrackerListeners()).forEach(trackerListener => {\n              trackerListener.onDisconnected();\n            });\n          }\n        } catch (err) {\n          Object.values(getTrackerListeners()).forEach(trackerListener => {\n            trackerListener.onError(err);\n          });\n          this._logger.error('Error processing onDisconnected event for ' +\n          `equity chart listener for account ${accountId}`, err);\n        }\n      }\n\n      // eslint-disable-next-line complexity, max-statements\n      async onSymbolPriceUpdated(instanceIndex, price) {\n        try {\n          if(pendingInitalizationResolves[accountId]) {\n            pendingInitalizationResolves[accountId].forEach(resolve => resolve());\n            delete pendingInitalizationResolves[accountId];\n          }\n  \n          if(!cache.lastPeriod) {\n            return;\n          }\n  \n          /**\n           * Process brokerTime:\n           * - smaller than tracker startBrokerTime -> ignore\n           * - bigger than tracker endBrokerTime -> send onTrackerCompleted, close connection\n           * - bigger than period endBrokerTime -> send onPeriodStatisticsCompleted\n           * - normal -> compare to previous data, if different -> send onPeriodStatisticsUpdated\n           */\n          const equity = price.equity - Object.values(cache.equityAdjustments)\n            .reduce((a, b) => a + b, 0);\n          const brokerTime = price.brokerTime;\n          if(brokerTime > cache.lastPeriod.endBrokerTime) {\n            Object.values(getTrackerListeners()).forEach(trackerListener => {\n              trackerListener.onPeriodStatisticsCompleted();\n            });\n            cache.equityAdjustments = {};\n            const startBrokerTime = cache.lastPeriod.startBrokerTime;\n            cache.lastPeriod = null;\n            // eslint-disable-next-line no-constant-condition\n            while(true) {\n              let periods = await equityTrackingClient.getTrackingStatistics(accountId, trackerId, undefined, 2, true);\n              if(periods[0].startBrokerTime === startBrokerTime) {\n                await new Promise(res => setTimeout(res, 10000));\n              } else {\n                cache.lastPeriod = periods[0];\n                periods.reverse();\n                Object.values(getTrackerListeners()).forEach(trackerListener => {\n                  trackerListener.onPeriodStatisticsUpdated(periods);\n                });\n                break;\n              }\n            }\n          } else {\n            if(cache.trackerData.startBrokerTime && brokerTime < cache.trackerData.startBrokerTime) {\n              return;\n            }\n            if(cache.trackerData.endBrokerTime && brokerTime > cache.trackerData.endBrokerTime) {\n              Object.values(getTrackerListeners()).forEach(trackerListener => {\n                trackerListener.onTrackerCompleted();\n              });\n              cache.equityAdjustments = {};\n              Object.keys(getTrackerListeners()).forEach(trackerListenerId => {\n                removePeriodStatisticsListener(trackerListenerId);\n              });\n            }\n            \n            let absoluteDrawdown = Math.max(0, cache.lastPeriod.initialBalance - equity);\n            let relativeDrawdown = absoluteDrawdown / cache.lastPeriod.initialBalance;\n            let absoluteProfit = Math.max(0, equity - cache.lastPeriod.initialBalance);\n            let relativeProfit = absoluteProfit / cache.lastPeriod.initialBalance;\n            const previousRecord = JSON.stringify(cache.record);\n            if(!cache.record.thresholdExceeded) {\n              if(cache.record.maxAbsoluteDrawdown < absoluteDrawdown) {\n                cache.record.maxAbsoluteDrawdown = absoluteDrawdown;\n                cache.record.maxRelativeDrawdown = relativeDrawdown;\n                cache.record.maxDrawdownTime = brokerTime;\n                if((cache.trackerData.relativeDrawdownThreshold && \n                  cache.trackerData.relativeDrawdownThreshold < relativeDrawdown) || \n                  (cache.trackerData.absoluteDrawdownThreshold &&\n                    cache.trackerData.absoluteDrawdownThreshold < absoluteDrawdown)) {\n                  cache.record.thresholdExceeded = true;\n                  cache.record.exceededThresholdType = 'drawdown';\n                }\n              }\n              if(cache.record.maxAbsoluteProfit < absoluteProfit) {\n                cache.record.maxAbsoluteProfit = absoluteProfit;\n                cache.record.maxRelativeProfit = relativeProfit;\n                cache.record.maxProfitTime = brokerTime;\n                if((cache.trackerData.relativeProfitThreshold && \n                  cache.trackerData.relativeProfitThreshold < relativeProfit) ||\n                  (cache.trackerData.absoluteProfitThreshold &&\n                    cache.trackerData.absoluteProfitThreshold < absoluteProfit)) {\n                  cache.record.thresholdExceeded = true;\n                  cache.record.exceededThresholdType = 'profit';\n                }\n              }\n              if(JSON.stringify(cache.record) !== previousRecord) {\n                Object.values(getTrackerListeners()).forEach(trackerListener => {\n                  trackerListener.onPeriodStatisticsUpdated([{\n                    startBrokerTime: cache.lastPeriod.startBrokerTime,\n                    endBrokerTime: cache.lastPeriod.endBrokerTime,\n                    initialBalance: cache.lastPeriod.initialBalance,\n                    maxAbsoluteDrawdown: cache.record.maxAbsoluteDrawdown,\n                    maxAbsoluteProfit: cache.record.maxAbsoluteProfit,\n                    maxDrawdownTime: cache.record.maxDrawdownTime,\n                    maxProfitTime: cache.record.maxProfitTime,\n                    maxRelativeDrawdown: cache.record.maxRelativeDrawdown,\n                    maxRelativeProfit: cache.record.maxRelativeProfit,\n                    period: cache.lastPeriod.period,\n                    exceededThresholdType: cache.record.exceededThresholdType,\n                    thresholdExceeded: cache.record.thresholdExceeded,\n                    tradeDayCount: cache.record.tradeDayCount\n                  }]);\n                });\n              }\n            }\n          }\n        } catch (err) {\n          Object.values(getTrackerListeners()).forEach(trackerListener => {\n            trackerListener.onError(err);\n          });\n          this._logger.error('Error processing onSymbolPriceUpdated event for ' +\n          `period statistics listener for account ${accountId}`, err);\n        }\n      }\n\n      async onDealAdded(instanceIndex, deal) {\n        try {\n          if(!cache.lastPeriod || !Object.keys(cache.lastPeriod).length) {\n            return;\n          }\n          if(deal.type === 'DEAL_TYPE_BALANCE') {\n            cache.equityAdjustments[deal.id] = deal.profit;\n          }\n          const ignoredDealTypes = ['DEAL_TYPE_BALANCE', 'DEAL_TYPE_CREDIT'];\n          if(!ignoredDealTypes.includes(deal.type)) {\n            const timeDiff = new Date(deal.time).getTime() - new Date(deal.brokerTime).getTime();\n            const startSearchDate = new Date(new Date(cache.lastPeriod.startBrokerTime).getTime() + timeDiff);\n            const deals = connection.historyStorage.getDealsByTimeRange(startSearchDate, new Date(8640000000000000))\n              .filter(dealItem => !ignoredDealTypes.includes(dealItem.type));\n            deals.push(deal);\n            const tradedDays = {};\n            deals.forEach(dealItem => {\n              tradedDays[dealItem.brokerTime.slice(0, 10)] = true;\n            });\n            const tradeDayCount = Object.keys(tradedDays).length;\n            if(cache.record.tradeDayCount !== tradeDayCount) {\n              cache.record.tradeDayCount = tradeDayCount;\n              Object.values(getTrackerListeners()).forEach(trackerListener => {\n                trackerListener.onPeriodStatisticsUpdated([{\n                  startBrokerTime: cache.lastPeriod.startBrokerTime,\n                  endBrokerTime: cache.lastPeriod.endBrokerTime,\n                  initialBalance: cache.lastPeriod.initialBalance,\n                  maxAbsoluteDrawdown: cache.record.maxAbsoluteDrawdown,\n                  maxAbsoluteProfit: cache.record.maxAbsoluteProfit,\n                  maxDrawdownTime: cache.record.maxDrawdownTime,\n                  maxProfitTime: cache.record.maxProfitTime,\n                  maxRelativeDrawdown: cache.record.maxRelativeDrawdown,\n                  maxRelativeProfit: cache.record.maxRelativeProfit,\n                  period: cache.lastPeriod.period,\n                  exceededThresholdType: cache.record.exceededThresholdType,\n                  thresholdExceeded: cache.record.thresholdExceeded,\n                  tradeDayCount: cache.record.tradeDayCount\n                }]);\n              });\n            }\n          }\n        } catch (err) {\n          Object.values(getTrackerListeners()).forEach(trackerListener => {\n            trackerListener.onError(err);\n          });\n          this._logger.error('Error processing onDealAdded event for ' +\n          `period statistics listener for account ${accountId}`, err);\n        }\n      }\n    }\n\n    const account = await this._metaApi.metatraderAccountApi.getAccount(accountId);\n    const tracker = await equityTrackingClient.getTracker(accountId, trackerId);\n    cache.trackerData = tracker;\n    if(!this._periodStatisticsListeners[accountId]) {\n      this._periodStatisticsListeners[accountId] = {};\n    }\n    if(!this._periodStatisticsListeners[accountId][trackerId]) {\n      this._periodStatisticsListeners[accountId][trackerId] = {};\n    }\n    const accountListeners = this._periodStatisticsListeners[accountId][trackerId];\n    accountListeners[listenerId] = listener;\n    this._accountsByListenerId[listenerId] = accountId;\n    this._trackersByListenerId[listenerId] = trackerId;\n    let isDeployed = false;\n    while(!isDeployed) {\n      try {\n        await account.waitDeployed();\n        isDeployed = true;  \n      } catch (err) {\n        listener.onError(err);\n        this._logger.error(`Error wait for account ${accountId} to deploy, retrying`, err);\n        await new Promise(res => setTimeout(res, retryIntervalInSeconds * 1000)); \n        retryIntervalInSeconds = Math.min(retryIntervalInSeconds * 2, 300);\n      }\n    }\n    if(!this._periodStatisticsConnections[accountId]) {\n      retryIntervalInSeconds = this._retryIntervalInSeconds;\n      connection = account.getStreamingConnection();\n      const syncListener = new PeriodStatisticsStreamListener();\n      connection.addSynchronizationListener(syncListener);\n      this._periodStatisticsConnections[accountId] = connection;\n      this._syncListeners[trackerId] = syncListener;\n      \n      let isSynchronized = false;\n      while(!isSynchronized) {\n        try {\n          await connection.connect();\n          await connection.waitSynchronized();\n          isSynchronized = true;\n        } catch (err) {\n          listener.onError(err);\n          this._logger.error('Error configuring period statistics stream listener for ' +\n          `account ${accountId}, retrying`, err);\n          await new Promise(res => setTimeout(res, retryIntervalInSeconds * 1000)); \n          retryIntervalInSeconds = Math.min(retryIntervalInSeconds * 2, 300);\n        }\n      }\n      retryIntervalInSeconds = this._retryIntervalInSeconds;\n    } else {\n      connection = this._periodStatisticsConnections[accountId];\n      if(newTracker) {\n        const syncListener = new PeriodStatisticsStreamListener();\n        connection.addSynchronizationListener(syncListener);\n        this._syncListeners[trackerId] = syncListener;\n      }\n      if(!connection.healthMonitor.healthStatus.synchronized) {\n        if(!this._pendingInitalizationResolves[accountId]) {\n          this._pendingInitalizationResolves[accountId] = [];\n        }\n        let resolveInitialize;\n        let initializePromise = new Promise((res, rej) => {\n          resolveInitialize = res;\n        });\n        this._pendingInitalizationResolves[accountId].push(resolveInitialize);\n        await initializePromise;\n      }\n    }\n    \n    let initialData = [];\n    const fetchInitialData = async () => {\n      try {\n        initialData = await equityTrackingClient.getTrackingStatistics(accountId, trackerId,\n          undefined, undefined, true);\n        if(initialData.length) {\n          const lastItem = initialData[0];\n          if(this._fetchInitialDataIntervalId[listenerId]) {\n            clearInterval(this._fetchInitialDataIntervalId[listenerId]);\n            delete this._fetchInitialDataIntervalId[listenerId];\n          }\n          listener.onPeriodStatisticsUpdated(initialData);\n          cache.lastPeriod = {\n            startBrokerTime: lastItem.startBrokerTime,\n            endBrokerTime: lastItem.endBrokerTime,\n            period: lastItem.period,\n            initialBalance: lastItem.initialBalance,\n            maxDrawdownTime: lastItem.maxDrawdownTime,\n            maxAbsoluteDrawdown: lastItem.maxAbsoluteDrawdown,\n            maxRelativeDrawdown: lastItem.maxRelativeDrawdown,\n            maxProfitTime: lastItem.maxProfitTime,\n            maxAbsoluteProfit: lastItem.maxAbsoluteProfit,\n            maxRelativeProfit: lastItem.maxRelativeProfit,\n            thresholdExceeded: lastItem.thresholdExceeded,\n            exceededThresholdType: lastItem.exceededThresholdType,\n            tradeDayCount: lastItem.tradeDayCount\n          };\n          cache.record = cache.lastPeriod;\n        }\n      } catch (err) {\n        listener.onError(err);\n        this._logger.error(`Failed to initialize tracking statistics data for account ${accountId}`, err);\n        await new Promise(res => setTimeout(res, retryIntervalInSeconds * 1000)); \n        retryIntervalInSeconds = Math.min(retryIntervalInSeconds * 2, 300);\n      }\n    };\n    retryIntervalInSeconds = this._retryIntervalInSeconds;\n    this._fetchInitialDataIntervalId[listenerId] = \n      setInterval(fetchInitialData, retryIntervalInSeconds * 1000 * 2 * 60);\n    fetchInitialData();\n\n    return listenerId;\n  }\n\n  /**\n   * Removes period statistics event listener by id\n   * @param {String} listenerId listener id \n   */\n  // eslint-disable-next-line complexity\n  removePeriodStatisticsListener(listenerId) {\n    if(this._accountsByListenerId[liste