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)
205 lines (204 loc) • 21.8 kB
JavaScript
;
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
try {
var info = gen[key](arg);
var value = info.value;
} catch (error) {
reject(error);
return;
}
if (info.done) {
resolve(value);
} else {
Promise.resolve(value).then(_next, _throw);
}
}
function _async_to_generator(fn) {
return function() {
var self = this, args = arguments;
return new Promise(function(resolve, reject) {
var gen = fn.apply(self, args);
function _next(value) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
}
function _throw(err) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
}
_next(undefined);
});
};
}
import SynchronizationListener from '../clients/metaApi/synchronizationListener';
let HistoryStorage = class HistoryStorage extends SynchronizationListener {
/**
* Initializes the storage and loads required data from a persistent storage
* @param {string} accountId account id
* @param {string} application application
* @returns {Promise} promise resolving when history storage is initialized
*/ initialize(accountId, application) {
var _this = this;
return _async_to_generator(function*() {
_this._accountId = accountId;
_this._application = application;
})();
}
/**
* Returns flag indicating whether order history synchronization have finished
* @return {Boolean} flag indicating whether order history synchronization have finished
*/ get orderSynchronizationFinished() {
return Object.values(this._orderSynchronizationFinished).reduce((acc, r)=>acc || r, false);
}
/**
* Returns flag indicating whether deal history synchronization have finished
* @return {Boolean} flag indicating whether deal history synchronization have finished
*/ get dealSynchronizationFinished() {
return Object.values(this._dealSynchronizationFinished).reduce((acc, r)=>acc || r, false);
}
/**
* Clears the storage and deletes persistent data
* @returns {Promise} promise resolving when history storage is cleared
*/ clear() {
return _async_to_generator(function*() {
throw Error('Abstract method clear has no implementation');
})();
}
/**
* Returns the time of the last history order record stored in the history storage
* @param {String} [instanceIndex] index of an account instance connected
* @returns {Promise<Date>} the time of the last history order record stored in the history storage
*/ lastHistoryOrderTime(instanceIndex) {
return _async_to_generator(function*() {
throw Error('Abstract method lastHistoryOrderTime has no implementation');
})();
}
/**
* Returns the time of the last history deal record stored in the history storage
* @param {String} [instanceIndex] index of an account instance connected
* @returns {Promise<Date>} the time of the last history deal record stored in the history storage
*/ lastDealTime(instanceIndex) {
return _async_to_generator(function*() {
throw Error('Abstract method lastDealTime has no implementation');
})();
}
/**
* Invoked when a new MetaTrader history order is added
* @param {String} instanceIndex index of an account instance connected
* @param {MetatraderOrder} historyOrder new MetaTrader history order
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ onHistoryOrderAdded(instanceIndex, historyOrder) {
return _async_to_generator(function*() {
throw Error('Abstract method onHistoryOrderAdded has no implementation');
})();
}
/**
* Invoked when a new MetaTrader history deal is added
* @param {String} instanceIndex index of an account instance connected
* @param {MetatraderDeal} deal new MetaTrader history deal
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ onDealAdded(instanceIndex, deal) {
return _async_to_generator(function*() {
throw Error('Abstract method onDealAdded has no implementation');
})();
}
/**
* Invoked when a synchronization of history deals on a MetaTrader account have finished to indicate progress of an
* initial terminal state synchronization
* @param {String} instanceIndex index of an account instance connected
* @param {String} synchronizationId synchronization request id
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ onDealsSynchronized(instanceIndex, synchronizationId) {
var _this = this;
return _async_to_generator(function*() {
const instance = _this.getInstanceNumber(instanceIndex);
_this._dealSynchronizationFinished['' + instance] = true;
})();
}
/**
* Invoked when a synchronization of history orders on a MetaTrader account have finished to indicate progress of an
* initial terminal state synchronization
* @param {String} instanceIndex index of an account instance connected
* @param {String} synchronizationId synchronization request id
* @return {Promise} promise which resolves when the asynchronous event is processed
*/ onHistoryOrdersSynchronized(instanceIndex, synchronizationId) {
var _this = this;
return _async_to_generator(function*() {
const instance = _this.getInstanceNumber(instanceIndex);
_this._orderSynchronizationFinished['' + instance] = true;
})();
}
/**
* Invoked when connection to MetaTrader terminal established
* @param {String} instanceIndex index of an account instance connected
*/ onConnected(instanceIndex) {
const instance = this.getInstanceNumber(instanceIndex);
this._orderSynchronizationFinished['' + instance] = false;
this._dealSynchronizationFinished['' + instance] = false;
}
/**
* Returns all deals
* @returns {Array<MetatraderDeal>} all deals
*/ get deals() {
throw Error('Abstract property deals has no implementation');
}
/**
* Returns deals by ticket id
* @param {string} id ticket id
* @returns {Array<MetatraderDeal>} deals found
*/ getDealsByTicket(id) {
throw Error('Abstract method getDealsByTicket has no implementation');
}
/**
* Returns deals by position id
* @param {string} positionId position id
* @returns {Array<MetatraderDeal>} deals found
*/ getDealsByPosition(positionId) {
throw Error('Abstract method getDealsByPosition has no implementation');
}
/**
* Returns deals by time range
* @param startTime start time, inclusive
* @param endTime end time, inclusive
* @returns {Array<MetatraderDeal>} deals found
*/ getDealsByTimeRange(startTime, endTime) {
throw Error('Abstract method getDealsByTimeRange has no implementation');
}
/**
* Returns all history orders
* @returns {Array<MetatraderOrder>} all history orders
*/ get historyOrders() {
throw Error('Abstract property historyOrders has no implementation');
}
/**
* Returns history orders by ticket id
* @param {string} id ticket id
* @returns {Array<MetatraderOrder>} history orders found
*/ getHistoryOrdersByTicket(id) {
throw Error('Abstract method getHistoryOrdersByTicket has no implementation');
}
/**
* Returns history orders by position id
* @param {string} positionId position id
* @returns {Array<MetatraderOrder>} history orders found
*/ getHistoryOrdersByPosition(positionId) {
throw Error('Abstract method getHistoryOrdersByPosition has no implementation');
}
/**
* Returns history orders by time range
* @param startTime start time, inclusive
* @param endTime end time, inclusive
* @returns {Array<MetatraderOrder>} hisotry orders found
*/ getHistoryOrdersByTimeRange(startTime, endTime) {
throw Error('Abstract method getHistoryOrdersByTimeRange has no implementation');
}
/**
* Constructs the history storage
*/ constructor(){
super();
this._orderSynchronizationFinished = {};
this._dealSynchronizationFinished = {};
}
};
/**
* Abstract class which defines MetaTrader history storage interface.
*/ export { HistoryStorage as default };
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["<anon>"],"sourcesContent":["'use strict';\n\nimport SynchronizationListener from '../clients/metaApi/synchronizationListener';\n\n/**\n * Abstract class which defines MetaTrader history storage interface.\n */\nexport default class HistoryStorage extends SynchronizationListener {\n\n  /**\n   * Constructs the history storage\n   */\n  constructor() {\n    super();\n    this._orderSynchronizationFinished = {};\n    this._dealSynchronizationFinished = {};\n  }\n\n  /**\n   * Initializes the storage and loads required data from a persistent storage\n   * @param {string} accountId account id\n   * @param {string} application application\n   * @returns {Promise} promise resolving when history storage is initialized\n   */\n  async initialize(accountId, application) {\n    this._accountId = accountId;\n    this._application = application;\n  }\n\n  /**\n   * Returns flag indicating whether order history synchronization have finished\n   * @return {Boolean} flag indicating whether order history synchronization have finished\n   */\n  get orderSynchronizationFinished() {\n    return Object.values(this._orderSynchronizationFinished).reduce((acc, r) => acc || r, false);\n  }\n\n  /**\n   * Returns flag indicating whether deal history synchronization have finished\n   * @return {Boolean} flag indicating whether deal history synchronization have finished\n   */\n  get dealSynchronizationFinished() {\n    return Object.values(this._dealSynchronizationFinished).reduce((acc, r) => acc || r, false);\n  }\n\n  /**\n   * Clears the storage and deletes persistent data\n   * @returns {Promise} promise resolving when history storage is cleared\n   */\n  async clear() {\n    throw Error('Abstract method clear has no implementation');\n  }\n\n  /**\n   * Returns the time of the last history order record stored in the history storage\n   * @param {String} [instanceIndex] index of an account instance connected\n   * @returns {Promise<Date>} the time of the last history order record stored in the history storage\n   */\n  async lastHistoryOrderTime(instanceIndex) {\n    throw Error('Abstract method lastHistoryOrderTime has no implementation');\n  }\n\n  /**\n   * Returns the time of the last history deal record stored in the history storage\n   * @param {String} [instanceIndex] index of an account instance connected\n   * @returns {Promise<Date>} the time of the last history deal record stored in the history storage\n   */\n  async lastDealTime(instanceIndex) {\n    throw Error('Abstract method lastDealTime has no implementation');\n  }\n\n  /**\n   * Invoked when a new MetaTrader history order is added\n   * @param {String} instanceIndex index of an account instance connected\n   * @param {MetatraderOrder} historyOrder new MetaTrader history order\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onHistoryOrderAdded(instanceIndex, historyOrder) {\n    throw Error('Abstract method onHistoryOrderAdded has no implementation');\n  }\n\n  /**\n   * Invoked when a new MetaTrader history deal is added\n   * @param {String} instanceIndex index of an account instance connected\n   * @param {MetatraderDeal} deal new MetaTrader history deal\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onDealAdded(instanceIndex, deal) {\n    throw Error('Abstract method onDealAdded has no implementation');\n  }\n\n  /**\n   * Invoked when a synchronization of history deals on a MetaTrader account have finished to indicate progress of an\n   * initial terminal state synchronization\n   * @param {String} instanceIndex index of an account instance connected\n   * @param {String} synchronizationId synchronization request id\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onDealsSynchronized(instanceIndex, synchronizationId) {\n    const instance = this.getInstanceNumber(instanceIndex);\n    this._dealSynchronizationFinished['' + instance] = true;\n  }\n\n  /**\n   * Invoked when a synchronization of history orders on a MetaTrader account have finished to indicate progress of an\n   * initial terminal state synchronization\n   * @param {String} instanceIndex index of an account instance connected\n   * @param {String} synchronizationId synchronization request id\n   * @return {Promise} promise which resolves when the asynchronous event is processed\n   */\n  async onHistoryOrdersSynchronized(instanceIndex, synchronizationId) {\n    const instance = this.getInstanceNumber(instanceIndex);\n    this._orderSynchronizationFinished['' + instance] = true;\n  }\n\n  /**\n   * Invoked when connection to MetaTrader terminal established\n   * @param {String} instanceIndex index of an account instance connected\n   */\n  onConnected(instanceIndex) {\n    const instance = this.getInstanceNumber(instanceIndex);\n    this._orderSynchronizationFinished['' + instance] = false;\n    this._dealSynchronizationFinished['' + instance] = false;\n  }\n\n  /**\n   * Returns all deals\n   * @returns {Array<MetatraderDeal>} all deals\n   */\n  get deals() {\n    throw Error('Abstract property deals has no implementation');\n  }\n\n  /**\n   * Returns deals by ticket id\n   * @param {string} id ticket id\n   * @returns {Array<MetatraderDeal>} deals found\n   */\n  getDealsByTicket(id) {\n    throw Error('Abstract method getDealsByTicket has no implementation');\n  }\n\n  /**\n   * Returns deals by position id\n   * @param {string} positionId position id\n   * @returns {Array<MetatraderDeal>} deals found\n   */\n  getDealsByPosition(positionId) {\n    throw Error('Abstract method getDealsByPosition has no implementation');\n  }\n\n  /**\n   * Returns deals by time range\n   * @param startTime start time, inclusive\n   * @param endTime end time, inclusive\n   * @returns {Array<MetatraderDeal>} deals found\n   */\n  getDealsByTimeRange(startTime, endTime) {\n    throw Error('Abstract method getDealsByTimeRange has no implementation');\n  }\n\n  /**\n   * Returns all history orders\n   * @returns {Array<MetatraderOrder>} all history orders\n   */\n  get historyOrders() {\n    throw Error('Abstract property historyOrders has no implementation');\n  }\n\n  /**\n   * Returns history orders by ticket id\n   * @param {string} id ticket id\n   * @returns {Array<MetatraderOrder>} history orders found\n   */\n  getHistoryOrdersByTicket(id) {\n    throw Error('Abstract method getHistoryOrdersByTicket has no implementation');\n  }\n\n  /**\n   * Returns history orders by position id\n   * @param {string} positionId position id\n   * @returns {Array<MetatraderOrder>} history orders found\n   */\n  getHistoryOrdersByPosition(positionId) {\n    throw Error('Abstract method getHistoryOrdersByPosition has no implementation');\n  }\n\n  /**\n   * Returns history orders by time range\n   * @param startTime start time, inclusive\n   * @param endTime end time, inclusive\n   * @returns {Array<MetatraderOrder>} hisotry orders found\n   */\n  getHistoryOrdersByTimeRange(startTime, endTime) {\n    throw Error('Abstract method getHistoryOrdersByTimeRange has no implementation');\n  }\n\n}\n"],"names":["SynchronizationListener","HistoryStorage","initialize","accountId","application","_accountId","_application","orderSynchronizationFinished","Object","values","_orderSynchronizationFinished","reduce","acc","r","dealSynchronizationFinished","_dealSynchronizationFinished","clear","Error","lastHistoryOrderTime","instanceIndex","lastDealTime","onHistoryOrderAdded","historyOrder","onDealAdded","deal","onDealsSynchronized","synchronizationId","instance","getInstanceNumber","onHistoryOrdersSynchronized","onConnected","deals","getDealsByTicket","id","getDealsByPosition","positionId","getDealsByTimeRange","startTime","endTime","historyOrders","getHistoryOrdersByTicket","getHistoryOrdersByPosition","getHistoryOrdersByTimeRange","constructor"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,OAAOA,6BAA6B,6CAA6C;AAKlE,IAAA,AAAMC,iBAAN,MAAMA,uBAAuBD;IAW1C;;;;;GAKC,GACD,AAAME,WAAWC,SAAS,EAAEC,WAAW;;eAAvC,oBAAA;YACE,MAAKC,UAAU,GAAGF;YAClB,MAAKG,YAAY,GAAGF;QACtB;;IAEA;;;GAGC,GACD,IAAIG,+BAA+B;QACjC,OAAOC,OAAOC,MAAM,CAAC,IAAI,CAACC,6BAA6B,EAAEC,MAAM,CAAC,CAACC,KAAKC,IAAMD,OAAOC,GAAG;IACxF;IAEA;;;GAGC,GACD,IAAIC,8BAA8B;QAChC,OAAON,OAAOC,MAAM,CAAC,IAAI,CAACM,4BAA4B,EAAEJ,MAAM,CAAC,CAACC,KAAKC,IAAMD,OAAOC,GAAG;IACvF;IAEA;;;GAGC,GACD,AAAMG;eAAN,oBAAA;YACE,MAAMC,MAAM;QACd;;IAEA;;;;GAIC,GACD,AAAMC,qBAAqBC,aAAa;eAAxC,oBAAA;YACE,MAAMF,MAAM;QACd;;IAEA;;;;GAIC,GACD,AAAMG,aAAaD,aAAa;eAAhC,oBAAA;YACE,MAAMF,MAAM;QACd;;IAEA;;;;;GAKC,GACD,AAAMI,oBAAoBF,aAAa,EAAEG,YAAY;eAArD,oBAAA;YACE,MAAML,MAAM;QACd;;IAEA;;;;;GAKC,GACD,AAAMM,YAAYJ,aAAa,EAAEK,IAAI;eAArC,oBAAA;YACE,MAAMP,MAAM;QACd;;IAEA;;;;;;GAMC,GACD,AAAMQ,oBAAoBN,aAAa,EAAEO,iBAAiB;;eAA1D,oBAAA;YACE,MAAMC,WAAW,MAAKC,iBAAiB,CAACT;YACxC,MAAKJ,4BAA4B,CAAC,KAAKY,SAAS,GAAG;QACrD;;IAEA;;;;;;GAMC,GACD,AAAME,4BAA4BV,aAAa,EAAEO,iBAAiB;;eAAlE,oBAAA;YACE,MAAMC,WAAW,MAAKC,iBAAiB,CAACT;YACxC,MAAKT,6BAA6B,CAAC,KAAKiB,SAAS,GAAG;QACtD;;IAEA;;;GAGC,GACDG,YAAYX,aAAa,EAAE;QACzB,MAAMQ,WAAW,IAAI,CAACC,iBAAiB,CAACT;QACxC,IAAI,CAACT,6BAA6B,CAAC,KAAKiB,SAAS,GAAG;QACpD,IAAI,CAACZ,4BAA4B,CAAC,KAAKY,SAAS,GAAG;IACrD;IAEA;;;GAGC,GACD,IAAII,QAAQ;QACV,MAAMd,MAAM;IACd;IAEA;;;;GAIC,GACDe,iBAAiBC,EAAE,EAAE;QACnB,MAAMhB,MAAM;IACd;IAEA;;;;GAIC,GACDiB,mBAAmBC,UAAU,EAAE;QAC7B,MAAMlB,MAAM;IACd;IAEA;;;;;GAKC,GACDmB,oBAAoBC,SAAS,EAAEC,OAAO,EAAE;QACtC,MAAMrB,MAAM;IACd;IAEA;;;GAGC,GACD,IAAIsB,gBAAgB;QAClB,MAAMtB,MAAM;IACd;IAEA;;;;GAIC,GACDuB,yBAAyBP,EAAE,EAAE;QAC3B,MAAMhB,MAAM;IACd;IAEA;;;;GAIC,GACDwB,2BAA2BN,UAAU,EAAE;QACrC,MAAMlB,MAAM;IACd;IAEA;;;;;GAKC,GACDyB,4BAA4BL,SAAS,EAAEC,OAAO,EAAE;QAC9C,MAAMrB,MAAM;IACd;IA1LA;;GAEC,GACD0B,aAAc;QACZ,KAAK;QACL,IAAI,CAACjC,6BAA6B,GAAG,CAAC;QACtC,IAAI,CAACK,4BAA4B,GAAG,CAAC;IACvC;AAqLF;AAjMA;;CAEC,GACD,SAAqBd,4BA8LpB"}