Пример #1
0
        public async Task <ProtoOAAccountAuthRes> AuthorizeAccount(long accountId, bool isLive, string accessToken)
        {
            VerifyConnection();

            var client = GetClient(isLive);

            using var cancelationTokenSource = new CancellationTokenSource();

            ProtoOAAccountAuthRes result = null;

            using var disposable = client.OfType <ProtoOAAccountAuthRes>().Where(response => response.CtidTraderAccountId == accountId)
                                   .Subscribe(response =>
            {
                result = response;

                cancelationTokenSource.Cancel();
            });

            var requestMessage = new ProtoOAAccountAuthReq
            {
                CtidTraderAccountId = accountId,
                AccessToken         = accessToken,
            };

            await SendMessage(requestMessage, ProtoOAPayloadType.ProtoOaAccountAuthReq, client, cancelationTokenSource, () => result is not null);

            return(result);
        }
        public ProtoMessage CreateAccAuthorizationRequest(string token, long accountId, string clientMsgId = null)
        {
            var _msg = ProtoOAAccountAuthReq.CreateBuilder();

            _msg.SetAccessToken(token);
            _msg.SetCtidTraderAccountId(accountId);
            return(CreateMessage((uint)_msg.PayloadType, _msg.Build().ToByteString(), clientMsgId));
        }
Пример #3
0
        private async static void AccountAuthRequest(string[] commandSplit)
        {
            var accountId = long.Parse(commandSplit[1]);

            Console.WriteLine("Sending account auth req...");

            var accountAuthReq = new ProtoOAAccountAuthReq
            {
                CtidTraderAccountId = accountId,
                AccessToken         = _token.AccessToken
            };

            await _client.SendMessage(accountAuthReq, ProtoOAPayloadType.ProtoOaAccountAuthReq);
        }
