public IActionResult CreateOrder([FromBody] OrderForCreationDto order) { try { if (order == null) { _logger.LogError("order object sent from client is null."); return(BadRequest("order object is null")); } if (!ModelState.IsValid) { _logger.LogError("Invalid order object sent from client."); return(BadRequest("Invalid model object")); } var orderEntity = _mapper.Map <Order>(order); _repository.Order.CreateOrder(orderEntity); _repository.Save(); var createdOrder = _mapper.Map <OrderDto>(orderEntity); return(CreatedAtRoute("OrderById", new { id = createdOrder.OrderId }, createdOrder)); } catch (Exception ex) { _logger.LogError($"Something went wrong inside CreateOrder action: {ex.InnerException.Message}"); return(StatusCode(500, "Internal server error")); } }
public IActionResult UpdateOrder([FromBody] OrderForCreationDto order, int orderId) { if (orderId < 1) { return(BadRequest("Hatalı sipariş numarası!")); } var validation = PreInsertAndUpdateValidation(order); if (!validation.FirstOrDefault().Value) { return(BadRequest(validation.FirstOrDefault().Key)); } var result = _orderService.Update(order, orderId); if (result != null) { return(Ok(result)); } else { return(BadRequest("Sipariş Kaydedilemedi!")); } }
public async Task <IActionResult> CreateOrder(OrderForCreationDto creationDto) { var accountId = User.Claims.FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier).Value; var result = await _orderService.CreateOrderAsync(creationDto, accountId); return(StatusCode((int)result.Code, result)); }
private Dictionary <string, bool> PreInsertAndUpdateValidation(OrderForCreationDto order) { Dictionary <string, bool> validation = new Dictionary <string, bool>(); var checkCustomerExist = _customerService.IsCustomerExist(order.CustomerId); foreach (var orderDto in order.OrderDetails) { var checkProduct = _productService.IsProductAndStockExist(orderDto.ProductId); if (!checkProduct) { validation.Add("Ürün bulunamadı!", false); return(validation); } var productQuantity = _productService.GetById(orderDto.ProductId); if (productQuantity.QuantityPerUnit < orderDto.Quantity) { validation.Add($"yeterli miktarda ürün yok {productQuantity.Name} ürününden {orderDto.Quantity - productQuantity.QuantityPerUnit} Adet siliniz!", false); return(validation); } } if (!checkCustomerExist) { validation.Add("Müşteri bulunamadı!", false); return(validation); } else { validation.Add("İşlem devam ediyor.!", true); return(validation); } }
public static Order MapToOrder(this OrderForCreationDto orderDto, int orderId = 0) { List <OrderDetail> orderDetails = new List <OrderDetail>(); foreach (var orderDetailDto in orderDto.OrderDetails) { var orderDetail = new OrderDetail { ProductId = orderDetailDto.ProductId, Quantity = orderDetailDto.Quantity, OrderId = orderId }; orderDetails.Add(orderDetail); } var model = new Order() { CustomerId = orderDto.CustomerId, OrderDetails = orderDetails, CreatedDate = DateTime.Now, OrderAddress = orderDto.OrderAddress }; return(model); }
public async Task <IActionResult> CheckOut([FromBody] OrderForCreationDto orderForCreation) { var currentUserId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value); var userFromRepo = await _repo.GetUser(orderForCreation.UserId); if (currentUserId != userFromRepo.Id) { return(Unauthorized()); } if (userFromRepo == null) { return(NotFound($"Could not find user with an ID of {orderForCreation.UserId}")); } var order = _mapper.Map <Order>(orderForCreation); _repo.Add(order); if (await _repo.SaveAll()) { foreach (var item in orderForCreation.Items) { var itemOrder = _mapper.Map <OrderDetail>(item); itemOrder.OrderId = order.Id; _repo.Add(itemOrder); await _repo.SaveAll(); } return(Ok(order)); } throw new Exception($"Failed while ordering your food"); }
public IActionResult CreateOrder([FromBody] OrderForCreationDto orderDto) { if (orderDto == null) { return(BadRequest()); } var stockCode = orderDto.StockCode; if (!_repository.StockExists(stockCode, orderDto.OrderDate)) { return(StatusCode(412)); } var entity = Mapper.Map <Order>(orderDto); var orderValue = CalculateOrderValue(orderDto.StockAmount, GetStockValueByStockCode(stockCode)); entity.OrderValue = orderValue; entity.BrokerageFee = CalculateBrokerageFee(orderDto.Type, orderValue); entity.IncomeTax = CalculateIncomeTax(orderDto); _repository.AddOrderForClient(orderDto.ClientId, entity); if (!_repository.Save()) { return(StatusCode(500)); } var orderToReturn = Mapper.Map <OrderDto>(entity); return(CreatedAtRoute("GetOrder", new { id = orderToReturn.Id }, orderToReturn)); }
public async Task <IActionResult> BookOrder(int clientId, OrderForCreationDto orderForCreationDto) { if (clientId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value)) { return(Unauthorized()); } // if(await _repo.GetCustomer(clientId) == null) // { // return NotFound(); // } var latestBasket = await _repo.RetrieveBasket(clientId); if (latestBasket == null) { return(BadRequest("There is no Basket!")); } var orderForBasket = await _repo.GetOrderItems(latestBasket.Id); if (orderForBasket.Count == 0) { return(BadRequest("There is no products!")); } var finalVer = await _repo.SaveOrder(latestBasket.Id, orderForCreationDto); //override the quantites of products! var itemsToRet = await _repo.GetOrderItems(finalVer.Id); return(Ok(finalVer)); }
public async Task BookOrderReturnBadRequest_IfBasketDoesntExist() { var mockRepo = new Mock <ICustomerRepository>(); var mockMapper = new Mock <IMapper>(); int mockUserId = 1; OrderForCreationDto d1 = new OrderForCreationDto(); mockRepo.Setup(repo => repo.RetrieveBasket(mockUserId)).ReturnsAsync((Order)null); var controller = new OrdersController(mockRepo.Object, mockMapper.Object); var user = new ClaimsPrincipal(new ClaimsIdentity(new Claim[] { new Claim(ClaimTypes.Name, "Just Name"), new Claim(ClaimTypes.NameIdentifier, "1") })); controller.ControllerContext = new ControllerContext() { HttpContext = new DefaultHttpContext() { User = user } }; var res = await controller.BookOrder(mockUserId, d1); Assert.IsType <BadRequestObjectResult>(res); }
private decimal CalculateIncomeTax(OrderForCreationDto order) { decimal income = 0; var orderType = order.Type; var stockCode = order.StockCode; if (orderType.Equals('C')) { return(0); } if (orderType.Equals('V')) { if (stockCode != null) { var stockFromOrderDate = _repository.GetStocks().FirstOrDefault(s => s.Code == stockCode && s.Date.Date == order.OrderDate.Date); var stockFromBuyDate = _repository.GetStocks().FirstOrDefault(s => s.Code == stockCode && s.Date.Date == order.BuyDate?.Date); if (stockFromOrderDate != null && stockFromBuyDate != null) { decimal orderDateQuote = stockFromOrderDate.Price; decimal buyDateQuote = stockFromBuyDate.Price; decimal variation = orderDateQuote - buyDateQuote; if (variation > 0) { income = (order.StockAmount * variation) * 0.15m; } } } } return(income); }
public async Task <Order> SaveOrder(int orderId, OrderForCreationDto orderForCreationDto) { var basketFromRepo = await _context.Orders.FirstOrDefaultAsync(p => p.Id == orderId); basketFromRepo.Status = orderForCreationDto.Status; basketFromRepo.OrderType = orderForCreationDto.OrderType; basketFromRepo.Total = orderForCreationDto.Total; basketFromRepo.OrderDate = orderForCreationDto.OrderDate; basketFromRepo.DeliverDate = orderForCreationDto.DeliverDate; int inc = 0; var orderItems = await _context.OrderItems.Where(p => p.OrderId == orderId).ToListAsync(); foreach (var item in orderItems) { item.Quantity = orderForCreationDto.Quantities[inc]; inc++; } // for(int x = 0; x < orderForCreationDto.Quantities.Count; x++) // { // var orderItem = await _context.OrderItems // .FirstOrDefaultAsync(p => p.ProductId == orderForCreationDto.ProductIds[x] && p.OrderId == orderId); // orderItem.Quantity = orderForCreationDto.Quantities[x]; // } await _context.SaveChangesAsync(); return(basketFromRepo); }
public async Task BookOrderReturnUnauthorized_IfIdOfUserDoesntMatch_WithIdInClaims() { var mockRepo = new Mock <ICustomerRepository>(); var mockMapper = new Mock <IMapper>(); int mockUserId = 2; //mockRepo.Setup(repo => repo.) OrderForCreationDto d1 = new OrderForCreationDto(); var controller = new OrdersController(mockRepo.Object, mockMapper.Object); var user = new ClaimsPrincipal(new ClaimsIdentity(new Claim[] { new Claim(ClaimTypes.Name, "Just Name"), new Claim(ClaimTypes.NameIdentifier, "1") })); controller.ControllerContext = new ControllerContext() { HttpContext = new DefaultHttpContext() { User = user } }; var res = await controller.BookOrder(mockUserId, d1); Assert.IsType <UnauthorizedResult>(res); }
public async Task <IActionResult> CreateOrder([FromBody] OrderForCreationDto orderForCreationDto) { var order = new Order(); var orderStatus = await this._repository.OrderStatuses .FindByCondition(status => status.Name == "New", false).SingleAsync(); if (orderStatus == null) { return(BadRequest("Order status does not exist.")); } var customer = await this._repository.Customer.GetByIdAsync(orderForCreationDto.OrderedByCustomerId, false); if (customer == null) { return(BadRequest("Customer does not exist.")); } order.StatusId = orderStatus.Id; order.CreationDate = DateTime.Now; order.OrderedByCustomerId = orderForCreationDto.OrderedByCustomerId; order.Price = orderForCreationDto.Price; this._repository.Orders.Create(order); await this._repository.SaveAsync(); return(Ok()); }
public async Task <IActionResult> CreateOrder([FromBody] OrderForCreationDto orderCreationDto) { try { if (orderCreationDto == null) { logger.LogError("Order Creation DTO is null."); return(BadRequest("Order gesendet is null")); } if (!ModelState.IsValid) { logger.LogError("Invalid Order Object sent from client."); return(BadRequest("Invalid Order Object sent.")); } var order = mapper.Map <Order>(orderCreationDto); repository.Orders.CreateOrder(order); await repository.SaveAsync(); var createdOrder = mapper.Map <OrderDto>(order); return(CreatedAtAction(nameof(GetOrderByIDAsync), new { id = createdOrder.OrderID }, createdOrder)); } catch (Exception ex) { logger.LogError($"CreateOrder(): {ex.Message} {ex.StackTrace} {ex.InnerException}"); return(StatusCode(StatusCodes.Status500InternalServerError, "Internal Server Error")); } }
public IActionResult Post([FromBody] OrderForCreationDto order) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var client = _clientRepository.GetClient(order.ClientId, false); if (client == null) { return(NotFound()); } var finalOrderCreated = _mapper.Map <Entities.Order>(order); finalOrderCreated.Client = client; _orderRepository.CreateOrder(finalOrderCreated); _orderRepository.Save(); var createdOrderToReturn = _mapper.Map <Models.OrderDto>(finalOrderCreated); return(CreatedAtRoute( "GetOrder", new { id = createdOrderToReturn.Id }, createdOrderToReturn)); }
public async Task <IActionResult> CreateOrder([FromBody] OrderForCreationDto order) { var orderDto = _mapper.Map <OrderForCreationDto, OrderDto>(order); var newOrder = await _orderManager.CreateOrderAsync(orderDto); return(Ok(newOrder)); // return NoContent(); }
public async Task <Order> AddOrder(OrderForCreationDto orderForCreationDto) { var order = await _orderFormattingService.BuildOrder(orderForCreationDto); await _orderRepository.AddOrder(order); return(order); }
public async Task <ActionResult <Order> > PostItem([FromBody] OrderForCreationDto order) { var orderEntity = _mapper.Map <Order>(order); _context.Orders.CreateOrder(orderEntity); await _context.SaveAsync(); return(Ok(orderEntity)); }
public async Task <IActionResult> AddOrder(OrderForCreationDto orderForCreationDto) { var order = await _orderService.AddOrder(orderForCreationDto); if (await _orderService.SaveAll()) { return(Ok(order)); } return(NotFound()); }
public Order Add(OrderForCreationDto orderDto) { var order = orderDto.MapToOrder(); _orderRepository.Add(order); UpdateProductQuantity(order.OrderDetails); _unitOfWork.SaveChanges(); return(order); }
public ActionResult <OrderDto> PostOrder(OrderForCreationDto orderForCreationDto) { if (_clientService.FindById(orderForCreationDto.clientId) == null) { return(BadRequest("This ClientId doesnt exist.")); } var OrderToReturn = _orderService.InsertOrder(orderForCreationDto); return(CreatedAtRoute("GetOrderById", new { Id = OrderToReturn.id }, OrderToReturn)); }
public async Task <ActionResult <OrderDto> > PostOrdeAsyncr(OrderForCreationDto orderForCreationDto) { if ((await _clientService.FindByIdAsync(orderForCreationDto.clientId)) == null) { return(NotFound("This ClientId doesnt exist.")); } var OrderToReturn = await _orderService.InsertOrderAsync(orderForCreationDto); return(CreatedAtRoute("GetOrderById", new { Id = OrderToReturn.id }, OrderToReturn)); }
public Order Update(OrderForCreationDto orderDto, int orderId) { var order = orderDto.MapToOrder(orderId); order.Id = orderId; order.ModifiedDate = DateTime.Now; _orderRepository.Update(order); UpdateProductQuantity(order.OrderDetails); _unitOfWork.SaveChanges(); return(order); }
public async Task <ActionResult <OrderDto> > CreateOrder(OrderForCreationDto order) { var orderEntity = _mapper.Map <Order>(order); _orderRepository.AddOrder(orderEntity); await _orderRepository.Save(); var orderToReturn = _mapper.Map <OrderDto>(orderEntity); return(CreatedAtRoute("GetOrderAsync", new { orderId = orderToReturn.Id }, orderToReturn)); }
public async Task <IActionResult> AddOrderForCustomer(string customerId, [FromBody] OrderForCreationDto model) { if (!await _orderService.CustomerExists(customerId)) { return(NotFound("Customer Not Found!")); } var order = _mapper.Map <Order>(model); var orderCreated = _mapper.Map <OrderDto>(await _orderService.AddAsync(order)); return(CreatedAtRoute("GetOrderForCustomer", new { customerId, orderId = orderCreated.OrderID }, orderCreated)); }
public void AddNewOrder(OrderForCreationDto input, IList <SelectingProductDto> selectedProducts) { // save order var order = Mapper.Map <Order>(input); var storedOrder = _orderRepository.Create(order); // save order products var orderProducts = Mapper.Map <IList <OrderProduct> >(selectedProducts); for (var i = 0; i < orderProducts.Count(); i++) { orderProducts[i].OrderId = storedOrder.Id; _orderProductRepository.Create(orderProducts[i]); } }
public OrderDto InsertOrder(OrderForCreationDto orderForCreationDto) { try { var Order = _mapper.Map <Order>(orderForCreationDto); _OrderRepository.Insert(Order); var OrderToReturn = _mapper.Map <OrderDto>(Order); return(OrderToReturn); } catch (Exception) { throw; } }
public async Task <OrderDto> InsertOrderAsync(OrderForCreationDto orderForCreationDto) { try { var Order = _mapper.Map <Order>(orderForCreationDto); await _OrderRepository.InsertAsync(Order); var OrderToReturn = _mapper.Map <OrderDto>(Order); return(OrderToReturn); } catch (Exception) { throw; } }
public void UpdateOrderInfo(OrderForCreationDto input, ObservableCollection <SelectingProductDto> selectedProducts) { // save order _orderRepository.UpdateProviderById(input.Id, input.ProviderId); // delete all old order's products _orderProductRepository.DeleteAllByOrderId(input.Id); // save all new order's products var orderProducts = Mapper.Map <IList <OrderProduct> >(selectedProducts); for (var i = 0; i < orderProducts.Count(); i++) { orderProducts[i].OrderId = input.Id; _orderProductRepository.Create(orderProducts[i]); } }
public async Task <ActionResult> CreateBookOrder(OrderForCreationDto order) { try { if (order == null) { return(BadRequest()); } await _service.CreateBookOrder(order); return(NoContent()); } catch (Exception ex) { return(BadRequest(ex.Message)); } }