//For Main program
 protected virtual void OnClientLogout(string Message)
 {
     ClientLogout?.Invoke(this, new ClientEventArgs()
     {
         clientLogoutMessage = Message
     });
 }
コード例 #2
0
ファイル: Program.cs プロジェクト: TradeHelmInc/TrueX
        private static void ProcessEvent(WebSocketMessageV2 msg)
        {
            if (msg is ClientLoginResponse)
            {
                ClientLoginResponse loginResp = (ClientLoginResponse)msg;

                if (loginResp.JsonWebToken != null)
                {
                    UUID   = loginResp.Uuid;
                    UserId = loginResp.UserId;
                    Token  = loginResp.JsonWebToken;
                    FirmId = null;
                }

                ProcessJsonMessage <ClientLoginResponse>(loginResp);
            }
            else if (msg is TokenResponse)
            {
                ProcessTokenResponse(msg);
            }
            else if (msg is ClientLogout)
            {
                ClientLogout logoutResp = (ClientLogout)msg;

                Token  = null;
                UserId = UserId;
                FirmId = null;
                UUID   = null;

                ProcessJsonMessage <ClientLogout>((ClientLogout)msg);
            }
            else if (msg is ClientHeartbeat)
            {
                ClientHeartbeat heartBeat = (ClientHeartbeat)msg;
                ProcessJsonMessage <ClientHeartbeat>((ClientHeartbeat)msg);
                ProcessHeartbeat(heartBeat);
            }
            else if (msg is SubscriptionResponse)
            {
                ProcessJsonMessage <SubscriptionResponse>((SubscriptionResponse)msg);
            }
            else if (msg is ClientAccountRecord)
            {
                ProcessJsonMessage <ClientAccountRecord>((ClientAccountRecord)msg);
            }
            else if (msg is ClientLastSale)
            {
                ProcessJsonMessage <ClientLastSale>((ClientLastSale)msg);
            }
            else if (msg is FirmsTradingStatusUpdateResponse)
            {
                ProcessJsonMessage <FirmsTradingStatusUpdateResponse>((FirmsTradingStatusUpdateResponse)msg);
            }
            else if (msg is ClientBestBidOffer)
            {
                ProcessJsonMessage <ClientBestBidOffer>((ClientBestBidOffer)msg);
            }
            else if (msg is ClientMarketState)
            {
                ProcessJsonMessage <ClientMarketState>((ClientMarketState)msg);
            }
            else if (msg is ClientInstrument)
            {
                ProcessJsonMessage <ClientInstrument>((ClientInstrument)msg);
            }
            else if (msg is ClientOrderAck)
            {
                ProcessJsonMessage <ClientOrderAck>((ClientOrderAck)msg);
            }
            else if (msg is ClientOrderRej)
            {
                ProcessJsonMessage <ClientOrderRej>((ClientOrderRej)msg);
            }
            else if (msg is ClientMassCancelResponse)
            {
                ProcessJsonMessage <ClientMassCancelResponse>((ClientMassCancelResponse)msg);
            }
            else if (msg is ClientOrderReq)
            {
                ProcessJsonMessage <ClientOrderReq>((ClientOrderReq)msg);
            }
            else if (msg is ClientDSP)
            {
                ProcessJsonMessage <ClientDSP>((ClientDSP)msg);
            }
            else if (msg is FirmsListResponse)
            {
                FirmsListResponse resp = (FirmsListResponse)msg;
                resp.Firms.ToList().ForEach(x => SettlementAgentDict.Add(x.FirmId.ToString(), resp.SettlementAgentId));
                ProcessJsonMessage <FirmsListResponse>(resp);
            }
            else if (msg is FirmsCreditLimitUpdateResponse)
            {
                ProcessJsonMessage <FirmsCreditLimitUpdateResponse>((FirmsCreditLimitUpdateResponse)msg);
            }
            else if (msg is FirmsTradingStatusUpdateResponse)
            {
                ProcessJsonMessage <FirmsTradingStatusUpdateResponse>((FirmsTradingStatusUpdateResponse)msg);
            }
            else if (msg is EmailNotificationsListResponse)
            {
                ProcessJsonMessage <EmailNotificationsListResponse>((EmailNotificationsListResponse)msg);
            }
            else if (msg is EmailNotificationsCreateResponse)
            {
                ProcessJsonMessage <EmailNotificationsCreateResponse>((EmailNotificationsCreateResponse)msg);
            }
            else if (msg is EmailNotificationsUpdateResponse)
            {
                ProcessJsonMessage <EmailNotificationsUpdateResponse>((EmailNotificationsUpdateResponse)msg);
            }
            else if (msg is EmailNotificationsDeleteResponse)
            {
                ProcessJsonMessage <EmailNotificationsDeleteResponse>((EmailNotificationsDeleteResponse)msg);
            }
            else if (msg is UnknownMessageV2)
            {
                UnknownMessageV2 unknownMsg = (UnknownMessageV2)msg;

                DoLog(string.Format("<<unknown {0}", unknownMsg.Resp));
            }
            else if (msg is ErrorMessageV2)
            {
                ErrorMessageV2 errorMsg = (ErrorMessageV2)msg;

                DoLog(string.Format("<<unknown {0}", errorMsg.Error));
            }
            else
            {
                DoLog(string.Format("<<Unknown message type {0}", msg.ToString()));
            }

            Console.WriteLine();
        }
