コード例 #1
0
        public async Task InitializeAsync()
        {
            _logger.LogInformation("Initializing internal trades...");

            var tradesRequest = new TradesRequest();

            _logger.LogInformation("Receiving all internal quotes...");

            //tradesRequest.From

            //var pricesResponse = await _client.PrivateApi.Get(priceRequest);

            //ValidateResponse(pricesResponse.Error);

            //_logger.LogInformation($"Received {pricesResponse.Payload.Count} internal quotes.");

            //foreach (var priceUpdate in pricesResponse.Payload)
            //{
            //    var quote = Map(priceUpdate);

            //    foreach (var quoteHandler in _handlers)
            //    {
            //        await quoteHandler.HandleAsync(quote);
            //    }
            //}

            //_logger.LogInformation("Handled all internal quotes.");
        }
コード例 #2
0
ファイル: PublicApi.cs プロジェクト: Brainman643/Exmo
        public Task <CurrencyPairDictionary <Trade[]> > GetTradesAsync(CurrencyPairCollection pairs, CancellationToken cancellationToken = default)
        {
            var request = new TradesRequest {
                Pairs = pairs
            };

            return(_client.PostAsync <CurrencyPairDictionary <Trade[]> >("trades", request, cancellationToken));
        }
コード例 #3
0
        public void UnsubscribeTrades()
        {
            TradesRequest tr = new TradesRequest
            {
                Channel = ChannelType.Trades,
                Action  = ActionType.Unsubscribe
            };

            AddMessageToQueue(tr);
        }
コード例 #4
0
        public void SubscribeTrades(string symbol)
        {
            TradesRequest tr = new TradesRequest
            {
                Channel = ChannelType.Trades,
                Action  = ActionType.Subscribe,
                Symbol  = symbol
            };

            AddMessageToQueue(tr);
        }
コード例 #5
0
        public async Task TradesRequest_Test()
        {
            const string  symbol        = "tBTCUSD";
            TradesRequest tradesRequest = new TradesRequest(symbol)
            {
                Limit = 120,
                Sort  = -1
            };

            var result = await tradesRequest.ExecuteAsync();
        }
コード例 #6
0
        public override async Task <TradesResponse> GetTrades(TradesRequest request, ServerCallContext context)
        {
            var result = await _validationService.ValidateTradesRequestAsync(request.AssetPairId, request.Offset, request.Take);

            if (result != null)
            {
                return(new TradesResponse
                {
                    Error = new Error
                    {
                        Code = _mapper.Map <ErrorCode>(result.Code),
                        Message = result.Message
                    }
                });
            }

            DateTime?from = null;
            DateTime?to   = null;

            if (request.OptionalFromCase != TradesRequest.OptionalFromOneofCase.None)
            {
                from = request.From.ToDateTime();
            }

            if (request.OptionalToCase != TradesRequest.OptionalToOneofCase.None)
            {
                to = request.To.ToDateTime();
            }

            var orderAction = request.OptionalSideCase == TradesRequest.OptionalSideOneofCase.None
                ? (OrderAction?)null
                : _mapper.Map <OrderAction>(request.Side);

            if (request.Take == 0)
            {
                request.Take = Constants.MaxPageSize;
            }

            var trades = await _historyClient.GetTradersAsync(context.GetHttpContext().User.GetWalletId(),
                                                              request.AssetPairId, request.Offset, request.Take, orderAction, from, to);

            var res  = new TradesResponse();
            var data = _mapper.Map <List <Trade> >(trades);

            res.Payload.AddRange(data);

            return(res);
        }
コード例 #7
0
        public void Trades()
        {
            var request = new TradesRequest()
            {
                Bin                     = "700000001",
                Subcode                 = "0517614",
                TradePaymentSummary     = true,
                TradePaymentTotals      = true,
                TradePaymentExperiences = true,
                TradePaymentTrends      = true,
            };

            var response = this.Fixture.ServiceClient.PostTradesAsync(Client.Environ.Sandbox, this.Fixture.ObtainAuthToken(), request);

            Assert.NotNull(response.Result);
        }
