public async Task <OrderDto> CreateOrder(OrderCreateInput input)
        {
            await OrderManager.CheckBuyPermission();

            ProductBoughtContext boughtContext = input.MapTo <ProductBoughtContext>();
            ProductOrder         order         = await OrderManager.CreateOrder(boughtContext);

            return(order.MapTo <OrderDto>());
        }
        public async Task <OrderSuspendViewModel> SuspendOrder(CheckoutInfoInput checkoutInfoInput)
        {
            var basket = await _basketService.Get();

            var orderCreateInput = new OrderCreateInput()
            {
                BuyerId = _sharedIdentityService.GetUserId,
                Address = new AddressCreateInput()
                {
                    Province = checkoutInfoInput.Province,
                    District = checkoutInfoInput.District,
                    Street   = checkoutInfoInput.Street,
                    ZipCode  = checkoutInfoInput.ZipCode,
                    Line     = checkoutInfoInput.Line
                }
            };

            basket.BasketItems.ForEach(x =>
            {
                orderCreateInput.OrderItems.Add(new OrderItemCreateInput()
                {
                    ProductId   = x.CourseId,
                    Price       = x.GetCurrentPrice,
                    PictureUrl  = "",
                    ProductName = x.CourseName
                });
            });

            var paymentInfoInput = new PaymentInfoInput()
            {
                CardName   = checkoutInfoInput.CardName,
                CardNumber = checkoutInfoInput.CardNumber,
                Expiration = checkoutInfoInput.Expiration,
                CVV        = checkoutInfoInput.CVV,
                TotalPrice = basket.TotalPrice,
                Order      = orderCreateInput
            };

            var responsePayment = await _paymentService.ReveivePayment(paymentInfoInput);

            if (!responsePayment)
            {
                return(new OrderSuspendViewModel()
                {
                    Error = "Ödeme alınamadı",
                    IsSuccessful = false
                });
            }

            await _basketService.Delete();

            return(new OrderSuspendViewModel()
            {
                IsSuccessful = true
            });
        }
Beispiel #3
0
        public async Task <OrderCreatedViewModel> CreateOrder(CheckOutInfoInput checkOutInfoInput)
        {
            var basket = await _basketService.Get();

            var paymentInfoInput = new PaymentInfoInput()
            {
                CardName   = checkOutInfoInput.CardName,
                CardNumber = checkOutInfoInput.CardNumber,
                Expiration = checkOutInfoInput.Expiration,
                CVV        = checkOutInfoInput.CVV,
                TotalPrice = basket.TotalPrice
            };

            var responsePayment = await _paymentService.ReceivePayment(paymentInfoInput);

            if (!responsePayment)
            {
                return(new OrderCreatedViewModel()
                {
                    Error = "Ödeme alınamadı.", IsSuccessful = false
                });
            }

            var orderCreateInput = new OrderCreateInput()
            {
                BuyerId = _sharedIdentityService.GetUserId,
                Address = new AddressCreateInput {
                    Province = checkOutInfoInput.Province, District = checkOutInfoInput.District, Street = checkOutInfoInput.Street, Line = checkOutInfoInput.Line, ZipCode = checkOutInfoInput.ZipCode
                },
            };

            basket.BasketItems.ForEach(x =>
            {
                var orderItem = new OrderItemCreateInput {
                    ProductId = x.CourseId, Price = x.GetCurrentPrice, PictureUrl = "", ProductName = x.CourseName
                };
                orderCreateInput.OrderItems.Add(orderItem);
            });

            var response = await _httpClient.PostAsJsonAsync <OrderCreateInput>("orders", orderCreateInput);

            if (!response.IsSuccessStatusCode)
            {
                return(new OrderCreatedViewModel()
                {
                    Error = "Sipariş oluşturulamadı", IsSuccessful = false
                });
            }

            var orderCreatedViewModel = await response.Content.ReadFromJsonAsync <Response <OrderCreatedViewModel> >();

            orderCreatedViewModel.Data.IsSuccessful = true;
            await _basketService.Delete();

            return(orderCreatedViewModel.Data);
        }
        public OrderMutations(IOrderService orders)
        {
            Name = "OrderMutations";

            Field <OrderType>(
                "create",
                arguments: new QueryArguments(
                    new QueryArgument <NonNullGraphType <OrderCreateInputType> > {
                Name = "order"
            }),
                resolve: ctx => {
                OrderCreateInput input = ctx.GetArgument <OrderCreateInput>("order");
                string orderId         = Guid.NewGuid().ToString();
                Order order            = new Order(orderId, input.Name, input.Created, input.Description, input.CustomerId);
                return(orders.CreateAsync(order));
            }
                );

            FieldAsync <OrderType>(
                "start",
                arguments: new QueryArguments(
                    new QueryArgument <NonNullGraphType <StringGraphType> > {
                Name = "orderId"
            }),
                resolve: async context => {
                string orderId = context.GetArgument <string>("orderId");
                return(await context.TryAsyncResolve(
                           async c => await orders.StartAsync(orderId)));
            });

            FieldAsync <OrderType>(
                "close",
                arguments: new QueryArguments(
                    new QueryArgument <NonNullGraphType <StringGraphType> > {
                Name = "orderId"
            }),
                resolve: async context => {
                string orderId = context.GetArgument <string>("orderId");
                return(await context.TryAsyncResolve(
                           async c => await orders.CloseAsync(orderId)));
            });
        }
Beispiel #5
0
        public async Task <AjaxResponse <bool> > Add([FromBody] OrderCreateInput dto)
        {
            var res = await _appservice.Add(dto);

            return(new AjaxResponse <bool>(res));
        }