public static OrderModelItem MapToModel(this OrderDataModel orderDataModel)
{
var orderItem = new OrderModelItem();
orderItem.Id = orderDataModel.Id;
orderItem.Date = orderDataModel.CreationDate;
orderItem.Email = orderDataModel.Email;
orderItem.UserName = $"{orderDataModel.FirstName} {orderDataModel.LastName}";
orderItem.Amount = orderDataModel.Amount;
var result = orderDataModel.PaymentId == null ? Enums.TransactionStatus.UnPaid : Enums.TransactionStatus.Paid;
orderItem.TransactionStatus = result;
orderItem.Currency = orderDataModel.OrderItems.Select(x => x.Currency).FirstOrDefault();
orderItem.OrderItems = new List <OrderItemModelItem>();
foreach (var item in orderDataModel.OrderItems)
{
orderItem.OrderItems.Add(new OrderItemModelItem
{
PrintingEditionType = item.PrintingEditionType,
Title = item.Title,
Count = item.Count
});
}
return(orderItem);
}
public async Task <BaseModel> CreateAsync(OrderModelItem modelItem)
{
if (modelItem.OrderItems == null || !modelItem.OrderItems.Any())
{
modelItem.Errors.Add(Constants.Errors.CreateOrderError);
return(modelItem);
}
var order = new Order();
order = modelItem.MapToEntity(order);
var orderId = await _orderRepository.CreateAsync(order);
if (orderId == 0)
{
modelItem.Errors.Add(Constants.Errors.CreateOrderError);
return(modelItem);
}
var orderItems = modelItem.OrderItems.MapToOrderItemsList(orderId);
var result = await _orderItemRepository.CreateListAsync(orderItems);
if (!result && orderItems.Count() > 0)
{
modelItem.Errors.Add(Constants.Errors.CreateOrderError);
}
return(modelItem);
}
public async Task <IActionResult> Create([FromHeader] string authorization, [FromBody] OrderModelItem orderModelItem)
{
orderModelItem.User.Id = _jwtHelper.GetUserIdFromToken(authorization);
var orderModel = await _orderService.CreateAsync(orderModelItem);
return(Ok(orderModel));
}
public async Task <OrderModel> CreateOrderAsync(OrderModelItem orderModelItem, string userId)
{
var responseModel = new OrderModel();
if (!orderModelItem.OrderItems.Any())
{
responseModel.Errors.Add(Constants.Errors.InvalidData);
return(responseModel);
}
if (!long.TryParse(userId, out long _userId) || _userId == 0)
{
responseModel.Errors.Add(Constants.Errors.UserNotFound);
return(responseModel);
}
var orderItems = new List <OrderItem>();
var user = await _userRepository.GetUserByIdAsync(_userId);
if (user == null)
{
responseModel.Errors.Add(Constants.Errors.UserNotFound);
return(responseModel);
}
var payment = new Payment()
{
TransactionId = null
};
var paymentId = await _paymentRepository.CreateAsync(payment);
var order = new Order()
{
Amount = orderModelItem.OrderItems.Sum(x => x.Price * x.Count),
PaymentId = paymentId,
UserId = user.Id
};
var orderId = await _orderRepository.CreateAsync(order);
foreach (var orderPrintingEdition in orderModelItem.OrderItems)
{
var orderItem = orderPrintingEdition.MapToEntity();
orderItem.OrderId = orderId;
orderItems.Add(orderItem);
}
var orderItemsResult = await _orderItemRepository.CreateOrderItems(orderItems.ToArray());
responseModel.Items.Add(new OrderModelItem
{
Id = orderId
});
return(responseModel);
}
public async Task <IActionResult> CreateOrderAsync(string role, [FromBody] OrderModelItem orderModelItem)
{
var userId = string.Empty;
if (!string.IsNullOrWhiteSpace(role) && role.Equals(Constants.Roles.User))
{
userId = User.Claims.FirstOrDefault(x => x.Type.Equals(ClaimTypes.NameIdentifier))?.Value;
}
var responseModel = await _orderService.CreateOrderAsync(orderModelItem, userId);
return(Ok(responseModel));
}
public static DataAccess.Entities.Order MapToEntity(this OrderModelItem model, DataAccess.Entities.Order entity)
{
entity.Description = model.Description;
entity.Status = model.Status;
if (model.Payment != null)
{
entity.PaymentId = model.Payment.Id;
}
entity.UserId = model.User.Id;
return(entity);
}
public async Task <OrderModel> GetAllAsync(OrderFilterModel orderFilterModel)
{
var orderModel = new OrderModel();
var filterModel = orderFilterModel.MapToEFFilterModel();
var listOfOrders = await _orderRepository.GetAllOrders(filterModel);
if (listOfOrders.Items == null)
{
orderModel.Errors.Add(Constants.Errors.NotFoundOrdersError);
return(orderModel);
}
orderModel.Counter = listOfOrders.Counter;
foreach (var item in listOfOrders.Items)
{
var orderItem = new OrderModelItem();
orderModel.Items.Add(item.MapToModel());
}
return(orderModel);
}
public async Task <BaseModel> UpdateAsync(PaymentModelItem modelItem)
{
var order = await _orderRepository.FindByIdAsync(modelItem.OrderId);
var orderModel = new OrderModelItem();
if (order == null)
{
orderModel.Errors.Add(Constants.Errors.NotFoundOrderError);
return(orderModel);
}
var payment = new Payment();
payment.TransactionId = modelItem.TransactionId;
var paymentId = await _paymentsRepository.CreateAsync(payment);
if (paymentId == 0)
{
orderModel.Errors.Add(Constants.Errors.CreatePaymentError);
return(orderModel);
}
order.PaymentId = paymentId;
order.Status = Enums.Order.OrderStatus.Paid;
var result = await _orderRepository.UpdateAsync(order);
if (!result)
{
orderModel.Errors.Add(Constants.Errors.UpdateOrderError);
}
return(orderModel);
}
public static OrderModelItem MapToModel(this DataAccess.Entities.Order entity)
{
var model = new OrderModelItem();
model.Id = entity.Id;
model.Date = entity.CreationDate;
model.Status = entity.Status;
model.Description = entity.Description;
model.User = new UserModelItem();
model.User.Id = entity.UserId;
model.User.FirstName = entity.User.FirstName;
model.User.LastName = entity.User.LastName;
model.User.Email = entity.User.Email;
model.OrderPrice = entity.OrderPrice;
foreach (var item in entity.OrderItems)
{
if (item == null)
{
continue;
}
var orderItem = new OrderItemModelItem();
orderItem.Id = item.Id;
orderItem.Amount = item.Amount;
orderItem.PrintingEdition = new PrintingEditionModelItem();
orderItem.PrintingEdition.Title = item.PrintingEdition.Title;
orderItem.PrintingEdition.Type = item.PrintingEdition.Type;
orderItem.PrintingEdition.Price = item.PrintingEdition.Price;
model.OrderItems.Add(orderItem);
}
return(model);
}