Пример #4
0
        private void Transmit()
        {
            while (!isShutdown)
            {
                if (_trasmitQueue.Count() > 0)
                {
                    //get the next message to submit
                    ProtoMessage msg = _trasmitQueue.Dequeue();

                    //Sends the Proto message
                    var    msgByteArray = msg.ToByteArray();
                    byte[] length       = BitConverter.GetBytes(msgByteArray.Length).Reverse().ToArray();
                    _apiSocket.Write(length);
                    _apiSocket.Write(msgByteArray);


                    switch ((ProtoOAPayloadType)msg.PayloadType)
                    {
                    case ProtoOAPayloadType.PROTO_OA_APPLICATION_AUTH_REQ:
                        MessageHandler?.Invoke("Authorising App.");
                        break;

                    case ProtoOAPayloadType.PROTO_OA_ACCOUNT_AUTH_REQ:
                        var accAuth = ProtoOAAccountAuthReq.CreateBuilder().MergeFrom(msg.Payload).Build();
                        MessageHandler?.Invoke("Authorising account " + Users[accAuth.AccessToken].AccountId);
                        break;

                    case ProtoOAPayloadType.PROTO_OA_SUBSCRIBE_SPOTS_REQ:
                        var spotReq = ProtoOASubscribeSpotsReq.CreateBuilder().MergeFrom(msg.Payload).Build();
                        //get the associated user
                        UserConfig config = Users.Where(x => x.Value.AccountId == spotReq.CtidTraderAccountId).Select(x => x.Value).FirstOrDefault();
                        //get the associated symbol
                        Symbol symbol = config.Symbols.Where(x => x.Id == spotReq.GetSymbolId(0)).FirstOrDefault();
                        //Notify the spot request has been sent
                        SymbolTickRequestHandler?.Invoke(symbol);
                        break;
                    }
                }
                else if (!_heartbeatTimer.Enabled)
                {
                    //start the heartbeat timer
                    _heartbeatTimer.Enabled = true;
                    _heartbeatTimer.Start();
                }

                //Wait 2.01 seconds between each message as to not exceed the 30 messages per minute restriction
                Thread.Sleep(2010);
            }
        }
        public static ProtoMessage Account_Auth_Req(long ctidTraderAccountId,
                                                    string accessToken)
        {
            ProtoOAAccountAuthReq message = new ProtoOAAccountAuthReq
            {
                payloadType         = ProtoOAPayloadType.ProtoOaAccountAuthReq,
                ctidTraderAccountId = ctidTraderAccountId,
                accessToken         = accessToken
            };

            Log.Info("ProtoOaAccountAuthReq:: " +
                     $"ctidTraderAccountId: {ctidTraderAccountId}; " +
                     $"accessToken: {accessToken}");

            InnerMemoryStream.SetLength(0);
            Serializer.Serialize(InnerMemoryStream, message);

            return(Encode((uint)message.payloadType, InnerMemoryStream.ToArray()));
        }
 public ProtoOAAccountAuthReq GetAccountAuthorizationRequest(byte[] msg = null)
 {
     return(ProtoOAAccountAuthReq.CreateBuilder().MergeFrom(GetPayload(msg)).Build());
 }
        static string OpenApiMessageToString(ProtoMessage msg)
        {
            switch ((ProtoOAPayloadType)msg.PayloadType)
            {
            case ProtoOAPayloadType.PROTO_OA_APPLICATION_AUTH_REQ:
                var app_auth_req = ProtoOAApplicationAuthReq.CreateBuilder().MergeFrom(msg.Payload).Build();
                return("AppAuthRequest{clientId:" + app_auth_req.ClientId + ", clientSecret:" + app_auth_req.ClientSecret + "}");

            case ProtoOAPayloadType.PROTO_OA_APPLICATION_AUTH_RES:
                return("ApAuthResponse");

            case ProtoOAPayloadType.PROTO_OA_ACCOUNT_AUTH_REQ:
                var acc_auth_req = ProtoOAAccountAuthReq.CreateBuilder().MergeFrom(msg.Payload).Build();
                return("AccAuthRequest{CtidTraderAccountId:" + acc_auth_req.CtidTraderAccountId + "}");

            case ProtoOAPayloadType.PROTO_OA_ACCOUNT_AUTH_RES:
                return("AccAuthResponse");

            case ProtoOAPayloadType.PROTO_OA_GET_ACCOUNTS_BY_ACCESS_TOKEN_REQ:
                return("GetAccountsByAccessTokenReq");

            case ProtoOAPayloadType.PROTO_OA_GET_ACCOUNTS_BY_ACCESS_TOKEN_RES:
                var accounts_list = ProtoOAGetAccountListByAccessTokenRes.CreateBuilder().MergeFrom(msg.Payload).Build();
                var sbAccounts    = new StringBuilder();
                foreach (var account in accounts_list.CtidTraderAccountList)
                {
                    sbAccounts.Append("ID: " + account.CtidTraderAccountId + (account.IsLive ? " Status: Live" + Environment.NewLine : " Status: Demo " + Environment.NewLine));
                }
                return("GetAccountsByAccessTokenRes{" + sbAccounts.ToString() + "}");

            case ProtoOAPayloadType.PROTO_OA_TRADER_REQ:
                return("PotoOATraderReq");

            case ProtoOAPayloadType.PROTO_OA_SYMBOLS_LIST_REQ:
                return("GetSymbolsList");

            case ProtoOAPayloadType.PROTO_OA_SYMBOLS_LIST_RES:
                var symbols_list = ProtoOASymbolsListRes.CreateBuilder().MergeFrom(msg.Payload).Build();
                var sbSymbols    = new StringBuilder();
                foreach (var symbol in symbols_list.SymbolList)
                {
                    sbSymbols.Append("ID: " + symbol.SymbolId + Environment.NewLine);
                    sbSymbols.Append("Name: " + symbol.SymbolName + Environment.NewLine);
                }
                return("Symbols{" + sbSymbols.ToString() + "}");

            case ProtoOAPayloadType.PROTO_OA_SYMBOL_BY_ID_REQ:
                return("GetSymbolsById");

            case ProtoOAPayloadType.PROTO_OA_SYMBOL_BY_ID_RES:
                var symbol_by_id_list = ProtoOASymbolByIdRes.CreateBuilder().MergeFrom(msg.Payload).Build();
                var sbSymbolByID      = new StringBuilder();
                foreach (var symbol in symbol_by_id_list.SymbolList)
                {
                    sbSymbolByID.Append("ID: " + symbol.SymbolId + Environment.NewLine);
                }
                return("Symbols{" + sbSymbolByID.ToString() + "}");

            case ProtoOAPayloadType.PROTO_OA_EXECUTION_EVENT:
                return(OpenApiExecEventsToString(msg));

            case ProtoOAPayloadType.PROTO_OA_DEAL_LIST_REQ:
                return("DealListRequest{}");

            case ProtoOAPayloadType.PROTO_OA_DEAL_LIST_RES:
                var deal_list = ProtoOADealListRes.CreateBuilder().MergeFrom(msg.Payload).Build();
                var sbDeals   = new StringBuilder();
                foreach (var deal in deal_list.DealList)
                {
                    sbDeals.Append("ID: " + deal.DealId + Environment.NewLine);
                    sbDeals.Append("Status: " + deal.DealStatus + Environment.NewLine);
                    sbDeals.Append("Volume: " + deal.Volume + Environment.NewLine);
                }
                return("DealList{" + sbDeals.ToString() + "}");

            case ProtoOAPayloadType.PROTO_OA_RECONCILE_REQ:
                return("ReconcileRequest{}");

            case ProtoOAPayloadType.PROTO_OA_RECONCILE_RES:
                var reconcile_response = ProtoOAReconcileRes.CreateBuilder().MergeFrom(msg.Payload).Build();
                var sbReconcile        = new StringBuilder();
                foreach (var order in reconcile_response.OrderList)
                {
                    sbReconcile.Append("ID: " + order.OrderId + Environment.NewLine);
                    sbReconcile.Append("Status: " + order.OrderStatus + Environment.NewLine);
                    sbReconcile.Append("Volume: " + order.TradeData.Volume + Environment.NewLine);
                }
                foreach (var position in reconcile_response.PositionList)
                {
                    sbReconcile.Append("ID: " + position.HasPositionId + Environment.NewLine);
                    sbReconcile.Append("Status: " + position.PositionStatus + Environment.NewLine);
                    sbReconcile.Append("Volume: " + position.TradeData.Volume + Environment.NewLine);
                }
                return("ReconcileList{" + sbReconcile.ToString() + "}");

            case ProtoOAPayloadType.PROTO_OA_CASH_FLOW_HISTORY_LIST_REQ:
                return("CashFlowHistoryRequest{}");

            case ProtoOAPayloadType.PROTO_OA_CASH_FLOW_HISTORY_LIST_RES:
                var cashflow_history = ProtoOACashFlowHistoryListRes.CreateBuilder().MergeFrom(msg.Payload).Build();
                var sbDCashflow      = new StringBuilder();
                foreach (var entry in cashflow_history.DepositWithdrawList)
                {
                    sbDCashflow.Append("ID: " + entry.BalanceHistoryId + Environment.NewLine);
                    sbDCashflow.Append("Type: " + entry.OperationType + Environment.NewLine);
                    sbDCashflow.Append("Delta: " + entry.Delta + Environment.NewLine);
                }
                return("CashFlowHistory{" + sbDCashflow.ToString() + "}");

            case ProtoOAPayloadType.PROTO_OA_GET_TRENDBARS_REQ:
                return("GetTrendbarsRequest{}");

            case ProtoOAPayloadType.PROTO_OA_GET_TRENDBARS_RES:
                var trendbar   = ProtoOAGetTrendbarsRes.CreateBuilder().MergeFrom(msg.Payload).Build();
                var sbTrendbar = new StringBuilder();
                foreach (var entry in trendbar.TrendbarList)
                {
                    sbTrendbar.Append("Open: " + entry.DeltaOpen + Environment.NewLine);
                    sbTrendbar.Append("High: " + entry.DeltaHigh + Environment.NewLine);
                    sbTrendbar.Append("Low: " + entry.Low + Environment.NewLine);
                    sbTrendbar.Append("Close: " + entry.DeltaClose + Environment.NewLine);
                }
                return("Trendbars{" + sbTrendbar.ToString() + "}");

            case ProtoOAPayloadType.PROTO_OA_GET_TICKDATA_REQ:
                return("GetTickDataRequest{}");

            case ProtoOAPayloadType.PROTO_OA_GET_TICKDATA_RES:
                var tickData   = ProtoOAGetTickDataRes.CreateBuilder().MergeFrom(msg.Payload).Build();
                var sbTickData = new StringBuilder();
                foreach (var entry in tickData.TickDataList)
                {
                    sbTickData.Append("Tick: " + entry.Tick + Environment.NewLine + " " + msg.ClientMsgId);
                }
                return("Tick Data{" + sbTickData.ToString() + "}");

            case ProtoOAPayloadType.PROTO_OA_CANCEL_ORDER_REQ:
                return("CancelOrderRequest{}");

            case ProtoOAPayloadType.PROTO_OA_NEW_ORDER_REQ:
                return("CreateOrderRequest{}");

            case ProtoOAPayloadType.PROTO_OA_CLOSE_POSITION_REQ:
                return("ClosePositionRequest{}");

            case ProtoOAPayloadType.PROTO_OA_AMEND_ORDER_REQ:
                return("AmendOrderRequest{}");

            case ProtoOAPayloadType.PROTO_OA_AMEND_POSITION_SLTP_REQ:
                return("AmendPositionRequest{}");

            case ProtoOAPayloadType.PROTO_OA_SUBSCRIBE_SPOTS_REQ:
                return("SubscribeForSpotsRequest{}");

            case ProtoOAPayloadType.PROTO_OA_SUBSCRIBE_SPOTS_RES:
                return("SubscribeForSpotsResponse{}");

            case ProtoOAPayloadType.PROTO_OA_UNSUBSCRIBE_SPOTS_REQ:
                return("UnsubscribeFromSpotsRequest{}");

            case ProtoOAPayloadType.PROTO_OA_UNSUBSCRIBE_SPOTS_RES:
                return("UnsubscribeFromSpotsResponse{}");

            case ProtoOAPayloadType.PROTO_OA_SPOT_EVENT:
                var _spot_event = ProtoOASpotEvent.CreateBuilder().MergeFrom(msg.Payload).Build();
                return("SpotEvent{symbolId:" + _spot_event.SymbolId + ", bidPrice:" + (_spot_event.HasBid ? _spot_event.Bid.ToString() : "       ") + ", askPrice:" + (_spot_event.HasAsk ? _spot_event.Ask.ToString() : "       ") + "}");

            case ProtoOAPayloadType.PROTO_OA_ERROR_RES:
                var _err = ProtoOAErrorRes.CreateBuilder().MergeFrom(msg.Payload).Build();
                return("ErrorResponse{errorCode:" + _err.ErrorCode + (_err.HasDescription ? ", description:" + _err.Description : "") + "}");

            case ProtoOAPayloadType.PROTO_OA_ORDER_ERROR_EVENT:
                var _orderErr = ProtoOAOrderErrorEvent.CreateBuilder().MergeFrom(msg.Payload).Build();
                return("OrderErrorResponse{errorCode:" + _orderErr.ErrorCode + (_orderErr.HasDescription ? ", description:" + _orderErr.Description : "") + "}");

            default:
                return("unknown");
            }
        }