IReadOnlyList <int> IMT4ServerConnectorHost.GetAllMT4Logins(eMT4ServerType serverIndex)
{
lock (_mt4LoginsByServerIndex)
return(_mt4LoginsByServerIndex.TryGetValue(serverIndex, out var mt4Logins)
? mt4Logins.ToArray()
: Array.Empty <int>());
}
public MT4UpdateWorker(
eMT4ServerType serverIndex, ILogger logger, Func <eMT4ServerType, MT4Connection> connectionFactory,
IMT4ServerConnectorHost host)
: base(logger)
{
_serverIndex = serverIndex;
_connection = connectionFactory(serverIndex);
_name = (serverIndex == eMT4ServerType.SRV_TYPE_DEMO ? "Demo" : "Live") + "." + GetType().Name;
m_ptrLogger = new ServerLogger(logger, _name);
_host = host;
}
void IMT4ServerConnectorHost.OnMargin(eMT4ServerType serverIndex, MarginLevel ptrLevel)
{
try
{
OnMarginAsync(serverIndex, ptrLevel, CancellationToken.None).Wait();
}
catch (Exception exception)
{
m_ptrLogger.LogException(exception);
}
}
void IMT4ServerConnectorHost.OnTrade(
eMT4ServerType serverIndex, TradeRecord ptrTrade, TransType transType)
{
try
{
_orderManager.Value.OnTradeAsync(serverIndex, ptrTrade, transType, CancellationToken.None).Wait();
}
catch (Exception exception)
{
m_ptrLogger.LogException(exception);
}
}
public MT4Connection(
eMT4ServerType serverIndex, ILogger logger, MT4Manager mt4Manager,
MasterUserSettingService masterSettingsService)
{
_serverIndex = serverIndex;
_baseLogger = logger;
_mt4Manager = mt4Manager;
_masterSettingsService = masterSettingsService;
//_api = _mt4Manager.CreateApi();
//Debug.Assert(_api != null);
//if (_api == null)
// throw new InvalidOperationException();
}
public WitFXServerConnector GetConnector(eMT4ServerType serverIndex)
{
switch (serverIndex)
{
case eMT4ServerType.SRV_TYPE_DEMO:
return(Demo);
case eMT4ServerType.SRV_TYPE_LIVE:
return(Live);
default:
throw new ArgumentOutOfRangeException(nameof(serverIndex), serverIndex, null);
}
}
/// <summary>
/// WitFXMT4ServerBL.onMarketData
/// </summary>
void IMT4ServerConnectorHost.OnMarketData(eMT4ServerType serverIndex, IReadOnlyList <SymbolInfo> symbols)
{
if (serverIndex == eMT4ServerType.SRV_TYPE_DEMO)
{
try
{
_marketDataService.Put(symbols);
_marketDataWorker.Enqueue(symbols);
}
catch (Exception exception)
{
m_ptrLogger.LogException(exception);
}
}
}
private void AddMt4LoginNoLock(eMT4ServerType serverIndex, int mt4Login)
{
Debug.Assert(mt4Login > 0);
if (mt4Login <= 0)
{
return;
}
if (!_mt4LoginsByServerIndex.TryGetValue(serverIndex, out var mt4Logins))
{
_mt4LoginsByServerIndex.Add(serverIndex, mt4Logins = new HashSet <int>());
}
mt4Logins.Add(mt4Login);
}
void IMT4ServerConnectorHost.OnSymbolInfo(
eMT4ServerType serverIndex, IReadOnlyList <ConSymbolGroup> ptrSecurityArr,
IReadOnlyList <ConSymbol> ptrSymbolArr)
{
if (serverIndex == eMT4ServerType.SRV_TYPE_DEMO)
{
try
{
OnSymbolInfoAsync(ptrSecurityArr, ptrSymbolArr, CancellationToken.None).Wait();
}
catch (Exception exception)
{
m_ptrLogger.LogException(exception);
}
}
}
void IMT4ServerConnectorHost.OnResponse(
ReturnCode errorcode, string errormessage, eMT4ServerType serverIndex, MT4REQ reqType,
eOrderStatus trans_status, int masterLogin, /*int orderOrLogin,*/ Guid server_trans_id,
eAccountType accType, MT4REQMODE reqMode, MT4Request request)
{
try
{
OnResponseAsync(
errorcode, errormessage, serverIndex, reqType,
trans_status, masterLogin, /*orderOrLogin,*/ server_trans_id,
accType, reqMode, request, CancellationToken.None).Wait();
}
catch (Exception exception)
{
m_ptrLogger.LogException(exception);
}
}
/// <summary>
/// WitFXMT4ServerBL.onMarginLevelResponse
/// </summary>
private async Task OnMarginAsync(eMT4ServerType serverIndex, MarginLevel ptrMargin, CancellationToken cancellationToken)
{
int masterLogin = await _mt4AccountService.GetCachedMasterLoginAsync(serverIndex, ptrMargin.login, cancellationToken);
if (masterLogin > 0)
{
var ptr = new MT4MarginResponse(); // MT_MT4MarginResponse_ID
ptr._marginInfo = new MT4AccountStatus();
ptr._marginInfo._balance = ptrMargin.balance;
ptr._marginInfo._equity = ptrMargin.equity;
ptr._marginInfo._freeMargin = ptrMargin.margin_free;
ptr._marginInfo._margin = ptrMargin.margin;
ptr._marginInfo._marginLevel = ptrMargin.margin_level;
ptr._marginInfo._mt4ServerIndex = serverIndex;
ptr._marginInfo._mt4Login = ptrMargin.login;
_connectionMgr.SentDataUsingLoginID(ptr, MessageTypeID.MT_MT4MarginResponse_ID, masterLogin);
}
}
/// <summary>
/// WitFXMT4ServerBL.onMT4Response
/// </summary>
private async Task OnResponseAsync(
ReturnCode errorcode, string errormessage, eMT4ServerType serverIndex, MT4REQ reqType,
eOrderStatus trans_status, int masterLogin, /*int orderOrLogin,*/ Guid server_trans_id,
eAccountType accType, MT4REQMODE reqMode, MT4Request request, CancellationToken cancellationToken)
{
Debug.Assert(masterLogin > 0);
//m_ptrMySqlWrapper.insertLog(Utilities.LOG_INFO,masterLogin,orderOrLogin,"X",)
if (reqType == MT4REQ.MT4REQ_NEW_ACCOUNT)
{
var mt4Login = request.User?.login ?? 0;
if (trans_status == eOrderStatus.ORD_STAT_EXECUTED)
{
Debug.Assert(mt4Login > 0);
m_ptrLogger.LogInfo($"EXECUTED : MT4 Account {mt4Login}, master Login {masterLogin}, AccountType: {accType}");
MT4Account acc = new MT4Account();
//memset(&acc, 0, sizeof(MT4Account));
acc._accountType = accType;
acc._masterLogin = masterLogin;
acc._mt4Login = mt4Login;
acc._mt4ServerIndex = serverIndex;
//if (serverIndex == SRV_TYPE_DEMO)
//{
// Demo.insertMT4Account(orderOrLogin);
//}
//else
//{
// Live.insertMT4Account(orderOrLogin);
//}
lock (_mt4LoginsByServerIndex)
AddMt4LoginNoLock(serverIndex, mt4Login);
await _mt4AccountService.InsertMT4Account(acc, cancellationToken);
//if (!)
//{
// m_ptrLogger.LogError("Unable to insert MT4 account for masterlogin: %d MT4 Login: %d in database", masterLogin, orderOrLogin);
//}
//else
//{
#region Rebate
//TODO: Claudia: rebate
//if (accType == ACC_TYPE_REBATE)
//{
// Dictionary<int, int>.iterator it2;
// //lock (m_SyncMapMt4Master)
// //{
// it2 = m_mapMasterRebateAcc.find(masterLogin);
// if (it2 == m_mapMasterRebateAcc.end())
// {
// m_mapMasterRebateAcc.insert(new ValueTuple<int, int>(masterLogin, orderOrLogin));
// }
// //}
//}
#endregion
////else //if (accType != ACC_TYPE_REBATE)
////{
//Dictionary<bool, Dictionary<int, int>>.iterator it1;
////Dictionary<int, int>.iterator it2;
////lock (m_SyncMapMt4Master)
////{
//bool isDemoServer = serverIndex == SRV_TYPE_DEMO ? true : false;
//it1 = m_mapMT4MasterLogin.find(isDemoServer);
//if (it1 == m_mapMT4MasterLogin.end())
//{
// Dictionary<int, int> mp2 = new Dictionary<int, int>();
// m_mapMT4MasterLogin.insert(new ValueTuple<bool, Dictionary<int, int>>(isDemoServer, mp2));
// it1 = m_mapMT4MasterLogin.find(isDemoServer);
//}
//it1.second.insert(new ValueTuple<int, int>(orderOrLogin, masterLogin));
////}
////}
////}
if (accType == eAccountType.ACC_TYPE_SSP)
{
await _signalService.UpdateSignalMT4Login(server_trans_id, mt4Login, cancellationToken);
await _signalService.UpdateSSPSignalMT4Login(server_trans_id, mt4Login, cancellationToken);
//fetchAllSignal();
//fetchAllSSPSignal();
//fetchAllSMSignal();
//insertDBTransmitData(masterLogin, FDMT_Signal_ID);
//insertDBTransmitData(masterLogin, FDMT_SSPSignal_ID);
}
else if (accType == eAccountType.ACC_TYPE_SM)
{
await _signalService.UpdateSignalMT4Login(server_trans_id, mt4Login, cancellationToken);
await _signalService.UpdateSMSignalMT4Login(server_trans_id, mt4Login, cancellationToken);
//fetchAllSignal();
//fetchAllSSPSignal();
//fetchAllSMSignal();
//insertDBTransmitData(masterLogin, FDMT_Signal_ID);
//insertDBTransmitData(masterLogin, FDMT_SMSignal_ID);
}
var m_masterUserSetting = await _masterSettingsService.GetCachedMasterSettingsAsync(cancellationToken);
if (accType == eAccountType.ACC_TYPE_FOLLOWER_DEMO || accType == eAccountType.ACC_TYPE_SSP || accType == eAccountType.ACC_TYPE_SM)
{
MT4Request ptrMT4Req4 = (MT4Request) new MT4Request();
//memset(ptrMT4Req4, 0, sizeof(MT4Request));
//ptrMT4Req4.newLoginOrOrderID = orderOrLogin; // Alexey
ptrMT4Req4.masterLogin = masterLogin;
ptrMT4Req4.reqType = MT4REQ.MT4REQ_BALANCE;
//ptrMT4Req4.socketID = socketID;
ptrMT4Req4.status = eOrderStatus.ORD_STAT_RECVD;
ptrMT4Req4.serverTransID = TransactionService.NewTransactionId();
ptrMT4Req4.ptrData = new MT4OrderInfo();
//memset(ptrMT4Req4.ptrData, 0, sizeof(MT4OrderInfo));
MT4OrderInfo ptrOrd = (MT4OrderInfo)ptrMT4Req4.ptrData;
ptrOrd._accountType = accType;
ptrOrd._masterLogin = masterLogin;
ptrOrd._mt4Login = mt4Login;
ptrOrd._mt4ServerIndex = serverIndex;
ptrOrd._orderTransMode = eMT4OrderTransMode.ORD_TRANS_CLOSE;
ptrOrd._orderType = eMT4OrderType.ORD_TYPE_BALANCE;
ptrOrd._price = request.deposit;
if (ptrOrd._price == 0)
{
if (accType == eAccountType.ACC_TYPE_FOLLOWER_DEMO)
{
ptrOrd._price = m_masterUserSetting._deposit_followerDemo;
}
else if (accType == eAccountType.ACC_TYPE_SSP)
{
ptrOrd._price = m_masterUserSetting._deposit_SSP;
}
else if (accType == eAccountType.ACC_TYPE_SM)
{
ptrOrd._price = m_masterUserSetting._deposit_SM;
}
}
Demo.insertMT4Request(ptrMT4Req4);
}
else if (accType == eAccountType.ACC_TYPE_FOLLOWER_LIVE)
{
MT4Request ptrMT4Req4 = (MT4Request) new MT4Request();
//memset(ptrMT4Req4, 0, sizeof(MT4Request));
//ptrMT4Req4.newLoginOrOrderID = orderOrLogin; // Alexey
ptrMT4Req4.masterLogin = masterLogin;
ptrMT4Req4.reqType = MT4REQ.MT4REQ_BALANCE;
//ptrMT4Req4.socketID = socketID;
ptrMT4Req4.status = eOrderStatus.ORD_STAT_RECVD;
ptrMT4Req4.serverTransID = TransactionService.NewTransactionId();
ptrMT4Req4.ptrData = new MT4OrderInfo();
//memset(ptrMT4Req4.ptrData, 0, sizeof(MT4OrderInfo));
MT4OrderInfo ptrOrd = (MT4OrderInfo)ptrMT4Req4.ptrData;
ptrOrd._accountType = accType;
ptrOrd._masterLogin = masterLogin;
ptrOrd._mt4Login = mt4Login;
ptrOrd._mt4ServerIndex = serverIndex;
ptrOrd._orderTransMode = eMT4OrderTransMode.ORD_TRANS_CLOSE;
ptrOrd._orderType = eMT4OrderType.ORD_TYPE_BALANCE;
ptrOrd._price = request.deposit;
if (ptrOrd._price == 0)
{
ptrOrd._price = m_masterUserSetting._deposit_followerLive;
}
Live.insertMT4Request(ptrMT4Req4);
}
var ptrResp = new MT4AccountResponse(); //MT_MT4AccountResponse_ID
CppHelper.memcpy(ref ptrResp._account, acc);
_connectionMgr.SentDataUsingLoginID(ptrResp, MessageTypeID.MT_MT4AccountResponse_ID, masterLogin);
}
else if (trans_status == eOrderStatus.ORD_STAT_PROCESSING)
{
// Claudia: it's normal that orderOrLogin parameter is 0, because MT4 is still processing the request
Debug.Assert(masterLogin > 0);
m_ptrLogger.LogInfo("PROCESSING : MT4 Account %d master Login %d AccountType: %d", mt4Login, masterLogin, accType);
var ptrResp = new SocialOrderResponse(); //MT_SocialOrderResponse_ID
ptrResp._serverTransID = server_trans_id;
ptrResp._requestMode = reqMode;
ptrResp._retCode = (eReturnCode)trans_status;
//SentDataUsingSocketID(ptrResp, MT_SocialOrderResponse_ID, socketID);
_connectionMgr.SentDataUsingLoginID(ptrResp, MessageTypeID.MT_SocialOrderResponse_ID, masterLogin);
}
else if (trans_status == eOrderStatus.ORD_STAT_REJECTED)
{
// Claudia: it's normal that orderOrLogin parameter is 0, because MT4 is still processing the request
Debug.Assert(masterLogin > 0);
m_ptrLogger.LogInfo("REJECTED : MT4 Account %d master Login %d AccountType: %d", mt4Login, masterLogin, accType);
if (accType == eAccountType.ACC_TYPE_SSP)
{
await _signalService.UpdateSignalMT4Login(server_trans_id, mt4Login, cancellationToken, isRemove : true);
await _signalService.UpdateSSPSignalMT4Login(server_trans_id, mt4Login, cancellationToken, isRemove : true);
}
if (accType == eAccountType.ACC_TYPE_SM)
{
await _signalService.UpdateSignalMT4Login(server_trans_id, mt4Login, cancellationToken, isRemove : true);
await _signalService.UpdateSMSignalMT4Login(server_trans_id, mt4Login, cancellationToken, isRemove : true);
}
var ptrResp = new SocialOrderResponse(); //MT_SocialOrderResponse_ID
ptrResp._serverTransID = server_trans_id;
ptrResp._requestMode = reqMode;
ptrResp._retCode = (eReturnCode)trans_status;
ptrResp._mt4errorcode = errorcode;
CppHelper.strcpy(out ptrResp._mt4errormessage, errormessage);
//SentDataUsingSocketID(ptrResp, MT_SocialOrderResponse_ID, socketID);
_connectionMgr.SentDataUsingLoginID(ptrResp, MessageTypeID.MT_SocialOrderResponse_ID, masterLogin);
}
//insertDBTransmitData(masterLogin, FDMT_MasterUser_ID);
//insertDBTransmitData(masterLogin, FDMT_MT4Account_ID);
//insertDBTransmitData(masterLogin, FDMT_SSPSignal_ID);
//insertDBTransmitData(masterLogin, FDMT_SSPSignal_ID);
}
else
{
var orderId = request.OrderInfo?._orderID ?? 0;
if (trans_status == eOrderStatus.ORD_STAT_PROCESSING)
{
// Alexey: it's normal that orderOrLogin parameter is 0, because MT4 is still processing the request
Debug.Assert(masterLogin > 0 && server_trans_id != Guid.Empty);
m_ptrLogger.LogInfo($"PROCESSING : Order {orderId}, master Login {masterLogin}, UID: {server_trans_id}");
var ptrResp = new SocialOrderResponse(); //MT_SocialOrderResponse_ID
ptrResp._serverTransID = server_trans_id;
ptrResp._requestMode = reqMode;
ptrResp._retCode = (eReturnCode)trans_status;
//SentDataUsingSocketID(ptrResp, MT_SocialOrderResponse_ID, socketID);
_connectionMgr.SentDataUsingLoginID(ptrResp, MessageTypeID.MT_SocialOrderResponse_ID, masterLogin);
}
else if (trans_status == eOrderStatus.ORD_STAT_REJECTED)
{
// Alexey: it's normal that orderOrLogin parameter is 0, because MT4 is still processing the request
Debug.Assert(masterLogin > 0 && server_trans_id != Guid.Empty);
m_ptrLogger.LogInfo($"REJECTED : Order {orderId}, master Login {masterLogin}, UID: {server_trans_id}");
var ptrResp = new SocialOrderResponse(); //MT_SocialOrderResponse_ID
ptrResp._serverTransID = server_trans_id;
ptrResp._requestMode = reqMode;
ptrResp._retCode = (eReturnCode)trans_status;
ptrResp._mt4errorcode = errorcode;
CppHelper.strcpy(out ptrResp._mt4errormessage, errormessage);
//SentDataUsingSocketID(ptrResp, MT_SocialOrderResponse_ID, socketID);
_connectionMgr.SentDataUsingLoginID(ptrResp, MessageTypeID.MT_SocialOrderResponse_ID, masterLogin);
}
else if (trans_status == eOrderStatus.ORD_STAT_EXECUTED)
{
if (reqMode == MT4REQMODE.OPEN_TRADE)
{
Debug.Assert(server_trans_id != Guid.Empty && orderId > 0 && request.Order != null && request.Order.OrderId == 0);
request.Order.OrderId = orderId;
await _orderService.InsertAsync(request.Order, cancellationToken);
// updateTransLinking(server_trans_id, orderOrLogin);
}
//if (reqMode == MT4REQMODE.CLOSE_TRADE || reqMode == MT4REQMODE.DELETE_TRADE)
//{
// removeTransLinking(server_trans_id);
//}
Debug.Assert(masterLogin > 0 && server_trans_id != Guid.Empty);
m_ptrLogger.LogInfo($"EXECUTED : Order {orderId}, master Login {masterLogin}, UID: {server_trans_id}");
var ptrResp = new SocialOrderResponse(); //MT_SocialOrderResponse_ID
ptrResp._serverTransID = server_trans_id;
ptrResp._requestMode = reqMode;
ptrResp._retCode = (eReturnCode)trans_status;
//SentDataUsingSocketID(ptrResp, MT_SocialOrderResponse_ID, socketID);
_connectionMgr.SentDataUsingLoginID(ptrResp, MessageTypeID.MT_SocialOrderResponse_ID, masterLogin);
}
}
}
