public void SendOrderRest(int conId, CDataRestOrder dataRestOrder)
{
enmTradingEvent ev = enmTradingEvent.SendOrderRest;
SendDataToServer(conId, dataRestOrder, ev);
}
public void CallbackReadMessage(int conId, byte[] message)
{
byte byteTradingEvent = 0;
byte[] arrMsgBody = _messenger.GetBinaryMessageHeaderAndBody(message, ref byteTradingEvent);
enmTradingEvent tradingEvent = (enmTradingEvent)byteTradingEvent;
Log("Read message from client");
if (enmTradingEvent.AuthRequest == tradingEvent)
{
ProcessAuthRequest(conId, arrMsgBody);
}
else if (enmTradingEvent.EnableBot == tradingEvent)
{
ProcessEnableBot(conId, arrMsgBody);
}
else if (enmTradingEvent.DisableBot == tradingEvent)
{
ProcessDisableBot(conId, arrMsgBody);
}
else if (enmTradingEvent.CloseBotPosTrdMgr == tradingEvent)
{
ProcessClosePos(conId, arrMsgBody);
}
else if (enmTradingEvent.SendReconnect == tradingEvent)
{
ProcessSendReconnect(conId, arrMsgBody);
}
}
public void SendAuthRequest(int conId, CAuthRequest ar)
{
//CAuthRequest ar = new CAuthRequest { User = _terminalConfig.User, Password = _terminalConfig.Password };
enmTradingEvent ev = enmTradingEvent.AuthRequest;
SendDataToServer(conId, ar, ev);
}
public void SendDataToClients(object ob, enmTradingEvent ev, int connId = cnstBroadCast)
{
byte[] arrHeader = /*CMessenger*/ _messenger.GenBinaryMessageHeader((byte)ev);
byte[] arrBody = CUtilProto.SerializeProto(ob);
byte[] arrMsg = new byte[arrHeader.Length + arrBody.Length];
Buffer.BlockCopy(arrHeader, 0, arrMsg, 0, arrHeader.Length);
Buffer.BlockCopy(arrBody, 0, arrMsg, arrHeader.Length, arrBody.Length);
if (connId == cnstBroadCast)
{
foreach (KeyValuePair <int, CTradeManagerLink> kvp in _dictConIdTradeMgrLink)
{
if (kvp.Value.IsLoggedOn)
{
_tcpServer.SendMessage(kvp.Key, arrMsg);
}
}
}
else
{
_tcpServer.SendMessage(connId, arrMsg);
}
}
public void CloseAllPositions()
{
if (_tickerName == null)
{
Log("Try CloseAllPositions but _tickerName is null");
return;
}
if (VMUserPos != null && VMUserPos.Amount != 0)
//if (UserPos != null && UserPos.Amount != 0)
{
CCloseAllPositionsByIsin closeByIsin = new CCloseAllPositionsByIsin {
Isin = _tickerName
};
enmTradingEvent ev = enmTradingEvent.CloseAllPositionsByIsin;
_kernelTerminal.Communicator.SendDataToServer(ConnId, closeByIsin, ev);
Log("CloseAllPositions _tickerName=" + _tickerName);
}
else
{
string msg = "Try CloseAllPositions but";
if (VMUserPos == null)
{
msg += " VMUserPos is null";
}
else
{
msg += " VMUserPos.Amount ==0";
}
Log(msg);
}
}
public void CancellOrderbyId(long id)
{
CCancellOrderById ordById = new CCancellOrderById {
Id = id
};
enmTradingEvent ev = enmTradingEvent.CancellOrderById;
_kernelTerminal.Communicator.SendDataToServer(ConnId, ordById, ev);
}
public void SendSubscribeTickerList(int conId, CSubscribeTicker st)
{
enmTradingEvent ev = enmTradingEvent.UserSubscribeTicker;
//CSubscribeTicker st = new CSubscribeTicker { SubscribeCommand = new CCommandSubscribeTickers { Ticker = ticker, Action = EnmSubsrcibeActions.Subscribe } };
SendDataToServer(conId, st, ev);
}
public void CancellInstrumentOrders(object sender, ExecutedRoutedEventArgs e)
{
CDataCloseInstPos closeInstrPos = (CDataCloseInstPos)e.Parameter;
CCancellOrderByIsin cancellAllOrders = new CCancellOrderByIsin {
Isin = closeInstrPos.Instrument
};
enmTradingEvent ev = enmTradingEvent.CancellOrdersByIsin;
Communicator.SendDataToServer(closeInstrPos.ConId, cancellAllOrders, ev);
}
public void InvertPosition(int conId, string instrument)
{
enmTradingEvent ev = enmTradingEvent.InvertPosition;
CInvertUserPos invPos = new CInvertUserPos()
{
Instrument = instrument
};
SendDataToServer(conId, invPos, ev);
}
public void CloseInstrumentPostions(object sender, ExecutedRoutedEventArgs e)
{
CDataCloseInstPos closeInstrPos = (CDataCloseInstPos)e.Parameter;
CCloseAllPositionsByIsin closeByIsin = new CCloseAllPositionsByIsin {
Isin = closeInstrPos.Instrument
};
enmTradingEvent ev = enmTradingEvent.CloseAllPositionsByIsin;
Communicator.SendDataToServer(closeInstrPos.ConId, closeByIsin, ev);
}
public void SendOrderType(int conId, string instrument, EnmOrderTypes stopLossTakeProfit, decimal price, decimal amount = 0)
{
enmTradingEvent ev = enmTradingEvent.SetStoplossTakeProfit;
CSetOrder ssp = new CSetOrder
{
Instrument = instrument,
Price = price,
OrderType = stopLossTakeProfit,
Amount = amount
};
SendDataToServer(conId, ssp, ev);
}
public void SendOrderThrow(int conId, string instrument, decimal amount, EnmOrderDir dir, int throwSteps)
{
enmTradingEvent ev = enmTradingEvent.SendOrderThrow;
CSendOrderThrow sot = new CSendOrderThrow
{
Instrument = instrument,
OrderDir = dir,
Amount = amount,
ThrowSteps = throwSteps
};
SendDataToServer(conId, sot, ev);
}
//deprecated
public void CloseAllPositionsByIsin(string isin)
{
if (_tickerName == null)
{
return;
}
CCloseAllPositionsByIsin closeByIsin = new CCloseAllPositionsByIsin {
Isin = isin
};
enmTradingEvent ev = enmTradingEvent.CloseAllPositionsByIsin;
_kernelTerminal.Communicator.SendDataToServer(ConnId, closeByIsin, ev);
Log("CloseAllPositionsByIsin isin=" + isin);
}
public void AddOrder(string isin, decimal amount, EnmOrderDir dir, decimal price)
{
int id = Convert.ToInt16(_kernelTerminal.TerminalConfig.User);
CAddOrder ord = new CAddOrder {
IdTrader = id, Amount = amount, Dir = dir, Isin = _tickerName, Price = price
};
enmTradingEvent ev = enmTradingEvent.AddOrder;
_kernelTerminal.Communicator.SendDataToServer(ConnId, ord, ev);
Log("AddOrder IdTrader=" + id + " Amount=" + amount + " Dir=" + dir + " isin=" + _tickerName + " price=" + price);
}
public void CancellAllOrders()
{
if (_tickerName == null)
{
return;
}
CCancellOrderByIsin cancellAllOrders = new CCancellOrderByIsin {
Isin = _tickerName
};
enmTradingEvent ev = enmTradingEvent.CancellOrdersByIsin;
_kernelTerminal.Communicator.SendDataToServer(ConnId, cancellAllOrders, ev);
Log("CancellAllOrders");
}
/// <summary>
/// Creates message of specificated format (header, body) and writes message to tcpClient.
///
///
///
/// Call from:
/// 1) Internal class methods
/// 2) From MarketViewModel
/// </summary>
/// <param name="conId"></param>
/// <param name="ob"></param>
/// <param name="ev"></param>
public void SendDataToServer(int conId, object ob, enmTradingEvent ev)
{
CTCPClient tcpClient = null;
if (GetTCPClient(conId, out tcpClient))
{
byte[] arrHeader = _messenger.GenBinaryMessageHeader((byte)ev);
byte[] arrBody = CUtilProto.SerializeProto(ob);
byte[] arrMsg = new byte[arrHeader.Length + arrBody.Length];
Buffer.BlockCopy(arrHeader, 0, arrMsg, 0, arrHeader.Length);
Buffer.BlockCopy(arrBody, 0, arrMsg, arrHeader.Length, arrBody.Length);
tcpClient.WriteMessage(arrMsg);
}
}
//==========================================================================================================
//============================== END PUBLIC METHODS ============================================================
//==========================================================================================================
private void SendSubscribeOrUnsubscribeOneTicker(int conId, string ticker, EnmSubsrcibeActions act)
{
enmTradingEvent ev = enmTradingEvent.UserSubscribeTicker;
CSubscribeTicker st = new CSubscribeTicker
{
ListSubscribeCommands = new List <CCommandSubscribeTickers>
{
(new CCommandSubscribeTickers
{
Ticker = ticker,
Action = act
})
}
};
SendDataToServer(conId, st, ev);
}
public void CallbackReadMessage(byte[] message)
{
try
{
byte byteTradingEvent = 0;
byte[] arrMsgBody = _messenger.GetBinaryMessageHeaderAndBody(message, ref byteTradingEvent);
enmTradingEvent tradingEvent = (enmTradingEvent)byteTradingEvent;
if (enmTradingEvent.AuthResponse == tradingEvent)
{
ProcessAuthResponse(arrMsgBody);
}
else if (enmTradingEvent.PositionInstrTotal == tradingEvent)
{
ProcessPositionInstrTotal(arrMsgBody);
}
else if (enmTradingEvent.BotStatus == tradingEvent)
{
ProcessBotStatus(arrMsgBody);
}
else if (enmTradingEvent.BotPosTrdMgr == tradingEvent)
{
ProcessBotPosTrdMgr(arrMsgBody);
}
else if (enmTradingEvent.ClientInfo == tradingEvent)
{
ProcessClientInfo(arrMsgBody);
}
else
{
Error("Unknown message");
}
}
catch (Exception e)
{
Error("CDataRecieverTrdMgr.CallbackReadMessage", e);
}
}
/// <summary>
/// Callback triggered by tcp client
/// </summary>
/// <param name="message">message recieved by TCP client </param>
public void CallbackReadMessage(byte[] message)
{
try
{
byte byteTradingEvent = 0;
byte[] arrMsgBody = _messenger.GetBinaryMessageHeaderAndBody(message, ref byteTradingEvent);
enmTradingEvent tradingEvent = (enmTradingEvent)byteTradingEvent;
//object msgBody = CUtil.DeSerializeBinary(arrMsgBody);
if (enmTradingEvent.AuthResponse == tradingEvent)
{
ProcessAuthResponse(arrMsgBody);
}
else if (enmTradingEvent.UserOrdersUpdate == tradingEvent)
{
ProcessUserOrdersUpdate(arrMsgBody);
}
else if (enmTradingEvent.UserUpdatePositionMonitor == tradingEvent)
{
ProcessUserUpdatePositionMonitor(arrMsgBody);
}
else if (enmTradingEvent.UserUpdatePosLog == tradingEvent)
{
ProcessUserUpdatePosLog(arrMsgBody);
}
else if (enmTradingEvent.UpdateUserPosLogLate == tradingEvent)
{
ProcessUserUpdPosLogLate(arrMsgBody);
}
else if (enmTradingEvent.UserUpdateDealsLog == tradingEvent)
{
ProcessUserUpdateDealsLog(arrMsgBody);
}
else if (enmTradingEvent.UserUpdateVM == tradingEvent)
{
ProcessUserUpdateVM(arrMsgBody);
}
else if (enmTradingEvent.StockUpadate == tradingEvent)
{
ProcessStockUpadate(arrMsgBody);
}
else if (enmTradingEvent.DealsUpdate == tradingEvent)
{
ProcessDealsUpdate(arrMsgBody);
}
else if (enmTradingEvent.UserUpdateAvailableTickers == tradingEvent)
{
ProcessUserUpdateAvailableTickers(arrMsgBody);
}
else if (enmTradingEvent.SynchroniseTime == tradingEvent)
{
ProcessSynchroniseTime(arrMsgBody);
}
else if (enmTradingEvent.UpdateMoneyData == tradingEvent)
{
ProcessUpdateMoneyData(arrMsgBody);
}
else if (enmTradingEvent.StopLossTakeProfitAccepted == tradingEvent)
{
ProcessAcceptStoplossTakeProfit(arrMsgBody);
}
else if (enmTradingEvent.UpdateInstrumentParams == tradingEvent)
{
ProcessUpdInstrParamsOnilne(arrMsgBody);
}
else
{
Error("CDataReciever unknownMessage type");
}
}
catch (Exception e)
{
Error("CDataReciever.CallbackReadMessage", e);
}
}
public void CallbackReadMessage(int conId, byte[] message)
{
byte byteTradingEvent = 0;
byte[] arrMsgBody = _messenger.GetBinaryMessageHeaderAndBody(message, ref byteTradingEvent);
enmTradingEvent tradingEvent = (enmTradingEvent)byteTradingEvent;
Log("Read message from client");
if (enmTradingEvent.AuthRequest == tradingEvent)
{
ProcessAuthRequest(conId, arrMsgBody);
}
//TODO command as bot not directly
else if (enmTradingEvent.AddOrder == tradingEvent)
{
ProcessAddOrder(conId, arrMsgBody);
}
else if (enmTradingEvent.CancellOrderById == tradingEvent)
{
ProcessCancellOrderById(conId, arrMsgBody);
}
else if (enmTradingEvent.CancellAllOrders == tradingEvent)
{
ProcessCancellAllOrders(conId, arrMsgBody);
}
else if (enmTradingEvent.CancellOrdersByIsin == tradingEvent)
{
ProcessCancellOrdersByIsin(conId, arrMsgBody);
}
else if (enmTradingEvent.CloseAllPositions == tradingEvent)
{
ProcessCloseAllPositions(conId, arrMsgBody);
}
else if (enmTradingEvent.CloseAllPositionsByIsin == tradingEvent)
{
ProcessCloseAllPositionsByIsin(conId, arrMsgBody);
}
else if (enmTradingEvent.UserSubscribeTicker == tradingEvent)
{
ProcessUserSubscribeTicker(conId, arrMsgBody);
}
else if (enmTradingEvent.SetStoplossTakeProfit == tradingEvent)
{
ProcessTypeOrder(conId, arrMsgBody);
}
else if (enmTradingEvent.SendOrderThrow == tradingEvent)
{
ProcessSendOrderThrow(conId, arrMsgBody);
}
else if (enmTradingEvent.InvertPosition == tradingEvent)
{
ProcessInvertPosition(conId, arrMsgBody);
}
else if (enmTradingEvent.SendOrderRest == tradingEvent)
{
PorcessOrderRest(conId, arrMsgBody);
}
else if (enmTradingEvent.ClientInfo == tradingEvent)
{
ProcessClientInfo(conId, arrMsgBody);
}
else
{
throw new ApplicationException("Unknown message from client");
}
}
// connId == -1 for all else for specific connId
public void SendDataToClients(object ob, enmTradingEvent ev, string isin, int connId = cnstBroadCast)
{
try
{
Stopwatch sw2_1 = new Stopwatch();
Stopwatch sw2_2 = new Stopwatch();
Stopwatch sw2_3 = new Stopwatch();
//Stopwatch sw2_4 = new Stopwatch();
//Stopwatch sw2_5 = new Stopwatch();
//Stopwatch sw2_6 = new Stopwatch();
sw2_1.Reset(); sw2_1.Start();
sw2_2.Reset(); sw2_2.Start();
sw2_3.Reset(); sw2_3.Start();
// sw2_4.Reset(); sw2_4.Start();
// sw2_5.Reset(); sw2_5.Start();
// sw2_6.Reset(); sw2_6.Start();
byte[] arrHeader = /*CMessenger*/ _messenger.GenBinaryMessageHeader((byte)ev);
// sw2_6.Stop();
// byte[] arrBody = CUtil.SerializeBinary(ob).ToArray();
byte[] arrBody = CUtilProto.SerializeProto(ob);
// byte[] arrBody = (CUtil.SerializeBinaryExt(ob, ref ms, ref formatter)).ToArray();
//sw2_5.Stop();
byte[] arrMsg = new byte[arrHeader.Length + arrBody.Length];
//sw2_4.Stop();
Buffer.BlockCopy(arrHeader, 0, arrMsg, 0, arrHeader.Length);
sw2_3.Stop();
Buffer.BlockCopy(arrBody, 0, arrMsg, arrHeader.Length, arrBody.Length);
sw2_2.Stop();
//TO DO send olny subscribers that are subscribed
if (connId == cnstBroadCast)
{
foreach (KeyValuePair <int, CTrader> kvp in _dictConnIdTrader)
{
if (kvp.Value.IsLoggedOn)
{
if (ev == enmTradingEvent.SynchroniseTime || kvp.Value.SubscribedIsins.Contains(isin))
{
_tcpServer.SendMessage(kvp.Key, arrMsg);
}
}
}
sw2_1.Stop();
LogIsin(isin, ev + " sw2_1.Milliseconds= " + sw2_1.ElapsedMilliseconds + " s2_1.Ticks=" + sw2_1.ElapsedTicks);
_perfAnlzr.CheckLim(sw2_1.ElapsedMilliseconds, _perfSendDataToClient, "CTradersDispatcher.SendDataToClients sw2_1");
_perfAnlzr.CheckLim(sw2_2.ElapsedMilliseconds, _perfSendDataToClient, "CTradersDispatcher.SendDataToClients sw2_2");
_perfAnlzr.CheckLim(sw2_3.ElapsedMilliseconds, _perfSendDataToClient, "CTradersDispatcher.SendDataToClients sw2_3");
}
else
{
_tcpServer.SendMessage(connId, arrMsg);
}
}
catch (Exception e)
{
Error("CTradersDispatcher. Serialization", e);
}
}
private void Enqueue(object data, enmTradingEvent evnt, int connId = cnstBroadCast)
{
_bqTraderData.Add(new CTradingData {
Data = data, Event = evnt, ConnId = connId
});
}
