public async Task <IActionResult> Checkout([FromBody] OrderCreateRequest request) { try { var user = await _userManager.GetUserAsync(HttpContext.User); if (user == null) { return(BadRequest(ErrorCodes.INVALID_REQUEST)); } if (request.Lines == null || !request.Lines.Any()) { return(BadRequest(ErrorCodes.ORDER_NO_PRODUCT_IN_CART)); } if (ModelState.IsValid) { var result = await _orderService.SaveOrderAsync(request, user); return(Ok(result)); } else { return(BadRequest(ErrorCodes.ORDER_MISSING_ADDRESS_OR_PHONENUMBER)); } } catch (Exception ex) { return(BadRequest(ex.InnerException)); } }
public async Task <ActionResult <OrderViewModel> > PostAsync(OrderCreateRequest request) { foreach (var item in request.Items) { var products = _orleansClient.GetGrain <IProducts>(Guid.Empty); var exists = await products.Exists(item.ProductId); if (!exists) { return(NotFound()); } if (item.Quantity < 0) { ModelState.AddModelError(nameof(item.Quantity), "Invalid"); return(BadRequest(ModelState)); } } var Order = MapFromRequest(request); var Orders = _orleansClient.GetGrain <IOrders>(Guid.Empty); var result = await Orders.Add(Order); var response = MapToViewModel(result); return(response); }
public async Task <IActionResult> AddOrder(string phone, string fullAddress, string customerEmail) { List <CartItemViewModel> cart = HttpContext.Session.Get <List <CartItemViewModel> >("UserCart"); var orderVM = new OrderCreateRequest { Phone = phone, FullAddress = fullAddress, CustomerEmail = customerEmail, Cost = 0, OrderStatus = "XN", orderDetail = new List <OrderDetailViewModel>() }; foreach (var el in cart) { orderVM.Cost += el.Price * el.Qty; orderVM.orderDetail.Add(new OrderDetailViewModel { Qty = el.Qty, ProductId = el.ProductId }); } var result = await _orderApiClient.addOrder(orderVM); if (result) { Task.WaitAll(Task.Delay(2000)); return(RedirectToAction("Index", "Home")); } else { Task.WaitAll(Task.Delay(2000)); return(RedirectToAction("Index", "Cart")); } }
public async Task <IActionResult> PostOrder(OrderCreateRequest orderRequest) { var postOrder = new OrderHeader { Phone = orderRequest.Phone, CustomerEmail = orderRequest.CustomerEmail, Cost = orderRequest.Cost, FullAddress = orderRequest.FullAddress, OrderStatus = orderRequest.OrderStatus }; foreach (var el in orderRequest.orderDetail) { postOrder.OrderDetails.Add(new OrderDetail { Qty = el.Qty, ProductId = el.ProductId, Order = postOrder }); } var isPostSuccessOrder = await _orderService.CreateOrder(postOrder); if (isPostSuccessOrder) { return(NoContent()); } else { return(NotFound()); } }
public async void CanCreateOrder() { const int productId = 1; const int applicantId = 2; //so complex because PG rounds milliseconds to 6 digits var now = DateTimeOffset.Now; var dateAdd = new DateTimeOffset(now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second, 123, now.Offset); var request = new OrderCreateRequest { ProductId = productId, ApplicantId = applicantId, DateAdd = dateAdd }; var order = await _client.CreateOrderAsync(request); Assert.Equal(applicantId, order.ApplicantId); Assert.Equal(productId, order.ProductId); Assert.Equal(dateAdd, order.DateAdd); var orderId = order.Id; order = await _client.GetOrderAsync(orderId); Assert.Equal(orderId, order.Id); Assert.Equal(applicantId, order.ApplicantId); Assert.Equal(productId, order.ProductId); Assert.Equal(dateAdd, order.DateAdd); }
public OrderCreateResponse Create(OrderCreateRequest request) { var response = new OrderCreateResponse(); _facade.Create(request.Order); return(response); }
public async Task OrdersController_Checkout_Order_No_Product_In_Cart() { var user = new ClaimsPrincipal(new ClaimsIdentity(new Claim[] { new Claim(ClaimTypes.Name, _fixture.Users[0].UserName), new Claim(ClaimTypes.NameIdentifier, _fixture.Users[0].Id) }, "mock")); var userManager = _fixture.ServiceProvider.GetRequiredService <UserManager <User> >(); var controller = new OrdersController(_fixture.OrderService, userManager) { ControllerContext = new ControllerContext { HttpContext = new DefaultHttpContext() { User = user } } }; var request = new OrderCreateRequest { Address = "ABC Street, XYZ City", PhoneNumber = "123 456 789" }; var result = await controller.Checkout(request); var badResult = Assert.IsType <BadRequestObjectResult>(result); Assert.Equal(badResult.Value.ToString(), ErrorCodes.ORDER_NO_PRODUCT_IN_CART); }
public async Task <ApiResult <bool> > Create(OrderCreateRequest request) { Order order = new Order() { OrderDate = DateTime.UtcNow, UserId = request.UserId, OrderDetails = request.ListCart.Select(x => new OrderDetail() { ProductId = x.ProductId, Quantity = x.Quantity, Price = x.Price }).ToList(), ShipAddress = request.ShipAddress, ShipEmail = request.ShipEmail, ShipName = request.ShipName, ShipPhoneNumber = request.ShipPhoneNumber, Status = OrderStatus.InProgress }; _context.Orders.Add(order); if (await _context.SaveChangesAsync() != 0) { return(new ApiSuccessResult <bool>()); } return(new ApiErrorResult <bool>()); }
private void AddToCart(ref Order order, OrderCreateRequest orderCreateRequest) { var productExistOrder = order.orderDetails.Where(x => x.productId == orderCreateRequest.productId).FirstOrDefault(); if (productExistOrder != null) { if (productExistOrder.quantity + orderCreateRequest.quantity <= 0) { context.OrderDetails.Remove(productExistOrder); //order.orderDetails.Remove(productExistOrder); } else { productExistOrder.quantity += orderCreateRequest.quantity; order.updatedDate = DateTime.Now; } } else { productExistOrder = new OrderDetail { productId = orderCreateRequest.productId, quantity = orderCreateRequest.quantity, orderId = order.orderId }; order.updatedDate = order.createdDate = DateTime.Now; order.orderDetails.Add(productExistOrder); } }
public async Task <int> Create(OrderCreateRequest request) { var tempUser = await _context.Users.FindAsync(request.UserId); var tempCartList = await _context.Carts.Where(x => x.UserId == request.UserId).ToListAsync(); var newOrder = new Order() { OrderDate = DateTime.Now, ShipAddress = tempUser.Address + " " + tempUser.City + " " + tempUser.State, ShipName = tempUser.FirstName + " " + tempUser.LastName, ShipEmail = tempUser.Email, ShipPhoneNumber = tempUser.PhoneNumber, UserId = tempUser.Id, Status = Data.Enums.OrderStatus.InProgress, OrderDetails = new List <OrderDetail>(), }; for (var i = 0; i < tempCartList.Count; i++) { var newOrderDetail = new OrderDetail() { ItemId = tempCartList[i].ItemId, Quantity = tempCartList[i].Quantity, Price = tempCartList[i].Price, }; await _context.OrderDetails.AddAsync(newOrderDetail); _context.Carts.Remove(tempCartList[i]); newOrder.OrderDetails.Add(newOrderDetail); } await _context.Orders.AddAsync(newOrder); return(await _context.SaveChangesAsync()); }
public async Task <Order> PutOrderAsync(OrderCreateRequest order, string userId) { Order orderToBeAdded; var productInDB = await context.Products.FindAsync(order.productId); if (!context.Orders.Any(o => o.user.Id == userId)) { return(null); } else { orderToBeAdded = await context.Orders.Where(o => o.user.Id == userId).Include(o => o.orderDetails).FirstOrDefaultAsync(); AddToCart(ref orderToBeAdded, order); } try { await context.SaveChangesAsync(); return(orderToBeAdded); } catch (Exception e) { return(null); } }
public static Order MapFromRequest(OrderCreateRequest request) { return(new Order { Items = request.Items.Select(x => MapFromRequest(x)).ToList(), Name = request.Name, }); }
/// <summary>Call the POS for Order method</summary> /// <param name="request">The request</param> public OrderCreatePOSResponse OrderTransaction(OrderCreateRequest request) { OrderCreatePOSResponse response = new OrderCreatePOSResponse(); // TODO: call (calls) to POS return(response); }
public async Task <OrderCreateResponse> SaveOrder(OrderCreateRequest order) { var request = new HttpRequestMessage(HttpMethod.Post, BackEndUrls.SaveOrder()) { Content = new StringContent(JsonConvert.SerializeObject(order), Encoding.UTF8, "application/json") }; return(await _apiServive.SendAsync <OrderCreateResponse>(request)); }
public async Task <IActionResult> PostAsync([FromBody] OrderCreateRequest request, CancellationToken cancellationToken) { var phoneNumber = User.FindFirst(ClaimTypes.NameIdentifier).Value; request.PhoneNumber = phoneNumber; var responseModel = await this.mediator.Send(request, cancellationToken); return(new CustomActionResult(responseModel)); }
private void VerifySignature(ActionExecutingContext filterContext, string path, table_商户账号 dbAccount) { string apiPassword = dbAccount.商户密码API; string secret = dbAccount.公共密匙; int? timeunix = filterContext.ActionParameters[tsKey] as int?; Int32 unixTimestamp = (Int32)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds; if (unixTimestamp - timeunix.Value > 180) { filterContext.Result = GetStandardError(BaseErrors.ERROR_NUMBER.LX1006, dbAccount.商户ID, unixTimestamp + "-" + timeunix.Value + "=" + (unixTimestamp - timeunix.Value)); return; } string signature = filterContext.ActionParameters[signKey] as string; string source; if (path.Contains("AccountInquiry")) { source = dbAccount.商户ID + apiPassword + timeunix + secret; } else if (path.Contains("OrderInquire")) { OrderInquireRequest orderInquireRequest = filterContext.ActionParameters["request"] as OrderInquireRequest; source = dbAccount.商户ID + apiPassword + timeunix + orderInquireRequest.OrderNumberMerchant + secret; } else if (path.Contains("OrderCreate")) { OrderCreateRequest orderCreateRequest = filterContext.ActionParameters["request"] as OrderCreateRequest; source = dbAccount.商户ID + apiPassword + timeunix + orderCreateRequest.OrderNumberMerchant + orderCreateRequest.AimsCardNumber + orderCreateRequest.AimsCardName + orderCreateRequest.AimsCardBank + orderCreateRequest.AimsMoney + secret; } else { filterContext.Result = GetStandardError(BaseErrors.ERROR_NUMBER.LX1018, dbAccount.商户ID); return; } using (MD5 md5Hash = MD5.Create()) { if (!VerifyMd5Hash(md5Hash, source, signature)) { if (dbAccount.签名错误累计 > MAX_ERROR_COUNT) { filterContext.Result = GetStandardError(BaseErrors.ERROR_NUMBER.LX1002, dbAccount.商户ID); } else { dbAccount.签名错误累计++; sqlSugarClient.Updateable(dbAccount).UpdateColumns(it => new { it.签名错误累计 }).ExecuteCommand();; filterContext.Result = GetStandardError(BaseErrors.ERROR_NUMBER.LX1004, dbAccount.商户ID); } } } }
public async Task <IActionResult> Create(OrderCreateRequest request) { var result = await _orderService.Create(request); if (result > 0) { return(Ok()); } return(BadRequest()); }
public async Task <IActionResult> CreateAsync([FromBody] OrderCreateRequest request) { if (request == null) { return(Fail(WebResource.CreateRequestIsEmpty)); } var id = await OrderService.CreateAsync(request); return(Success(id)); }
public async Task <IActionResult> Checkout() { var request = new OrderCreateRequest { ListCart = await GetListCart(CultureInfo.CurrentCulture.Name), //UserId = (Guid)await _userApiClient.GetUserId() }; return(View(request)); }
public async Task <IActionResult> CreateOrder(OrderCreateRequest request) { var result = await this.orderService.CreateOrder(request); if (!result.IsSuccess) { return(BadRequest(result)); } return(this.Ok(result)); }
public void should_create_order() { var items = new List <StackItem> { new StackItem { ProductId = 6, Amount = 2 }, new StackItem { ProductId = 7, Amount = 5 } }; var request = new OrderCreateRequest { OrderItems = new List <OrderItemCreateRequest> { new OrderItemCreateRequest { ProductId = 6, Amount = 1 }, new OrderItemCreateRequest { ProductId = 7, Amount = 2 } } }; items.ForEach(i => ResolveSession().Save(i)); var orderService = new OrderService(ResolveSession(), new OrderRepository(ResolveSession()), new StackItemRepository(ResolveSession())); orderService.CreateOrder(request); var orders = ResolveSession().Query <Order>().ToList(); Assert.Equal(1, orders.Count); var orderItems = ResolveSession().Query <OrderItem>().ToList(); Assert.Equal(1, orderItems.Single(i => i.ProductId == 6).Amount); Assert.Equal(2, orderItems.Single(i => i.ProductId == 7).Amount); var stackItems = ResolveSession().Query <StackItem>().ToList(); Assert.Equal(1, stackItems.Single(i => i.ProductId == 6).Amount); Assert.Equal(3, stackItems.Single(i => i.ProductId == 7).Amount); }
public void OrderCreateValidator_Should_Fail_Validation_When_ObjectNumber_Null() { // arrange var sut = new OrderCreateValidator(); var order = new OrderCreateRequest(); // act var result = sut.Validate(order); // assert Assert.False(result.IsValid); }
public async Task <IActionResult> createOrder([FromBody] OrderCreateRequest request) { try { var orderId = await ordersService.createOrder(request); return(Ok(orderId)); } catch (UserNotFoundException e) { return(BadRequest("Wrong order data was passed")); } }
/// <summary> /// 下单验证接口 /// </summary> /// <param name="request"></param> /// <param name="business"></param> /// <returns></returns> private PageResult VerifyOrder(OrderCreateRequest request, Tbl_OTABusiness business) { var orderInfo = request.Body.OrderInfo; OrderCreateResponse result = new OrderCreateResponse { Head = HeadResult.V1, Body = new OrderCreateInfo { Item = new List <OrderCreateItem>() } }; var validResult = _orderService.ValidDataForOrderVerifyRequest(request); if (!validResult.Status) { result.Head.Code = validResult.Code; result.Head.Describe = validResult.Message; return(PageDataResult.Data(result, business.Saltcode.ToString())); } List <int> productIds = orderInfo.TicketList.Select(a => a.ProductId).ToList(); var ticketIds = _otaTicketRelationService.GetTicketIds(business.Id, productIds); var tbl_Tickets = _ticketService.CheckIsTicketIds(ticketIds, business.ScenicId, orderInfo.VisitDate.ToDataTime()); var validDataResult = _orderService.ValidDataForOrderCreateRequest(request, tbl_Tickets); if (!validDataResult.Status) { result.Head.Code = validDataResult.Code; result.Head.Describe = validDataResult.Message; result.Body.Item.Add(new OrderCreateItem { ProductId = request.Body.OrderInfo.TicketList[0].ProductId.ToString(), useDate = request.Body.OrderInfo.VisitDate, quantity = 0 }); return(PageDataResult.Data(result, business.Saltcode.ToString())); } result.Head.Code = "000000"; result.Head.Describe = "成功"; result.Body.OrderStatus = "OREDER_SUCCESS"; foreach (var row in tbl_Tickets) { result.Body.Item.Add(new OrderCreateItem { ProductId = row.TicketId.ToString(), useDate = request.Body.OrderInfo.VisitDate, quantity = 500000 }); } return(PageDataResult.Data(result, business.Saltcode.ToString())); }
public async Task <DataResponseObject <OrderDTO> > CreateOrder(OrderCreateRequest order) { var createdOrder = await _orderRepository.CreateOrder(_mapper.Map <Order>(order)); if (createdOrder.Success) { _logger.LogInformation("Creating order with id {ID} with timeout of 10s", createdOrder.Data.Id); await _bus.Publish(new OrderCreatedEvent(createdOrder.Data.Id, createdOrder.Data.Price, createdOrder.Data.StockAmount, createdOrder.Data.UserId), optionalHeaders : new Dictionary <string, string> { { "x-message-ttl", "10000" } }); } return(_mapper.Map <DataResponseObject <OrderDTO> >(createdOrder)); }
public async Task CreateOrder_Should_Return_BadRequest_When_ObjectNumber_Is_Missing() { // arrange var createdOrder = new OrderCreateRequest(); var httpClient = _testFixture.Factory.CreateClient(); var httpContent = new StringContent(JsonSerializer.Serialize(createdOrder), Encoding.UTF8, "application/json"); // act var response = await httpClient.PostAsync("api/v1/orders", httpContent); // assert Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); }
public async Task <int> createOrder(OrderCreateRequest request) { if (await dbContext.Client.Where(client => client.clientId == request.clientId).SingleOrDefaultAsync() != null) { var order = new Order { creationTime = DateTime.Now, recipientName = request.recipientName, recipientEmail = request.recipientEmail, recipientPhoneNumber = request.recipientPhoneNumber, recipientSurname = request.recipientSurname, deliveryAddress = request.deliveryAddress, deliveryType = request.deliveryType, paymentType = request.paymentType, realizationState = RealizationStateEnum.NotAccepted, clientId = request.clientId }; if (order.paymentType == PaymentTypeEnum.OnlinePayment) { order.realizationState = RealizationStateEnum.Accepted; } await dbContext.Order.AddAsync(order); order.Products = new List <OrderProduct>(); foreach (OrderProductConnection orderProdcut in request.products) { var product = await dbContext.Product.Where(product => product.productId == orderProdcut.productId).SingleOrDefaultAsync(); if (product != null) { order.Products.Add(new OrderProduct { orderId = order.orderId, productId = product.productId, amount = orderProdcut.amount }); } else { throw new ProductNotFoundException("no such user"); } } await dbContext.SaveChangesAsync(); return(order.orderId); } else { throw new UserNotFoundException("no such user"); } }
public void OrderCreateValidator_Should_Pass_Validation_When_ObjectNumber_NotNull() { // arrange var sut = new OrderCreateValidator(); var order = new OrderCreateRequest { ObjectNumber = "B123", }; // act var result = sut.Validate(order); // assert Assert.True(result.IsValid); }
public async Task <ApiResult <string> > Create(OrderCreateRequest request) { var json = JsonConvert.SerializeObject(request); var httpContent = new StringContent(json, Encoding.UTF8, "application/json"); var response = await _client.PostAsync($"/api/orders", httpContent); var result = await response.Content.ReadAsStringAsync(); if (response.IsSuccessStatusCode) { return(JsonConvert.DeserializeObject <ApiResultSuccess <string> >(result)); } return(JsonConvert.DeserializeObject <ApiResultErrors <string> >(result)); }
public async Task <ActionResult <Order> > PostOrder([FromBody] OrderCreateRequest order) { try { var userId = User.FindFirst(ClaimTypes.NameIdentifier).Value; var orderToBeAdded = await service.PostOrderAsync(order, userId); return(CreatedAtAction(nameof(GetOrder), new { id = orderToBeAdded.orderId }, orderToBeAdded)); } catch (Exception) { throw; } }