public IActionResult Post([FromBody] NewOrderDto newOrderDto, int idClient) { try { return(Ok(_dbService.AddOrder(newOrderDto, idClient))); } catch (Exception e) { return(BadRequest("Exception: " + e.Message + "\n" + e.StackTrace)); } }
public async Task <ContentResult> CreateOrder(NewOrderDto order) { ReturnMessage rm = new ReturnMessage(1, "Success"); try { var customer = _mapper.Map <Customer>(order.Customer); var address = _mapper.Map <Address>(order.Address); var payment = _mapper.Map <Payment>(order.Payment); var customerAdded = _unitOfWork.Customers._Add(customer); var addressAdded = _unitOfWork.Address._Add(address); var paymentAdded = _unitOfWork.Payments._Add(payment); var orderAdded = _unitOfWork.Orders._Add(new Order() { Message = order.Message, Status = "Pending", Customer = customerAdded, OrderAddress = addressAdded, Payment = paymentAdded, CreatedAt = DateTime.Now, UpdatedAt = DateTime.Now, OrderAt = order.OrderTime }); foreach (var item in order.Product) { _unitOfWork.OrderDetails.Add(new OrderDetail() { Quantity = item.Quantity, Message = item.Message, Order = orderAdded, ProductId = item.ProductId, SizeId = item.SizeId }); } _unitOfWork.Complete(); return(this.Content(rm.returnMessage(null), "application/json")); } catch (Exception ex) { return(this.Content(JsonConvert.SerializeObject(new { // 0 is Exception msgCode = 0, msg = ex.Message }), "application/json")); } }
public async Task <IActionResult> Post([FromBody] NewOrderDto newOrderDto) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } _orderId++; var pickupPosition = await GetByAddress(newOrderDto.PickUp); if (pickupPosition == null) { return(BadRequest($"address = \"{newOrderDto.PickUp}\" not found")); } var dropoffPosition = await GetByAddress(newOrderDto.DropOff); if (dropoffPosition == null) { return(BadRequest($"address = \"{newOrderDto.DropOff}\" address not found")); } var newOrder = new Order { Id = _orderId.ToString(), Status = OrderStatus.unassigned, Pickup = new GLocation { Address = newOrderDto.PickUp, Position = pickupPosition, }, Dropoff = new GLocation { Address = newOrderDto.DropOff, Position = dropoffPosition, } }; Orders.Add(newOrder); BrowserSocket.SendToAllAsync(new OrdersSocketMessage { Payload = Orders }); MobileSocket.SendToAllMobileSockets(new OrderAvailablePayload { Payload = newOrder }); return(Ok(newOrder)); }
public void Add(NewOrderDto order) { var dbOrder = new Order() { CreatedDate = order.CreatedDate.ToUniversalTime(), Total = order.Total, UserId = -1, }; dbOrder.OrderItems = GetOrderItems(order.Items, dbOrder); _orderRepository.Create(dbOrder); }
private async Task <Order> SaveNewOrderAsync(NewOrderDto newOrderDto) { var newOrderModel = _mapper.Map <Order>(newOrderDto); newOrderModel.CreatedAt = newOrderModel.LastUpdatedAt = DateTime.Now; newOrderModel.Status = OrderStatus.New; foreach (var orderItem in newOrderModel.Items) { orderItem.Status = OrderItemStatus.New; } return(await _orderUoW.OrdersRepository.CreateAsync(newOrderModel)); }
public static void ValidateNewOrderDto(NewOrderDto newOrderDto) { newOrderDto.OrderLines.ForEach(item => { if (string.IsNullOrEmpty(item.ComputerId)) { throw new Exception("Computer id cannot be null or empty"); } if (item.Quantity < 0) { throw new Exception("Computer quantity cannot be negative"); } }); }
public ActionResult <OrderDto> Create([FromBody] NewOrderDto data) { try { var order = _mapper.Map <NewOrderDto, Order>(data); var newOrder = _service.CreateOrder(order); var result = _mapper.Map <Order, OrderDto>(newOrder); return(CreatedAtAction(nameof(Get), new { id = newOrder.Id }, result)); } catch (ArgumentException) { return(BadRequest()); } }
public IActionResult AddOrder(NewOrderDto newOrderDto, int idClient) { if (newOrderDto.Wyroby.Count() == 0) { return(new BadRequestObjectResult("Order should contains at least 1 product")); } Client client = _context.Clients.Find(idClient); if (client == null) { return(new NotFoundObjectResult("Client with selected id doesn't exist")); } Order order = new Order { IdClient = idClient, IdEmployee = idClient % 2, AcceptanceDate = newOrderDto.DataPrzyjecia, Comments = newOrderDto.Uwagi }; _context.Orders.Add(order); _context.SaveChanges(); foreach (NewOrderItemDto newOrderItemDto in newOrderDto.Wyroby) { ConfectioneryProduct confectioneryProduct = _context.ConfectioneryProducts .Where(p => p.Name == newOrderItemDto.Wyrob) .FirstOrDefault(); if (confectioneryProduct == null) { return(new NotFoundObjectResult("Product with selected name doesn't exist")); } OrderItem orderItem = new OrderItem { IdOrder = _context.Orders.Max(o => o.IdOrder), IdConfectioneryProduct = confectioneryProduct.IdConfectioneryProduct, Quantity = int.Parse(newOrderItemDto.Ilosc), Comments = newOrderItemDto.Uwagi }; _context.OrderItems.Add(orderItem); } _context.SaveChanges(); return(new OkObjectResult("Ok")); }
public void Raise_an_error_when_creating_new_order_with_non_existing_computer() { NewOrderDto newOrderDto = new NewOrderDto { OrderLines = new List <NewOrderLineDto> { new NewOrderLineDto { ComputerId = "Unknown", Quantity = 1 } }, }; Exception exception = Assert.Throws <Exception>(() => ordersController.CreateNewOrder(newOrderDto)); Assert.IsNotNull(exception); Assert.AreEqual("Computer not found. Id: Unknown", exception.Message); }
public void Raise_an_error_when_creating_new_order_with_negative_quantity() { ComputersController computersController = new ComputersController(); ComputerInfoDto computerInfoDto = computersController.FindComputerByName("MacBook Pro 15"); NewOrderDto newOrderDto = new NewOrderDto { OrderLines = new List <NewOrderLineDto> { new NewOrderLineDto { ComputerId = computerInfoDto.Id, Quantity = -1 } } }; Exception exception = Assert.Throws <Exception>(() => ordersController.CreateNewOrder(newOrderDto)); Assert.IsNotNull(exception); Assert.AreEqual("Computer quantity cannot be negative", exception.Message); }
public async Task <IActionResult> CheckOut([FromBody] NewOrderDto newOrderDto) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var correlationToken = CorrelationTokenManager.GenerateToken(); // Note: Sending querystring parameters in the post. var response = await client.PostAsync <NewOrderDto>(ServiceEnum.Basket, $"api/Basket/CheckOut/?correlationToken={correlationToken}", newOrderDto); if (response == null) { return(BadRequest($"Shopping Basket with Id {newOrderDto.BasketId} could not be found")); } return(Accepted("Order Being Created")); }
public async Task <ActionResult> OrderForm(List <string> listbox) { NewOrderDto newOrderDTO = new NewOrderDto(); ICollection <OrderedPartDto> list = new List <OrderedPartDto>(); int id = 0; List <int> ids = new List <int>(); var parts = await partRepo.Select(); foreach (var item in listbox) { id = 0; foreach (var part in parts) { if (part.Name == item) { id = part.Id; break; } } ids.Add(id); } foreach (var _id in ids) { OrderedPartDto newOrder = new OrderedPartDto() { PartId = _id, Price = 30 }; list.Add(newOrder); } newOrderDTO.PartList = list; newOrderDTO.AuthorId = HttpContext.Session.GetComplex <User>("User").Id; newOrderDTO.Date = DateTime.Now; await orderRepo.AddOrder(newOrderDTO); var orders = await orderRepo.Select(); return(View("OrdersPage", orders)); }
public ActionResult NewOrder(NewOrderDto newOrder, ICreateService service) { if (!ModelState.IsValid) { //model errors so return immediately service.ResetDto(newOrder); return(View(newOrder)); } var response = service.Create(newOrder); if (response.IsValid) { //no success message as in a process return(RedirectToAction("EditLineItems", new { salesOrderId = newOrder.SalesOrderID })); } //else errors, so copy the errors over to the ModelState and return to view response.CopyErrorsToModelState(ModelState, newOrder); return(View(newOrder)); }
public NewOrderIdDto CreateNewOrder(NewOrderDto newOrderDto) { User user = AuthenticationService.AuthenticateUser(_username, _password); ValidationService.ValidateNewOrderDto(newOrderDto); Order order = new Order() { Guid = Guid.NewGuid().ToString(), Date = DateTime.Now, OrderLines = newOrderDto.OrderLines.Select(TransformationService.NewOrderLineDtoToOrderLine).ToList(), User = user }; Entities entities = DatabaseContext.GetEntities(); entities.Orders.Add(order); entities.Save(); return(new NewOrderIdDto { Id = order.Guid }); }
public void CreateOrder_CreatedDate_Should_BeStoredInUtcFormat() { // Arrange var dateToTest = DateTime.Now; var inputDto = new NewOrderDto() { CreatedDate = dateToTest }; var mockOrderRepository = new Mock <IOrderRepository>(); var result = default(Order); mockOrderRepository.Setup(r => r.Create(It.IsAny <Order>())) .Callback <Order>(o => result = o); // Act var orderService = new OrderService(mockOrderRepository.Object); orderService.Add(inputDto); // Assert mockOrderRepository.Verify(orderRepo => orderRepo.Create(It.IsAny <Order>()), Times.Once); Assert.AreEqual(result.CreatedDate, dateToTest.ToUniversalTime()); }
public async Task <ActionResult <string> > CreateOrder(NewOrderDto newOrder) { var requestId = await _ordersService.Create(newOrder); return(Accepted(requestId)); }
public ActionResult NewOrder(NewOrderDto newOrder, ICreateService service) { if (!ModelState.IsValid) { //model errors so return immediately service.ResetDto(newOrder); return View(newOrder); } var response = service.Create(newOrder); if (response.IsValid) { //no success message as in a process return RedirectToAction("EditLineItems", new { salesOrderId = newOrder.SalesOrderID}); } //else errors, so copy the errors over to the ModelState and return to view response.CopyErrorsToModelState(ModelState, newOrder); return View(newOrder); }
public Task <ApiResponse <OrderDto> > AddOrderAsync(NewOrderDto dto) { return(PostAsync <NewOrderDto, ApiResponse <OrderDto> >(_clientOptions.MakeOrderUrl, dto)); }
public async Task <Guid> Create(NewOrderDto newOrder) { return(await Mediator.Send(new CreateOrderCommand { NewOrder = newOrder })); }
public Task AddOrder(NewOrderDto order) { order.PersonId = GetPersonId(); return(_ordersService.AddOrder(order, HttpContext.RequestAborted)); }
public async Task <IActionResult> MakeOrderAsync([FromBody] NewOrderDto order) { var result = await _billingService.MakeOrderAsync(order); return(ApiResult(result)); }
public CreateOrderCommand(NewOrderDto order) { Order = order; }