private void ProcessSendReconnect(int conId, byte[] arrMsgBody)
{
CSendReconnect sendRecon = CUtilProto.DeserializeProto <CSendReconnect>(arrMsgBody);
Log("Process sending reconnect");
_dealingServer.OnTrdMgrSentReconnect(sendRecon.ConnectionId);
}
private void ProcessCancellAllOrders(int conId, byte[] arrMsgBody)
{
CCancellAllOrders coa = CUtilProto.DeserializeProto <CCancellAllOrders>(arrMsgBody);
_dictKBotIdVBotTrader[_dictConnIdTrader[conId].BotId].CancellAllBotOrders();
_dbg.DBGCancellAllOrders(_dictConnIdTrader[conId].BotId);
}
private void ProcessAuthResponse(byte[] arrMsgBody)
{
CAuthResponse aresp = CUtilProto.DeserializeProto <CAuthResponse>(arrMsgBody);
Log("[AuthResponse]");
_client.AuthResponse(aresp, _connId);
}
private void ProcessUserOrdersUpdate(byte[] arrMsgBody)
{
CUserOrdersUpdate userOrdersUpdate = CUtilProto.DeserializeProto <CUserOrdersUpdate>(arrMsgBody);
Log("[UserOrdersUpdate]");
_kernelTerminal.UpdateUserOrders(userOrdersUpdate);
}
private void ProcessAcceptStoplossTakeProfit(byte[] arrMsgBody)
{
CSetOrder stopLossTakeProfit = CUtilProto.DeserializeProto <CSetOrder>(arrMsgBody);
Log("[ProcessAcceptStoplossTakeProfit]");
_kernelTerminal.AcceptStopLossTakeProfit(stopLossTakeProfit);
}
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);
}
}
private void ProcessUpdInstrParamsOnilne(byte[] arrMsgBody)
{
CUpdateInstrumentParams updInstrParams = CUtilProto.DeserializeProto <CUpdateInstrumentParams>(arrMsgBody);
Log("ProcessUpdInstrParamsOnilne]");
_kernelTerminal.UpdateInstrParamsOnilne(updInstrParams);
}
private void ProcessDisableBot(int conId, byte[] arrMsgBody)
{
CDisableBot disableBot = CUtilProto.DeserializeProto <CDisableBot>(arrMsgBody);
Log("Disable bot Id=" + disableBot.BotId);
_dealingServer.DisableBot(disableBot.BotId);
}
private void ProcessCloseAllPositions(int conId, byte[] arrMsgBody)
{
CCloseAllPositions cap = CUtilProto.DeserializeProto <CCloseAllPositions>(arrMsgBody);
GetBotTrader(conId).CloseAllPositions();
_dbg.DBGCloseAllPositions(GetBotTrader(conId).BotId);
}
private void ProcessClosePos(int conId, byte[] arrMsgBody)
{
CCloseBotPosTrdMgr closePos = CUtilProto.DeserializeProto <CCloseBotPosTrdMgr>(arrMsgBody);
CBotBase bot = _dealingServer.GetBotById(closePos.BotId);
bot.ClosePositionOfInstrument(closePos.Instrument);
}
private void ProcessCancellOrdersByIsin(int conId, byte[] arrMsgBody)
{
CCancellOrderByIsin coa = CUtilProto.DeserializeProto <CCancellOrderByIsin>(arrMsgBody);
_dictKBotIdVBotTrader[_dictConnIdTrader[conId].BotId].CancellOrdersWithInstrumenByTrader(coa.Isin);
_dbg.DBGCancellAllOrdersByIsin(_dictConnIdTrader[conId].BotId, coa.Isin);
}
private void ProcessAddOrder(int conId, byte[] arrMsgBody)
{
CAddOrder sc = CUtilProto.DeserializeProto <CAddOrder>(arrMsgBody);
_dictKBotIdVBotTrader[_dictConnIdTrader[conId].BotId].AddOrderByTrader(sc.Isin, sc.Price, sc.Dir, sc.Amount);
Log("Add order bot_id=" + _dictConnIdTrader[conId].BotId + " isin=" +
sc.Isin + " dir=" + sc.Dir + " Price=" + sc.Price + " Amount=" + sc.Amount);
}
private void ProcessClientInfo(byte[] arrMsgBody)
{
CListClientInfo listClientInfo = CUtilProto.DeserializeProto <CListClientInfo>(arrMsgBody);
Log("[CListClietInfo]");
_client.DataUser.UpdateClientInfo(listClientInfo);
}
private void ProcessBotPosTrdMgr(byte[] arrMsgBody)
{
CListBotPosTrdMgr listBotPosTrdMgr = CUtilProto.DeserializeProto <CListBotPosTrdMgr>(arrMsgBody);
Log("[CListBotPosTrdMgr]");
_client.DataUser.UpdateBotPosTrdMgr(listBotPosTrdMgr);
}
private void ProcessBotStatus(byte[] arrMsgBody)
{
CListBotStatus listBotStatus = CUtilProto.DeserializeProto <CListBotStatus>(arrMsgBody);
Log("[CListBotStatus]");
_client.DataUser.UpdateListBotStatus(listBotStatus);
}
private void ProcessPositionInstrTotal(byte[] arrMsgBody)
{
CListPositionInstrTotal posInstr = CUtilProto.DeserializeProto <CListPositionInstrTotal>(arrMsgBody);
Log("[CPositionInstrumentTotal]");
_client.DataUser.UpdatePositionInstrTotal(posInstr);
}
private void ProcessCloseAllPositionsByIsin(int conId, byte[] arrMsgBody)
{
CCloseAllPositionsByIsin cap = CUtilProto.DeserializeProto <CCloseAllPositionsByIsin>(arrMsgBody);
_dictKBotIdVBotTrader[_dictConnIdTrader[conId].BotId].ClosePositionOfInstrumentByTrader(cap.Isin);
_dbg.DBGCloseAllPositionByIsin(_dictConnIdTrader[conId].BotId, cap.Isin);
}
private void ProcessAuthResponse(byte[] arrMsgBody)
{
CAuthResponse aresp = CUtilProto.DeserializeProto <CAuthResponse>(arrMsgBody);
Log("[AuthResponse]");
AuthResponse(aresp, _connId);
_childWinDataUpdater.Update(aresp, _connId);
}
private void ProcessUserUpdPosLogLate(byte[] arrMsgBody)
{
CUserPosLogUpdLate userPosUpdLate = CUtilProto.DeserializeProto <CUserPosLogUpdLate>(arrMsgBody);
Log("[CUserPosLogUpdLate]");
_childWinDataUpdater.Update(userPosUpdLate, _connId);
}
private void ProcessUserUpdateVM(byte[] arrMsgBody)
{
CUserVMUpdate updateVM = CUtilProto.DeserializeProto <CUserVMUpdate>(arrMsgBody);
Log("[UserUpdateVM]");
_childWinDataUpdater.Update(updateVM, _connId);
_childWinDataUpdater.Update(updateVM.ListVM, _connId);
}
private void ProcessCancellOrderById(int conId, byte[] arrMsgBody)
{
CCancellOrderById co = CUtilProto.DeserializeProto <CCancellOrderById>(arrMsgBody);
//_plaza2Connector.CancelOrder( co.Id, _dictConnIdTrader[conId].BotId);
_dictKBotIdVBotTrader[_dictConnIdTrader[conId].BotId].CancelOrder(co.Id);
_dbg.DBGCancellOrderById(_dictConnIdTrader[conId].BotId, co);
}
private void ProcessUserUpdateAvailableTickers(byte[] arrMsgBody)
{
CAvailableTickers avTickers = CUtilProto.DeserializeProto <CAvailableTickers>(arrMsgBody);
UpdateAvailTickers(avTickers);
_childWinDataUpdater.Update(avTickers, _connId);
//Added 2018-02-25
_kernelTerminal.UpdateInstrParamsOnConnection(avTickers);
}
private void ProcessUserUpdateDealsLog(byte[] arrMsgBody)
{
CUserDealsLogUpdate userDealsLog = CUtilProto.DeserializeProto <CUserDealsLogUpdate>(arrMsgBody);
foreach (var kvp in userDealsLog.DictLog)
{
//public Dictionary<string, List<CUserDeal>> DictLog{ get; set; }
}
Log("[UserUpdatePosLog]");
_childWinDataUpdater.Update(userDealsLog, _connId);
}
private void ProcessDealsUpdate(byte[] arrMsgBody)
{
try
{
CDealsList lstDeals = CUtilProto.DeserializeProto <CDealsList>(arrMsgBody);
string isin = lstDeals.Isin; //lstDeals.DealsList[0].Isin;
CheckDeltaTimeLim(lstDeals.DtBeforePack, 50, "deals update");
_dtStockUpdate = (DateTime.Now - lstDeals.DtBeforePack).TotalMilliseconds;
Log("[Dealsupdate] DtBeforePack=" + lstDeals.DtBeforePack.ToString("hh:mm:ss.fff") + " isin=" + lstDeals.Isin +
" Dt_firtst_deal=" + lstDeals.DealsList[0].DtTm.ToString("hh:mm:ss.fff") +
" Dt_last_deal=" + lstDeals.DealsList[lstDeals.DealsList.Count - 1].DtTm.ToString("hh:mm:ss.fff") + " Count=" + lstDeals.DealsList.Count +
" dt=" + _dtStockUpdate);
List <CDealClass> lstAggr = new List <CDealClass>();
//get summarized deals
_dictDealsAggr[isin].GenAggrPrice(lstDeals.DealsList, lstAggr);
lock (OutpListAggrDeals[isin])
{
foreach (CDealClass dealClass in lstAggr)//lstDeals.DealsList)
{
OutpListAggrDeals[isin].Add(dealClass);
}
}
lock (OutpListRawDeals[isin])
{
foreach (CDealClass dealClass in lstDeals.DealsList)
{
OutpListRawDeals[isin].Add(dealClass);
}
}
}
catch (Exception e)
{
Error("CDataReciever deals", e);
}
}
/// <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);
}
}
public void Test()
{
int szDecimals = sizeof(decimal);
int szLong = sizeof(long);
int szDouble = sizeof(double);
int szFloat = sizeof(float);
// int szDateTime = DateTime
sc = CreateStockClass();
InitStockClass();
var bytes = CUtilProto.SerializeProto(sc);
}
private void ProcessSynchroniseTime(byte[] arrMsgBody)
{
Log("[TimeSynchro]");
bool needSynchro = false;
lock (_kernelTerminal.TerminalConfig)
needSynchro = _kernelTerminal.TerminalConfig.NeedTimeSynchro;
//TODO send moscow time flag or not (or Timezone) on datamessage
CTimeSynchroClass ts = CUtilProto.DeserializeProto <CTimeSynchroClass>(arrMsgBody);
//removed 2018-03-28 to remove message "Time syncro dtMS=" from error log
/*
* if (needSynchro)
* {
*
* int dtMS = (int)(DateTime.Now - ts.DtCurrentTime).TotalMilliseconds;
*
* int param = 20;
* if (Math.Abs(dtMS) > param)
* {
* CTimeChanger tch = new CTimeChanger(-dtMS);
* Error("Time syncro dtMS=" + dtMS);
* }
* }
*/
DateTime dtMsc = CUtilTime.LocalToMsc(ts.DtCurrentTime);
try
{
_terminalViewModel.StockClock = dtMsc.ToString("HH:mm:ss");
}
catch (Exception e)
{
Thread.Sleep(0);
}
}
private void ProcessUserUpdatePositionMonitor(byte[] arrMsgBody)
{
CUserPosMonitorUpdate userPosUpdate = CUtilProto.DeserializeProto <CUserPosMonitorUpdate>(arrMsgBody);
//changed 2018-05-27
string msg = "[UserUpdatePositionMonitor]";
if (userPosUpdate.MonitorUserPos == null)
{
msg += " MonitorUserPos==null";
}
else
{
foreach (var poses in userPosUpdate.MonitorUserPos)
{
msg += String.Format("instr={0} amount={1} avPos={2}",
poses.Key, poses.Value.Amount, poses.Value.AvPos);
}
}
Log(msg);
_kernelTerminal.UpdateUserMonitorPos(userPosUpdate);
}
private void ProcessAuthRequest(int conId, byte[] arrMsgBody)
{
//TODO auth here
int botId = -1;
CAuthRequest areq = CUtilProto.DeserializeProto <CAuthRequest>(arrMsgBody);
if (!IsPassedAuth(areq))
{
//response: auth is not success
EnqueueSendAuthResponse(false, "Пользователь и пароль не найдены", conId);
}
else
{
_dictConIdTradeMgrLink[conId].ConnId = conId;
//response: successfull auth.
EnqueueSendAuthResponse(true, "", conId);
_dictConIdTradeMgrLink[conId].IsLoggedOn = true;
}
Log("AuthRequest botId=" + botId);
}
private void ProcessClientInfo(int conId, byte[] arrMsgBody)
{
CClientInfo ci = CUtilProto.DeserializeProto <CClientInfo>(arrMsgBody);
ci.ConId = conId;
ci.BotId = GetBotId(conId);
ci.DtConnection = DateTime.Now;
ci.Ip = _tcpServer.GetClientIp(conId);
Log(String.Format("Client info. ConId={0} ip={1} botId={2} version={3} instance={4}",
conId, //0
_tcpServer.GetClientIp(conId),
GetBotId(conId), //1
ci.Version, //2
ci.Instance //3
));
_client.AddClientInfo(ci);
//_dictKBotIdVBotTrader[_dictConnIdTrader[conId].BotId].AddRestOrder(ro.Instrument, ro.Price, ro.Dir);
}
