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)
168 lines (167 loc) • 20.5 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return HistoryStorage;
}
});
const _synchronizationListener = /*#__PURE__*/ _interop_require_default(require("../clients/metaApi/synchronizationListener"));
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
let HistoryStorage = class HistoryStorage extends _synchronizationListener.default {
/**
* 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
*/ async initialize(accountId, application) {
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
*/ async clear() {
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
*/ async lastHistoryOrderTime(instanceIndex) {
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
*/ async lastDealTime(instanceIndex) {
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
*/ async onHistoryOrderAdded(instanceIndex, historyOrder) {
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
*/ async onDealAdded(instanceIndex, deal) {
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
*/ async onDealsSynchronized(instanceIndex, synchronizationId) {
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
*/ async onHistoryOrdersSynchronized(instanceIndex, synchronizationId) {
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 = {};
}
};
//# 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":["HistoryStorage","SynchronizationListener","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;;;;;;;eAOqBA;;;gFALe;;;;;;AAKrB,IAAA,AAAMA,iBAAN,MAAMA,uBAAuBC,gCAAuB;IAWjE;;;;;GAKC,GACD,MAAMC,WAAWC,SAAS,EAAEC,WAAW,EAAE;QACvC,IAAI,CAACC,UAAU,GAAGF;QAClB,IAAI,CAACG,YAAY,GAAGF;IACtB;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,MAAMG,QAAQ;QACZ,MAAMC,MAAM;IACd;IAEA;;;;GAIC,GACD,MAAMC,qBAAqBC,aAAa,EAAE;QACxC,MAAMF,MAAM;IACd;IAEA;;;;GAIC,GACD,MAAMG,aAAaD,aAAa,EAAE;QAChC,MAAMF,MAAM;IACd;IAEA;;;;;GAKC,GACD,MAAMI,oBAAoBF,aAAa,EAAEG,YAAY,EAAE;QACrD,MAAML,MAAM;IACd;IAEA;;;;;GAKC,GACD,MAAMM,YAAYJ,aAAa,EAAEK,IAAI,EAAE;QACrC,MAAMP,MAAM;IACd;IAEA;;;;;;GAMC,GACD,MAAMQ,oBAAoBN,aAAa,EAAEO,iBAAiB,EAAE;QAC1D,MAAMC,WAAW,IAAI,CAACC,iBAAiB,CAACT;QACxC,IAAI,CAACJ,4BAA4B,CAAC,KAAKY,SAAS,GAAG;IACrD;IAEA;;;;;;GAMC,GACD,MAAME,4BAA4BV,aAAa,EAAEO,iBAAiB,EAAE;QAClE,MAAMC,WAAW,IAAI,CAACC,iBAAiB,CAACT;QACxC,IAAI,CAACT,6BAA6B,CAAC,KAAKiB,SAAS,GAAG;IACtD;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"}