public MakeOrderRespone MakeOrder(MakeOrderRequest request)
{
var makeOrderRespone = new MakeOrderRespone();
//var command = new MakeOrderCommand();
return(makeOrderRespone);
}
public IActionResult CreateAuthor(MakeOrderRequest request)
{
var command = mapper.Map <MakeOrderCommand>(request);
command.UserId = CurrentAccountId;
return(HandleCommandResult(appExecutor.Dispatch(command)));
}
public async Task <IActionResult> MakeOrder([FromRoute] string id, [FromBody] MakeOrderRequest request)
{
var identityUser = await _userManager.GetUserAsync(HttpContext.User);
var command = new MakeNewOrder(id, request.Quantity, identityUser.Id);
return((await _mediator.Send(command))
.Match(Ok, Error));
}
/// <inheritdoc/>
public async Task <ServiceResult <OrderDto> > MakeOrder(MakeOrderRequest request)
{
var customer = await _context.Customers.FindAsync(request.CustomerId);
if (customer == null)
{
var error = $"Пользователь с id = {request.CustomerId} не найден";
_logger.LogError(error);
return(new ServiceResult <OrderDto>(isSuccess: false, errors: new string[] { error }));
}
var productsIds = request.Items.Select(x => x.ProductNumber).ToArray();
var productsCount = _context.Products.Where(p => productsIds.Contains(p.Id)).Count();
if (productsCount == 0)
{
return(new ServiceResult <OrderDto>(isSuccess: false, errors: new string[] { "Не найдены товары с такими Id" }));
}
var products = _context.Products.Where(p => productsIds.Contains(p.Id)).ToArray();
if (productsCount != productsIds.Length)
{
var missedIds = productsIds.Except(products.Select(x => x.Id)).ToArray();
return(new ServiceResult <OrderDto>(isSuccess: false, errors: new string[] { $"Не найдены товары с такими Id: {string.Join(",", missedIds)}" }));
}
var newOrder = new Order {
Description = request.Description, Customer = customer
};
foreach (var item in request.Items)
{
var product = products.Where(x => x.Id == item.ProductNumber).FirstOrDefault();
AddItemToOrder(newOrder, product, item);
}
UpdateOrderTotalPrice(newOrder);
CalculateDiscount(newOrder);
try
{
_context.Orders.Add(newOrder);
await _context.SaveChangesAsync();
}
catch (Exception e)
{
_logger.LogError("Произошла ошибка при обновлении заказа.", e);
return(new ServiceResult <OrderDto>(isSuccess: false, errors: new string[] { $"Произошла непредвиденная ошибка." }));
}
return(new ServiceResult <OrderDto>(item: _mapper.Map <OrderDto>(newOrder), isSuccess: true));
}
public async Task <MakeOrderResponse> Create(MakeOrderRequest request)
{
var order = await _orderService.CreateAsync(request);
if (order == null)
{
return(new MakeOrderResponse()
{
Code = ResponseCode.InnerError
});
}
return(new MakeOrderResponse());
}
public ActionResult MakeOrder(MakeOrderRequest request)
{
var userId = CurrentUser.UserId;
if (userId == Guid.Empty)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var order = _orderRepository.MakeOrder(userId, request);
EmailUtils.SendUserOrderEmail(CurrentUser.FullName, CurrentUser.Email, order);
EmailUtils.SendAdminOrderEmail();
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
public async Task <IActionResult> MakeOrder([FromBody] MakeOrderRequest request)
{
if (request == null || request?.CustomerId <= 0 || request?.Items.Length == 0)
{
return(BadRequest());
}
var result = await _orderService.MakeOrder(request);
if (result.IsSuccess)
{
return(Ok(result));
}
return(BadRequest(result.Errors));
}
public async Task <OrderModel> CreateAsync(MakeOrderRequest request)
{
try
{
// Get or create user
var user = await _userService.GetUserByPhoneAsync(request.Phone);
if (user == null)
{
user = _userEntityFactory.Create(
request.Name,
request.LastName,
request.Phone,
null,
CreateUserPlace.FromOrder);
_userRepository.Add(user);
}
// Create order
var order = _orderEntityFactory.Create(
request.Address,
user,
request.CalculateTotalPrice(),
request.Comment);
_orderRepository.Add(order);
// Create order items
foreach (var requestOrderPosition in request.OrderPositions)
{
var orderItem = _orderItemFactory.Create(
requestOrderPosition.ProductId,
requestOrderPosition.Price,
requestOrderPosition.Count,
order);
_orderItemRepository.Add(orderItem);
}
// Change user statistic
var statistic = await _userStatisticRepository.GetOneAsync(user.Id);
if (statistic == null)
{
statistic = new UserStatisticEntity {
User = user
};
statistic.OrdersCount++;
statistic.TotalOrdersPrice += order.TotalPrice;
statistic.Bonus += order.TotalPrice * _bonusPart;
_userStatisticRepository.Add(statistic);
}
else
{
statistic.OrdersCount++;
statistic.TotalOrdersPrice += order.TotalPrice;
statistic.Bonus += order.TotalPrice * _bonusPart;
_userStatisticRepository.Update(statistic);
}
await _orderRepository.SaveChangesAsync();
return(_mapper.Map <OrderModel>(order));
}
catch (Exception ex)
{
_logger.LogError(ex.ToString());
return(null);
}
}
public async Task AddOrderAsync(MakeOrderRequest order)
{
var container = _dbClient.GetContainer(_databaseName, _writeContainerName);
await container.CreateItemAsync(order, new PartitionKey(order.OrderId));
}
public OrderModel MakeOrder(Guid userId, MakeOrderRequest request)
{
var userEntity = _context.Users
.SingleOrDefault(x => x.UserId == userId);
var cartEntity = _context.Carts
.Include(x => x.CartItems)
.Include(x => x.CartItems.Select(y => y.Product))
.SingleOrDefault(x => x.User.UserId == userEntity.UserId);
var index = 1;
if (_context.Orders.Count() != 0)
{
index = _context.Orders
.OrderByDescending(x => x.Index)
.ToList()
.First()
.Index + 1;
}
var orderEntity = new OrderEntity()
{
OrderId = Guid.NewGuid(),
Index = index,
TotalPrice = cartEntity.TotalPrice,
PurchaseDate = DateTime.Now,
Status = OrderStatusEnum.InProcess,
User = userEntity
};
var orderItemsEntities = new List <OrderItemEntity>();
foreach (var item in cartEntity.CartItems)
{
var orderItemEntity = new OrderItemEntity()
{
OrderItemId = Guid.NewGuid(),
Count = item.Count,
Price = item.Price,
Product = item.Product,
Order = orderEntity,
};
orderItemsEntities.Add(orderItemEntity);
}
orderEntity.OrderItems = orderItemsEntities;
cartEntity.TotalPrice = decimal.Zero;
userEntity.Address = request.Address;
userEntity.Inn = request.Inn;
userEntity.CompanyName = request.CompanyName;
userEntity.PhoneNumber = request.PhoneNumber;
_context.Orders.Add(orderEntity);
_context.OrderItems.AddRange(orderItemsEntities);
_context.CartItems.RemoveRange(cartEntity.CartItems);
_context.Carts.AddOrUpdate(cartEntity);
_context.Users.AddOrUpdate(userEntity);
_context.SaveChanges();
var model = new OrderModel(orderEntity);
return(model);
}
public MakeOrderRespone MakeOrder(MakeOrderRequest request)
{
var response = _apiService.MakeOrder(request);
return(response);
}