コード例 #8
0
        public override async Task <TradesResponse> GetTrades(TradesRequest request, ServerCallContext context)
        {
            var session = SessionFromContext(context);

            var assetPairId = request.OptionalAssetPairIdCase == TradesRequest.OptionalAssetPairIdOneofCase.AssetPairId
                ? request.AssetPairId
                : string.Empty;

            DateTime?fromTime = request.OptionalFromDateCase == TradesRequest.OptionalFromDateOneofCase.From
                ? request.From.ToDateTime()
                : (DateTime?)null;

            DateTime?toTime = request.OptionalToDateCase == TradesRequest.OptionalToDateOneofCase.To
                ? request.To.ToDateTime()
                : (DateTime?)null;

            var side = request.OptionalTradeTypeCase == TradesRequest.OptionalTradeTypeOneofCase.TradeType
                ? request.TradeType
                : string.Empty;

            var trades = await _clientWalletService.GetClientTradesAsync(session.TenantId, session.ClientId,
                                                                         assetPairId, fromTime, toTime, side, request.Skip, request.Take);

            var resp = new TradesResponse();

            foreach (var trade in trades)
            {
                resp.Trades.Add(new TradesResponse.Types.TradeModel()
                {
                    Id             = trade.TradeId,
                    AssetPairId    = trade.BaseAssetId + trade.QuotingAssetId, //todo: take Id from AssetPair list
                    Timestamp      = Timestamp.FromDateTime(DateTime.SpecifyKind(trade.Timestamp, DateTimeKind.Utc)),
                    Price          = trade.Price,
                    BaseVolume     = trade.BaseVolume.Replace("-", ""),
                    BaseAssetName  = trade.BaseAssetId,
                    QuoteVolume    = trade.QuotingVolume,
                    QuoteAssetName = trade.QuotingAssetId,
                    Direction      = trade.BaseVolume.StartsWith("-") ? "Sell" : "Buy",
                    OrderId        = trade.ExternalOrderId
                });
            }

            return(resp);
        }
コード例 #9
0
        public override async Task <TradesResponse> GetTrades(TradesRequest request, ServerCallContext context)
        {
            var result = await _validationService.ValidateTradesRequestAsync(request.AssetPairId, request.Offset, request.Take);

            if (result != null)
            {
                return(new TradesResponse
                {
                    Error = new Error
                    {
                        Code = (int)result.Code,
                        Message = result.Message
                    }
                });
            }

            DateTime?from = null;
            DateTime?to   = null;

            if (DateTime.TryParse(request.From, out var fromDate))
            {
                from = fromDate;
            }

            if (DateTime.TryParse(request.To, out var toDate))
            {
                to = toDate;
            }

            var orderAction = request.OptionalSideCase == TradesRequest.OptionalSideOneofCase.None
                ? (OrderAction?)null
                : request.Side == Side.Buy ? OrderAction.Buy : OrderAction.Sell;
            var trades = await _historyClient.GetTradersAsync(context.GetHttpContext().User.GetWalletId(),
                                                              request.AssetPairId, request.Offset, request.Take, orderAction, from, to);

            var res  = new TradesResponse();
            var data = _mapper.Map <List <Trade> >(trades);

            res.Payload.AddRange(data);

            return(res);
        }
コード例 #10
0
        public override async Task <TradesResponse> GetTrades(TradesRequest request, ServerCallContext context)
        {
            var result = new TradesResponse();

            var token   = context.GetBearerToken();
            var wallets = await _clientAccountClient.Wallets.GetClientWalletsFilteredAsync(context.GetClientId(), WalletType.Trading);

            var walletId = wallets.FirstOrDefault()?.Id;

            var response = await _walletApiV2Client.GetTradesByWalletIdAsync(
                walletId, request.AssetPairId, request.Take, request.Skip,
                request.OptionalFromDateCase == TradesRequest.OptionalFromDateOneofCase.None?(DateTimeOffset?)null : request.From.ToDateTimeOffset(),
                request.OptionalToDateCase == TradesRequest.OptionalToDateOneofCase.None?(DateTimeOffset?)null : request.To.ToDateTimeOffset(),
                request.OptionalTradeTypeCase == TradesRequest.OptionalTradeTypeOneofCase.None?null : (TradeType?)Enum.Parse(typeof(TradeType?), request.TradeType),
                token);

            if (response != null)
            {
                result.Body = new TradesResponse.Types.Body();
                result.Body.Trades.AddRange(_mapper.Map <List <TradesResponse.Types.TradeModel> >(response));
            }

            return(result);
        }
コード例 #11
0
 public TradePage GetTrades(TradesRequest request) => GetTradesAsync(request).GetAwaiter().GetResult();
コード例 #12
0
 public async Task <TradePage> GetTradesAsync(TradesRequest request)
 {
     return(await this.httpClient.GetAsync <TradePage>($"{baseUrl}/api/v1/trades{Query(request)}"));
 }
コード例 #13
0
        public override TradesModel RequestTrades(PairBase pair)
        {
            var request = new TradesRequest(pair);

            return(request.Request <TradesResponse>().Transform());
        }