public async Task <IActionResult> GetOrderDraftFromBasketData(
            [FromBody] CreateOrderDraftCommand createOrderDraftCommand)
        {
            var draft = await _mediator.Send(createOrderDraftCommand);

            return(Ok(draft));
        }
Exemple #2
0
        public override async Task <OrderDraftDTO> CreateOrderDraftFromBasketData(CreateOrderDraftCommand createOrderDraftCommand, ServerCallContext context)
        {
            _logger.LogInformation("Begin grpc call from method {Method} for ordering get order draft {CreateOrderDraftCommand}", context.Method, createOrderDraftCommand);
            _logger.LogTrace(
                "----- Sending command: {CommandName} - {IdProperty}: {CommandId} ({@Command})",
                createOrderDraftCommand.GetGenericTypeName(),
                nameof(createOrderDraftCommand.BuyerId),
                createOrderDraftCommand.BuyerId,
                createOrderDraftCommand);

            var command = new AppCommand.CreateOrderDraftCommand(
                createOrderDraftCommand.BuyerId,
                this.MapBasketItems(createOrderDraftCommand.Items));


            var data = await _mediator.Send(command);

            if (data != null)
            {
                context.Status = new Status(StatusCode.OK, $" ordering get order draft {createOrderDraftCommand} do exist");

                return(this.MapResponse(data));
            }
            else
            {
                context.Status = new Status(StatusCode.NotFound, $" ordering get order draft {createOrderDraftCommand} do not exist");
            }

            return(new OrderDraftDTO());
        }
        public async Task Get()
        {
            var createOrderDraftCommand = new CreateOrderDraftCommand("1", new List <BasketItem> {
                new BasketItem {
                    Id = "11", UnitPrice = 1, Quantity = 1
                }
            });
            //发送 请求
            var response = await _mediator.Send(createOrderDraftCommand);

            Log.Debug("response:{@response}", response); // "Pong"
        }
    private CreateOrderDraftCommand MapToOrderDraftCommand(BasketData basketData)
    {
        var command = new CreateOrderDraftCommand
        {
            BuyerId = basketData.BuyerId,
        };

        basketData.Items.ForEach(i => command.Items.Add(new BasketItem
        {
            Id           = i.Id,
            OldUnitPrice = (double)i.OldUnitPrice,
            PictureUrl   = i.PictureUrl,
            ProductId    = i.ProductId,
            ProductName  = i.ProductName,
            Quantity     = i.Quantity,
            UnitPrice    = (double)i.UnitPrice,
        }));

        return(command);
    }
        public async Task <ActionResult <OrderDraftDto> > CreateOrderDraftFromBasketDataAsync([FromBody] CreateOrderDraftCommand createOrderDraftCommand)
        {
            //TODO: logging

            return(await _mediator.Send(createOrderDraftCommand));
        }
Exemple #6
0
        public async Task <ActionResult <OrderDraftDTO> > CreateOrderDraftFromBasketDataAsync([FromBody] CreateOrderDraftCommand createOrderDraftCommand)
        {
            _logger.LogInformation(
                "----- Sending command: {CommandName} - {IdProperty}: {CommandId} ({@Command})",
                createOrderDraftCommand.GetGenericTypeName(),
                nameof(createOrderDraftCommand.BuyerId),
                createOrderDraftCommand.BuyerId,
                createOrderDraftCommand);

            return(await _mediator.Send(createOrderDraftCommand));
        }
 public async Task <ActionResult <OrderDraftDTO> > CreateOrderDraftFromBasketDataAsync([FromBody] CreateOrderDraftCommand createOrderDraftCommand)
 {
     return(await _commandSender.SendCommand(createOrderDraftCommand));
 }