public (bool, int) AddOrders(OrdersRequestModel ordersRequestModel, string?IPAddress)
{
bool isValidResult = false;
int orderID = 0;
using (TransactionScope ts = new TransactionScope())
{
try
{
if (ordersRequestModel.isValid())
{
Order order = ordersRequestModel.toEntity(IPAddress);
_dbContext.Orders.Add(order);
_dbContext.SaveChanges();
_dbContext.OrderItems.AddRange(ordersRequestModel.ordersDetails.Select(x => x.toEntity(IPAddress, order.ID)));
_dbContext.SaveChanges();
ts.Complete();
orderID = order.ID;
isValidResult = true;
}
}
catch (Exception ex)
{
Trace.WriteLine(ex.Message);
isValidResult = false;
orderID = 0;
}
ts.Dispose();
}
return(isValidResult, orderID);
}
public (bool, FileResponseModel) GetReciptByID(int id)
{
try
{
OrdersRequestModel orders = (from order in _dbContext.Orders
join items in _dbContext.OrderItems on order.ID equals items.OrderID
where order.ID.Equals(id)
select new OrdersRequestModel()
{
Address = order.Address,
CompanyName = order.CompanyName,
MerchantID = order.MerchantID,
PhoneNumber = order.PhoneNumber,
OrderNo = order.OrderNo,
ordersDetails = _dbContext.OrderItems.Where(x => x.OrderID == id).Select(x => new OrdersDetailRequestModel()
{
Name = x.Name,
Price = x.Price,
Quantity = x.Quantity,
}).ToList()
}).FirstOrDefault();
return(true, new PdfHelper().CreateFileFromModel(orders));
}
catch (Exception ex)
{
Trace.WriteLine(ex.Message);
return(false, null);
}
}
public async Task <ActionResult> Purchase(
OrdersRequestModel model)
{
var userId = this.currentUser.UserId;
var id = await this.orders.PurchaseAsync(model, userId);
return(Created(nameof(this.Purchase), id));
}
public ActionResult Post([FromBody] OrdersRequestModel ordersRequest)
{
IPAddress remoteIpAddress = Request.HttpContext.Connection.RemoteIpAddress;
(bool isValid, int OrderID)ordersResponse = _orderService.AddOrders(ordersRequest, remoteIpAddress.ToString());
if (ordersResponse.isValid)
{
return(Ok($"{BaseURL}/{ordersResponse.OrderID}"));
}
else
{
return(BadRequest());
}
}
public async Task <OrdersResponseModel> GetOrdersForAdmin(OrdersRequestModel requestModel)
{
OrderRequestParameters parameters = requestModel.MapToRequestParameters();
(List <Order> orders, int count) = await _orderRepository.GetByParmeters(parameters);
List <OrderModel> orderModels = orders.Select(item => new OrderModel(item)).ToList();
OrdersResponseModel response = new OrdersResponseModel()
{
OrderModels = orderModels, Count = count
};
return(response);
}
public FileResponseModel CreateFileFromModel(OrdersRequestModel ordersRequestModel)
{
AddElementtoDoc(ordersRequestModel.CompanyName, TextAlignment.CENTER, 12);
AddElementtoDoc(ordersRequestModel.Address, TextAlignment.CENTER, 10);
AddElementtoDoc($"Phone: {ordersRequestModel.PhoneNumber}", TextAlignment.CENTER, 10);
AddElementtoDoc($"-----------------------------------------------------", TextAlignment.CENTER, 10);
AddTable(ordersRequestModel.ordersDetails);
AddElementtoDoc($"-----------------------------------------------------", TextAlignment.CENTER, 10);
AddElementtoDoc($"Discount:{ordersRequestModel.OverallDiscount}", TextAlignment.RIGHT, 10, 0, 0, 0, 0);
AddElementtoDoc($"Tax:{ordersRequestModel.Tax}", TextAlignment.RIGHT, 10, 0, 0, 0, 0);
AddElementtoDoc($"Total:{ordersRequestModel.ordersDetails.Select(x => x.Price).Sum()}", TextAlignment.RIGHT, 10, 0, 0, 0, 0);
PdfDocument.Close();
Document.Close();
return(new FileResponseModel(File.ReadAllBytes(FullPath), FullPath));
}
public static Order toEntity(this OrdersRequestModel requestModel, string IPAddress)
{
Order order = new Order
{
Address = requestModel.Address,
IpAddress = IPAddress,
PhoneNumber = requestModel.PhoneNumber,
MerchantID = requestModel.MerchantID,
OrderNo = requestModel.OrderNo,
CompanyName = requestModel.CompanyName,
CreatedDate = DateTime.Now,
Discount = requestModel.OverallDiscount,
Tax = requestModel.Tax
};
return(order);
}
public async Task <string> PurchaseAsync(
OrdersRequestModel model, string userId)
{
var order = new Order
{
UserId = userId,
DeliveryAddressId = model.AddressId
};
var shoppingCartProducts = await this
.Data
.ShoppingCartsProducts
.Where(sc => sc.ShoppingCart.UserId == userId)
.ToListAsync();
var orderProducts = new List <OrderProduct>();
foreach (var shoppingCartProduct in shoppingCartProducts)
{
var productId = shoppingCartProduct.ProductId;
var requestQuantity = shoppingCartProduct.Quantity;
var orderProduct = new OrderProduct
{
Order = order,
ProductId = productId,
Quantity = requestQuantity
};
orderProducts.Add(orderProduct);
await this.ReduceProductQuantity(productId, requestQuantity);
}
this.Data.RemoveRange(shoppingCartProducts);
await this.Data.AddRangeAsync(orderProducts);
await this.Data.SaveChangesAsync();
return(order.Id);
}
public static bool isValid(this OrdersRequestModel requestModel)
{
bool _modelValidated = true;
if (string.IsNullOrEmpty(requestModel.MerchantID))
{
_modelValidated = false;
}
if (requestModel.ordersDetails is null || requestModel.ordersDetails.Count.Equals(0))
{
_modelValidated = false;
}
if (requestModel.OrderNo == 0)
{
_modelValidated = false;
}
if (string.IsNullOrEmpty(requestModel.CompanyName))
{
_modelValidated = false;
}
if (string.IsNullOrEmpty(requestModel.Address))
{
_modelValidated = false;
}
requestModel.ordersDetails.ForEach(item =>
{
if (string.IsNullOrEmpty(item.Name))
{
_modelValidated = false;
}
if (item.Price.Equals(0))
{
_modelValidated = false;
}
if (item.Quantity.Equals(0))
{
_modelValidated = false;
}
});
return(_modelValidated);
}
public async Task <OrdersResponseModel> GetOrdersForAdmin([FromBody] OrdersRequestModel requestModel)
{
OrdersResponseModel responseModel = await _orderService.GetOrdersForAdmin(requestModel);
return(responseModel);
}
public async Task <ActionResult <string> > Create(OrdersRequestModel model)
{
return(await _ordersService
.CreateOrders(model, _currentUser.UserId)
.ToActionResult());
}
public async Task <Result> CreateOrders(OrdersRequestModel model, string userId)
{
var order = new Order
{
UserId = userId,
AddressId = model.AddressId,
DeliveryId = model.DeliveryId,
PaymentId = model.PaymentId,
Status = OrderStatus.Pay
};
await Data.AddAsync(order)
.ConfigureAwait(false);
var productsAttributes = await Data
.CartItem
.Where(x => x.UserId == userId)
.ToListAsync()
.ConfigureAwait(false);
if (productsAttributes.Count == 0)
{
return(EmptyCart);
}
var payment = await Data.Payment.FindAsync(order.PaymentId);
var delivery = await Data.Delivery.FindAsync(order.DeliveryId);
var tax = await TotalTax(productsAttributes.Select(x => x.ProductAttributeId)).ConfigureAwait(false);
if (payment.Percentage > 0)
{
tax += tax * (decimal)payment.Percentage / 100;
}
tax += delivery.Price;
order.TotalTax = tax;
var products = new List <OrderItem>();
foreach (var orderModel in productsAttributes)
{
var guidId = orderModel.ProductAttributeId;
var orderItem = new OrderItem
{
Order = order,
ProductAttributeId = guidId,
Quantity = orderModel.Quantity
};
products.Add(orderItem);
await ReduceProductQuantity(guidId, orderModel.Quantity)
.ConfigureAwait(false);
}
Data.RemoveRange(productsAttributes);
await Data.OrderItem.AddRangeAsync(products)
.ConfigureAwait(false);
await Data.SaveChangesAsync()
.ConfigureAwait(false);
return(Result.Success);
}
