コード例 #1
0
        /**
         * Description: 买家卖家收单交易
         * Summary: 统一收单交易创建
         */
        public async Task <CreateTradeResponse> CreateTradeAsync(CreateTradeRequest request)
        {
            AlibabaCloud.TeaUtil.Models.RuntimeOptions runtime = new AlibabaCloud.TeaUtil.Models.RuntimeOptions();
            Dictionary <string, string> headers = new Dictionary <string, string>()
            {
            };

            return(await CreateTradeExAsync(request, headers, runtime));
        }
コード例 #2
0
        public async Task <IActionResult> Post([FromBody] CreateTradeRequest request)
        {
            ProductTradeService productTrade = new ProductTradeService(_context);

            Guid id = await productTrade.Create(new ProductTrade(request.Date, request.ProductId, request.Details, request.SchemaId, request.TradeId, request.ProductId));


            return(Created(string.Empty, id));
        }
コード例 #3
0
        /**
         * Description: 买家卖家收单交易
         * Summary: 统一收单交易创建
         */
        public CreateTradeResponse CreateTrade(CreateTradeRequest request)
        {
            AlibabaCloud.TeaUtil.Models.RuntimeOptions runtime = new AlibabaCloud.TeaUtil.Models.RuntimeOptions();
            Dictionary <string, string> headers = new Dictionary <string, string>()
            {
            };

            return(CreateTradeEx(request, headers, runtime));
        }
コード例 #4
0
 public async Task <ActionResult> CreateTrade(CreateTradeRequest request)
 {
     try
     {
         return(Ok(new Success(await Mediator.Send(request))));
     }
     catch (Exception exception)
     {
         return(StatusCode((int)HttpStatusCode.InternalServerError, new InternalServerError(exception)));
     }
 }
コード例 #5
0
        public async Task <AccountTradeModel> CreateTrade(CreateTradeRequest request)
        {
            using (var scope = _container.BeginLifetimeScope())
            {
                var repository = scope.Resolve <IAccountTradeRepository>();
                var entity     = repository.Add(new AccountTradeEntity());

                entity.AccountId   = request.AccountId;
                entity.CloseDate   = null;
                entity.EntryDate   = request.EntryDate;
                entity.EntryPrice  = request.EntryPrice;
                entity.Direction   = request.Direction;
                entity.SharesCount = request.SharesCount;

                await repository.CommitAsync();

                return(new AccountTradeModel(entity));
            }
        }
コード例 #6
0
        public async Task <AccountTradeModel> CloseTradePartially(CloseTradePartiallyRequest request)
        {
            using (var scope = _container.BeginLifetimeScope())
            {
                var tradeRepository = scope.Resolve <IAccountTradeRepository>();
                var trade           = await tradeRepository.GetAsync(request.TradeId);

                if (trade != null && trade.AccountId == request.AccountId)
                {
                    if (trade.SharesCount > request.SharesCount)
                    {
                        trade.SharesCount -= request.SharesCount;
                        await tradeRepository.CommitAsync();

                        var createTradeRequest = new CreateTradeRequest
                        {
                            AccountId   = request.AccountId,
                            EntryDate   = trade.EntryDate,
                            EntryPrice  = trade.EntryPrice,
                            Direction   = trade.Direction,
                            SharesCount = request.SharesCount
                        };

                        var completedTrade = await CreateTrade(createTradeRequest);

                        var closeTradeRequest = new CloseTradeRequest
                        {
                            AccountId  = request.AccountId,
                            TradeId    = completedTrade.TradeId,
                            CloseDate  = request.CloseDate,
                            ClosePrice = request.ClosePrice
                        };

                        return(await CloseTrade(closeTradeRequest));
                    }
                }
                return(null);
            }
        }
コード例 #7
0
 /**
  * Description: 买家卖家收单交易
  * Summary: 统一收单交易创建
  */
 public async Task <CreateTradeResponse> CreateTradeExAsync(CreateTradeRequest request, Dictionary <string, string> headers, AlibabaCloud.TeaUtil.Models.RuntimeOptions runtime)
 {
     AlibabaCloud.TeaUtil.Common.ValidateModel(request);
     return(TeaModel.ToObject <CreateTradeResponse>(await DoRequestAsync("1.0", "antcloud.industry.trade.create", "HTTPS", "POST", "/gateway.do", request.ToMap(), headers, runtime)));
 }
コード例 #8
0
        public async Task <ApiResponse <CreateTradeResponse> > CreateTrade(CreateTradeRequest request)
        {
            await SetHeader();

            return(await _httpClient.PostJsonAsync <ApiResponse <CreateTradeResponse> >(Constants.URI.Trades.CreateTrade, request));
        }
コード例 #9
0
        public async Task <IHttpActionResult> CreateTrade([FromBody] CreateTradeRequest request)
        {
            var trade = await _accountService.CreateTrade(request);

            return(Ok(trade));
        }