metaapi.cloud-copyfactory-sdk
Version:
Javascript SDK for SDK for CopyFactory trade copying API. Can copy trades both between MetaTrader 5 (MT5) and MetaTrader 4 (MT4). (https://metaapi.cloud)
344 lines (322 loc) • 12.7 kB
text/typescript
'use strict';
import MetaApiClient from '../metaapi.client';
import SubscriberSignalClient from './subscriberSignal.client';
import StrategySignalClient from './strategySignal.client';
import StopoutListenerManager from './streaming/stopoutListenerManager';
import UserLogListenerManager from './streaming/userLogListenerManager';
import ConfigurationClient from './configuration.client';
import DomainClient from '../domain.client';
import StopoutListener from './streaming/stopoutListener';
import UserLogListener from './streaming/userLogListener';
import {
CopyFactoryStrategyStopout, CopyFactoryStrategyStopoutReason, CopyFactoryUserLogMessage
} from './trading.client.schemas';
export * from './trading.client.schemas';
/**
* metaapi.cloud CopyFactory trading API (trade copying trading API) client (see
* https://metaapi.cloud/docs/copyfactory/)
*/
export default class TradingClient extends MetaApiClient {
private _configurationClient: ConfigurationClient;
private _stopoutListenerManager: StopoutListenerManager;
private _userLogListenerManager: UserLogListenerManager;
/**
* Constructs CopyFactory trading API client instance
* @param {DomainClient} domainClient domain client
* @param {ConfigurationClient} configurationClient configuration client
*/
constructor(domainClient: DomainClient, configurationClient: ConfigurationClient) {
super(domainClient);
this._domainClient = domainClient;
this._configurationClient = configurationClient;
this._stopoutListenerManager = new StopoutListenerManager(domainClient);
this._userLogListenerManager = new UserLogListenerManager(domainClient);
}
/**
* Resynchronizes the account. See
* https://metaapi.cloud/docs/copyfactory/restApi/api/trading/resynchronize/
* @param {string} accountId account id
* @param {Array<string>} [strategyIds] array of strategy ids to recynchronize. Default is to synchronize all
* strategies
* @param {Array<string>} [positionIds] array of position ids to resynchronize. Default is to synchronize all
* positions
* @return {Promise} promise which resolves when resynchronization is scheduled
*/
async resynchronize(accountId: string, strategyIds?: Array<string>, positionIds?: Array<string>): Promise<any> {
if (this._isNotJwtToken()) {
return this._handleNoAccessError('resynchronize');
}
const opts = {
url: `/users/current/subscribers/${accountId}/resynchronize`,
method: 'POST',
headers: {
'auth-token': this._token
},
params: {
strategyId: strategyIds,
positionId: positionIds
},
json: true
};
return this._domainClient.requestCopyFactory(opts);
}
/**
* Generates an instance of signal client for a subscriber
* @param {string} subscriberId subscriber account id
*/
async getSubscriberSignalClient(subscriberId: string): Promise<SubscriberSignalClient> {
if (this._isNotJwtToken()) {
return this._handleNoAccessError('getSubscriberSignalClient');
}
let accountData = await this._domainClient.getAccountInfo(subscriberId);
const host = await this._domainClient.getSignalClientHost(accountData.regions);
return new SubscriberSignalClient(accountData.id, host, this._domainClient);
}
/**
* Generates an instance of signal client for a strategy
* @param {string} strategyId strategy id
*/
async getStrategySignalClient(strategyId: string): Promise<StrategySignalClient> {
if (this._isNotJwtToken()) {
return this._handleNoAccessError('getStrategySignalClient');
}
const strategy = await this._configurationClient.getStrategy(strategyId);
const accountData = await this._domainClient.getAccountInfo(strategy.accountId);
const host = await this._domainClient.getSignalClientHost(accountData.regions);
return new StrategySignalClient(accountData.id, strategyId, host, this._domainClient);
}
/**
* Returns subscriber account stopouts. See
* https://metaapi.cloud/docs/copyfactory/restApi/api/trading/getStopOuts/
* @param {string} subscriberId subscriber id
* @return {Promise<Array<CopyFactoryStrategyStopout>>} promise which resolves with stopouts found
*/
async getStopouts(subscriberId: string): Promise<Array<CopyFactoryStrategyStopout>> {
if (this._isNotJwtToken()) {
return this._handleNoAccessError('getStopouts');
}
const opts = {
url: `/users/current/subscribers/${subscriberId}/stopouts`,
method: 'GET',
headers: {
'auth-token': this._token
},
json: true
};
return this._domainClient.requestCopyFactory(opts);
}
/**
* Resets subscription stopouts. See
* https://metaapi.cloud/docs/copyfactory/restApi/api/trading/resetSubscriptionStopOuts/
* @param {string} subscriberId subscriber id
* @param {string} strategyId strategy id
* @param {CopyFactoryStrategyStopoutReason} reason stopout reason to reset
* yearly-equity, monthly-equity, daily-equity
* @return {Promise} promise which resolves when the stopouts are reset
*/
resetSubscriptionStopouts(
subscriberId: string, strategyId: string, reason: CopyFactoryStrategyStopoutReason
): Promise<any> {
if (this._isNotJwtToken()) {
return this._handleNoAccessError('resetSubscriptionStopouts');
}
const opts = {
url: `/users/current/subscribers/${subscriberId}/subscription-strategies/` +
`${strategyId}/stopouts/${reason}/reset`,
method: 'POST',
headers: {
'auth-token': this._token
},
json: true
};
return this._domainClient.requestCopyFactory(opts);
}
/**
* Resets subscriber stopouts. See
* https://metaapi.cloud/docs/copyfactory/restApi/api/trading/resetSubscriberStopOuts/
* @param {string} subscriberId subscriber id
* @param {CopyFactoryStrategyStopoutReason} reason stopout reason to reset
* yearly-equity, monthly-equity, daily-equity
* @return {Promise} promise which resolves when the stopouts are reset
*/
resetSubscriberStopouts(subscriberId: string, reason: CopyFactoryStrategyStopoutReason): Promise<any> {
if (this._isNotJwtToken()) {
return this._handleNoAccessError('resetSubscriberStopouts');
}
const opts = {
url: `/users/current/subscribers/${subscriberId}/stopouts/${reason}/reset`,
method: 'POST',
headers: {
'auth-token': this._token
},
json: true
};
return this._domainClient.requestCopyFactory(opts);
}
/**
* Returns copy trading user log for an account and time range. See
* https://metaapi.cloud/docs/copyfactory/restApi/api/trading/getUserLog/
* @param {string} subscriberId subscriber id
* @param {Date} [startTime] time to start loading data from
* @param {Date} [endTime] time to stop loading data at
* @param {string} [strategyId] strategy id filter
* @param {string} [positionId] position id filter
* @param {'DEBUG'|'INFO'|'WARN'|'ERROR'} [level] minimum severity level
* @param {Number} [offset] pagination offset. Default is 0
* @param {Number} [limit] pagination limit. Default is 1000
* @return {Promise<Array<CopyFactoryUserLogMessage>>} promise which resolves with log records found
*/
async getUserLog(
subscriberId: string, startTime?: Date, endTime?: Date, strategyId?: string, positionId?: string,
level?: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR', offset = 0, limit = 1000
): Promise<Array<CopyFactoryUserLogMessage>> {
if (this._isNotJwtToken()) {
return this._handleNoAccessError('getUserLog');
}
const opts = {
url: `/users/current/subscribers/${subscriberId}/user-log`,
method: 'GET',
params: {
startTime,
endTime,
strategyId,
positionId,
level,
offset,
limit
},
headers: {
'auth-token': this._token
},
json: true
};
let result = await this._domainClient.requestCopyFactory(opts, true);
if (result) {
result.map(r => r.time = new Date(r.time));
}
return result;
}
/**
* Returns event log for CopyFactory strategy, sorted in reverse chronological order. See
* https://metaapi.cloud/docs/copyfactory/restApi/api/trading/getStrategyLog/
* @param {string} strategyId strategy id to retrieve log for
* @param {Date} [startTime] time to start loading data from
* @param {Date} [endTime] time to stop loading data at
* @param {string} [positionId] position id filter
* @param {'DEBUG'|'INFO'|'WARN'|'ERROR'} [level] minimum severity level
* @param {Number} [offset] pagination offset. Default is 0
* @param {Number} [limit] pagination limit. Default is 1000
* @return {Promise<Array<CopyFactoryUserLogMessage>>} promise which resolves with log records found
*/
async getStrategyLog(
strategyId: string, startTime?: Date, endTime?: Date, positionId?: string,
level?: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR', offset = 0, limit = 1000
): Promise<Array<CopyFactoryUserLogMessage>> {
if (this._isNotJwtToken()) {
return this._handleNoAccessError('getStrategyLog');
}
const opts = {
url: `/users/current/strategies/${strategyId}/user-log`,
method: 'GET',
params: {
startTime,
endTime,
positionId,
level,
offset,
limit
},
headers: {
'auth-token': this._token
},
json: true
};
let result = await this._domainClient.requestCopyFactory(opts, true);
if (result) {
result.map(r => r.time = new Date(r.time));
}
return result;
}
/**
* Adds a stopout listener and creates a job to make requests
* @param {StopoutListener} listener stopout listener
* @param {string} [accountId] account id
* @param {string} [strategyId] strategy id
* @param {Number} [sequenceNumber] sequence number
* @return {string} listener id
*/
addStopoutListener(
listener: StopoutListener, accountId?: string, strategyId?: string, sequenceNumber?: number
): string {
return this._stopoutListenerManager.addStopoutListener(listener, accountId, strategyId, sequenceNumber);
}
/**
* Removes stopout listener and cancels the event stream
* @param {string} listenerId stopout listener id
*/
removeStopoutListener(listenerId: string): void {
this._stopoutListenerManager.removeStopoutListener(listenerId);
}
/**
* Adds a strategy log listener and creates a job to make requests
* @param {UserLogListener} listener user log listener
* @param {string} strategyId strategy id
* @param {Date} [startTime] log search start time
* @param {string} [positionId] position id filter
* @param {'DEBUG'|'INFO'|'WARN'|'ERROR'} [level] minimum severity level
* @param {Number} [limit] log pagination limit
* @return {string} listener id
*/
addStrategyLogListener(
listener: UserLogListener, strategyId: string, startTime?: Date, positionId?: string,
level?: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR', limit?: number
): string {
return this._userLogListenerManager.addStrategyLogListener(
listener,
strategyId,
startTime,
positionId,
level,
limit
);
}
/**
* Removes strategy log listener and cancels the event stream
* @param {string} listenerId strategy log listener id
*/
removeStrategyLogListener(listenerId: string): void {
this._userLogListenerManager.removeStrategyLogListener(listenerId);
}
/**
* Adds a subscriber log listener and creates a job to make requests
* @param {UserLogListener} listener user log listener
* @param {string} subscriberId subscriber id
* @param {Date} [startTime] log search start time
* @param {string} [strategyId] strategy id filter
* @param {string} [positionId] position id filter
* @param {'DEBUG'|'INFO'|'WARN'|'ERROR'} [level] minimum severity level
* @param {Number} [limit] log pagination limit
* @return {string} listener id
*/
addSubscriberLogListener(
listener: UserLogListener, subscriberId: string, startTime?: Date, strategyId?: string, positionId?: string,
level?: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR', limit?: number
): string {
return this._userLogListenerManager.addSubscriberLogListener(
listener,
subscriberId,
startTime,
strategyId,
positionId,
level,
limit
);
}
/**
* Removes subscriber log listener and cancels the event stream
* @param {string} listenerId subscriber log listener id
*/
removeSubscriberLogListener(listenerId: string): void {
this._userLogListenerManager.removeSubscriberLogListener(listenerId);
}
}