コード例 #3
0
 public static void HandleLogout(WorldSession session, ClientLogout logout)
 {
     session.Player.LogoutFinish();
 }
コード例 #4
0
        public override async void ReadResponses(object param)
        {
            while (true)
            {
                try
                {
                    string resp = "";
                    WebSocketReceiveResult webSocketResp;
                    if (SubscriptionWebSocket.State == WebSocketState.Open)
                    {
                        do
                        {
                            ArraySegment <byte> bytesReceived = new ArraySegment <byte>(new byte[1000]);
                            webSocketResp = await SubscriptionWebSocket.ReceiveAsync(bytesReceived, CancellationToken.None);

                            resp += Encoding.ASCII.GetString(bytesReceived.Array, 0, webSocketResp.Count);
                        }while (!webSocketResp.EndOfMessage);

                        if (resp != "")
                        {
                            WebSocketMessageV2 wsResp = JsonConvert.DeserializeObject <WebSocketMessageV2>(resp);

                            if (wsResp.Msg == "ClientLoginResponse")
                            {
                                ClientLoginResponse loginReponse = JsonConvert.DeserializeObject <ClientLoginResponse>(resp);
                                OnEvent(loginReponse);
                            }

                            else if (wsResp.Msg == "ClientLogout")
                            {
                                ClientLogout logoutReponse = JsonConvert.DeserializeObject <ClientLogout>(resp);
                                OnEvent(logoutReponse);
                            }
                            else if (wsResp.Msg == "ClientLogout")
                            {
                                ClientOrderAck clientOrderAck = JsonConvert.DeserializeObject <ClientOrderAck>(resp);
                                OnEvent(clientOrderAck);
                            }
                            else if (wsResp.Msg == "ClientOrderRej")
                            {
                                ClientOrderRej clientOrderRej = JsonConvert.DeserializeObject <ClientOrderRej>(resp);
                                OnEvent(clientOrderRej);
                            }
                            else if (wsResp.Msg == "TokenResponse")
                            {
                                TokenResponse tokenReponse = JsonConvert.DeserializeObject <TokenResponse>(resp);
                                OnEvent(tokenReponse);
                            }
                            else if (wsResp.Msg == "SubscriptionResponse")
                            {
                                SubscriptionResponse msg = JsonConvert.DeserializeObject <SubscriptionResponse>(resp);
                                OnEvent(msg);
                            }
                            else if (wsResp.Msg == "ClientAccountRecord")
                            {
                                ClientAccountRecord msg = JsonConvert.DeserializeObject <ClientAccountRecord>(resp);
                                OnEvent(msg);
                            }
                            else if (wsResp.Msg == "ClientLastSale")
                            {
                                ClientLastSale msg = JsonConvert.DeserializeObject <ClientLastSale>(resp);
                                OnEvent(msg);
                            }
                            else if (wsResp.Msg == "ClientBestBidOffer")
                            {
                                ClientBestBidOffer msg = JsonConvert.DeserializeObject <ClientBestBidOffer>(resp);
                                OnEvent(msg);
                            }
                            else if (wsResp.Msg == "ClientMarketState")
                            {
                                ClientMarketState msg = JsonConvert.DeserializeObject <ClientMarketState>(resp);
                                OnEvent(msg);
                            }
                            else if (wsResp.Msg == "ClientInstrument")
                            {
                                ClientInstrument msg = JsonConvert.DeserializeObject <ClientInstrument>(resp);
                                OnEvent(msg);
                            }
                            else if (wsResp.Msg == "DailySettlementPrice")
                            {
                                ClientDSP msg = JsonConvert.DeserializeObject <ClientDSP>(resp);
                                OnEvent(msg);
                            }
                            else if (wsResp.Msg == "ClientOrderAck")
                            {
                                ClientOrderAck msg = JsonConvert.DeserializeObject <ClientOrderAck>(resp);
                                OnEvent(msg);
                            }
                            else if (wsResp.Msg == "ClientOrderRej")
                            {
                                ClientOrderRej msg = JsonConvert.DeserializeObject <ClientOrderRej>(resp);
                                OnEvent(msg);
                            }
                            else if (wsResp.Msg == "ClientOrderReq")
                            {
                                ClientOrderReq msg = JsonConvert.DeserializeObject <ClientOrderReq>(resp);
                                OnEvent(msg);
                            }
                            else if (wsResp.Msg == "FirmsCreditLimitUpdateResponse")
                            {
                                FirmsCreditLimitUpdateResponse msg = JsonConvert.DeserializeObject <FirmsCreditLimitUpdateResponse>(resp);
                                OnEvent(msg);
                            }
                            else if (wsResp.Msg == "FirmsTradingStatusUpdateResponse")
                            {
                                FirmsTradingStatusUpdateResponse msg = JsonConvert.DeserializeObject <FirmsTradingStatusUpdateResponse>(resp);
                                OnEvent(msg);
                            }
                            else if (wsResp.Msg == "EmailNotificationsListResponse")
                            {
                                EmailNotificationsListResponse msg = JsonConvert.DeserializeObject <EmailNotificationsListResponse>(resp);
                                OnEvent(msg);
                            }
                            else if (wsResp.Msg == "EmailNotificationsCreateResponse")
                            {
                                EmailNotificationsCreateResponse msg = JsonConvert.DeserializeObject <EmailNotificationsCreateResponse>(resp);
                                OnEvent(msg);
                            }
                            else if (wsResp.Msg == "EmailNotificationsUpdateResponse")
                            {
                                EmailNotificationsUpdateResponse msg = JsonConvert.DeserializeObject <EmailNotificationsUpdateResponse>(resp);
                                OnEvent(msg);
                            }
                            else if (wsResp.Msg == "EmailNotificationsDeleteResponse")
                            {
                                EmailNotificationsDeleteResponse msg = JsonConvert.DeserializeObject <EmailNotificationsDeleteResponse>(resp);
                                OnEvent(msg);
                            }
                            else if (wsResp.Msg == "FirmsListResponse")
                            {
                                FirmsListResponse msg = JsonConvert.DeserializeObject <FirmsListResponse>(resp);
                                OnEvent(msg);
                            }
                            else if (wsResp.Msg == "ClientMassCancelResponse")
                            {
                                ClientMassCancelResponse msg = JsonConvert.DeserializeObject <ClientMassCancelResponse>(resp);
                                OnEvent(msg);
                            }
                            else if (wsResp.Msg == "ClientHeartbeat")
                            {
                                OnEvent(JsonConvert.DeserializeObject <ClientHeartbeat>(resp));
                            }
                            else
                            {
                                UnknownMessageV2 unknownMsg = new UnknownMessageV2()
                                {
                                    Msg    = "UnknownMsg",
                                    Resp   = resp,
                                    Reason = string.Format("Unknown message: {0}", resp)
                                };
                                OnEvent(unknownMsg);
                            }
                        }
                    }
                    else
                    {
                        Thread.Sleep(1000);
                    }
                }
                catch (Exception ex)
                {
                    ErrorMessageV2 errorMsg = new ErrorMessageV2()
                    {
                        Msg = "ErrorMsg", Error = ex.Message
                    };
                    OnEvent(errorMsg);
                }
            }
        }