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));
}
}
