private async Task <bool> IsProductAlreadyOrdered(OrderServiceModel orderService)
{
var allOrders = await GetAll().ToListAsync();
var ordaredOrder = new OrderServiceModel();
var result = num;
foreach (var currOrder in allOrders)
{
if (currOrder.ProductId == orderService.ProductId)
{
ordaredOrder = currOrder;
var orderAlreadyOrdered = await this.context.Orders
.SingleOrDefaultAsync(or => or.Id == ordaredOrder.Id);
orderAlreadyOrdered.Quantity++;
await Task.Run(() => this.context.Orders.Update(orderAlreadyOrdered));
result = await this.context.SaveChangesAsync();
return(result > num);
}
}
return(result > num);
}
public void GetOrderByIdAndUserId_WithExistentId_ShouldReturnCorrectResults()
{
string errorMessagePrefix = "OrdersService GetOrderByIdAndUserId() method does not work properly.";
var context = UniShopDbContextInMemoryFactory.InitializeContext();
this.SeedData(context);
ShoppingCartsService shoppingCartsService = new ShoppingCartsService(context, new UniShopUsersService(context),
new ProductsService(context, new ChildCategoriesService(context, new ParentCategoriesService(context))));
this.orderService = new OrdersService(context, new UniShopUsersService(context), shoppingCartsService, new SuppliersService(context),
new ProductsService(context, new ChildCategoriesService(context, new ParentCategoriesService(context))));
UniShopUser user = context.Users.First();
Order order = new Order
{
OrderStatus = OrderStatus.Processed,
UniShopUserId = user.Id,
};
context.Add(order);
context.SaveChanges();
OrderServiceModel expectedResults = user.Orders.First().To <OrderServiceModel>();
OrderServiceModel actualResults = this.orderService.GetOrderByIdAndUserId(expectedResults.Id, user.Id);
Assert.True(expectedResults.Id == actualResults.Id, errorMessagePrefix + " " + "Id is not returned properly.");
Assert.True(expectedResults.OrderStatus == actualResults.OrderStatus, errorMessagePrefix + " " + "OrderStatus is not returned properly.");
Assert.True(expectedResults.UniShopUserId == actualResults.UniShopUserId, errorMessagePrefix + " " + "UniShopUserId Count is not returned properly.");
}
protected async Task <bool> AddOrderProduct(OrderServiceModel order, List <ProductDTO> products, int orderId)
{
var productIds = order.OrderProducts.Select(x => x.ProductId).ToList();
for (var i = 0; i < productIds.Count; i++)
{
var productId = productIds[i];
var product = products.FirstOrDefault(x => x.Id == productId && x.IsAvailable);
var orderQuantity = order.OrderProducts.Single(x => x.ProductId == productId).Quantity;
if (!IsValidProduct(product, orderQuantity, i))
{
continue;
}
product.AvailableCount -= orderQuantity;
if (product.AvailableCount == 0)
{
product.IsAvailable = false;
}
await _unitOfWork.OrderProductRepository.InsertAsync(new OrderProductDTO { OrderId = orderId, ProductId = productId, Quantity = orderQuantity });
}
return(_validationDictionary.IsValid);
}
public async Task ReduceQuantity_WithExistentId_ShouldSuccessfullyReduceQuantity()
{
string errorMessagePrefix = "OrderService ReduceQuantity() method does not work properly.";
var context = ContextFactory.Initializer();
await SeedData(context);
this.orderService = new OrderService(context);
OrderServiceModel testOrder = context.Orders.First().To <OrderServiceModel>();
await this.orderService.ReduceQuantity(testOrder.Id);
int actualQuantity = 0;
int expectedQuantity = 0;
if (testOrder.Quantity >= 1)
{
expectedQuantity = testOrder.Quantity - 1;
}
else
{
actualQuantity = context.Orders.First().Quantity;
}
Assert.True(expectedQuantity == actualQuantity, errorMessagePrefix);
}
public void GetOrderByIdAndUserId_WithNonCorrectData_ShouldReturnNull()
{
string errorMessagePrefix = "OrdersService GetOrderByIdAndUserId() method does not work properly.";
var context = UniShopDbContextInMemoryFactory.InitializeContext();
this.SeedData(context);
string userId = context.Users.First().Id;
string nonExistentUserId = userId + new Guid();
Order order = new Order
{
OrderStatus = OrderStatus.Processed,
UniShopUserId = userId,
};
context.Add(order);
context.SaveChanges();
ShoppingCartsService shoppingCartsService = new ShoppingCartsService(context, new UniShopUsersService(context),
new ProductsService(context, new ChildCategoriesService(context, new ParentCategoriesService(context))));
this.orderService = new OrdersService(context, new UniShopUsersService(context), shoppingCartsService, new SuppliersService(context),
new ProductsService(context, new ChildCategoriesService(context, new ParentCategoriesService(context))));
OrderServiceModel actualResults = this.orderService.GetOrderByIdAndUserId(order.Id, nonExistentUserId);
Assert.True(actualResults == null, errorMessagePrefix);
}
public async Task Create_WithNonExistentEvent_ShouldNotChangeAnything()
{
// Arrange
var context = new EventuresDbContext(new DbContextOptionsBuilder <EventuresDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var ordersService = new OrdersService(context);
var user = new EventuresUser
{
UserName = "******"
};
await context.Users.AddAsync(user);
await context.SaveChangesAsync();
var model = new OrderServiceModel
{
EventId = Guid.NewGuid().ToString(),
TicketsCount = 2
};
// Act
var result = await ordersService.Create(model, user.UserName);
// Assert
Assert.False(result);
var count = await context.Orders.CountAsync();
Assert.Equal(0, count);
}
public async Task <bool> Create(OrderServiceModel orderService)
{
//IsProductAlreadyOrderedResult to increase quantity
var IsProductAlreadyOrderedResult = await IsProductAlreadyOrdered(orderService);
if (IsProductAlreadyOrderedResult)
{
return(true);
}
Order order = orderService.To <Order>();
var issuedOn = DateTime.UtcNow;
order.Quantity = orderQuantity;
order.IssuedOn = DateTime.UtcNow;
order.OrderStatus = await this.context.OrderStatuses
.SingleOrDefaultAsync(os => os.Name == ServicesGlobalConstants.OrderStatusActive);
await this.context.Orders.AddAsync(order);
var result = await this.context.SaveChangesAsync();
return(result > num);
}
public async Task <bool> Create(OrderServiceModel model, string userName)
{
if (!this.IsEntityStateValid(model))
{
return(false);
}
var user = await this.context.Users.SingleOrDefaultAsync(u => u.UserName == userName);
var ev = await this.context.Events.SingleOrDefaultAsync(e => e.Id == model.EventId);
if (user == null || ev == null || ev.TotalTickets < model.TicketsCount)
{
return(false);
}
var order = Mapper.Map <Order>(model);
order.User = user;
ev.TotalTickets -= model.TicketsCount;
this.context.Events.Update(ev);
await this.context.Orders.AddAsync(order);
await this.context.SaveChangesAsync();
return(true);
}
/// <summary>
/// Update Orders's information in DB
/// </summary>
/// <param name="order"></param>
/// <returns>result status</returns>
public async Task <bool> UpdateAsync(OrderServiceModel order)
{
var oldOrder = await this.GetOrderFromDBAsync(order.Id);
var updatedOrder = order.UpdateProperties(oldOrder);
return(await this.orderRepository.UpdateAsync(updatedOrder));
}
public async Task <OrderServiceModel> CreateAsync(OrderServiceModel orderServiceModel, string username, decimal deliveryPrice)
{
var shoppingCartProducts = this.shoppingCartService
.GetAllShoppingCartProducts(username)
.ToList();
if (shoppingCartProducts.Count == 0)
{
throw new ArgumentNullException(nameof(shoppingCartProducts));
}
var user = this.userService.GetUserByUsername(username);
var supplier = this.supplierService.GetSupplierById(orderServiceModel.SupplierId);
Order order = orderServiceModel.To <Order>();
foreach (var shoppingCartProduct in shoppingCartProducts)
{
order.OrderProducts.Add(new OrderProduct
{
Order = order,
ProductId = shoppingCartProduct.ProductId,
Price = shoppingCartProduct.Product.Price,
Quantity = shoppingCartProduct.Quantity
});
await this.productService.DecreaseQuantityInStock(shoppingCartProduct.ProductId,
shoppingCartProduct.Quantity);
}
order.OrderProducts = shoppingCartProducts
.Select(scp => new OrderProduct
{
Order = order,
ProductId = scp.ProductId,
Price = scp.Product.Price,
Quantity = scp.Quantity
})
.ToList();
await this.shoppingCartService.RemoveAllProductFromShoppingCart(username);
OrderStatus orderStatus = this.context.OrderStatuses.FirstOrDefault(x => x.Name == GlobalConstants.Unprocessed) ?? throw new ArgumentNullException(nameof(orderStatus));
PaymentStatus paymentStatus = this.context.PaymentStatuses.FirstOrDefault(x => x.Name == GlobalConstants.Unpaid) ?? throw new ArgumentNullException(nameof(paymentStatus));
order.DeliveryPrice = deliveryPrice;
order.OrderDate = DateTime.UtcNow;
order.UserId = user.Id;
order.OrderStatusId = orderStatus.Id;
order.PaymentStatusId = paymentStatus.Id;
order.TotalPrice = order.OrderProducts.Sum(product => product.Price * product.Quantity);
order.ExpectedDeliveryDate = DateTime.UtcNow.AddDays(supplier.DeliveryTimeInDays);
this.context.Orders.Add(order);
this.context.SaveChanges();
return(order.To <OrderServiceModel>());
}
public async Task <IActionResult> Order(ProductOrderInputModel productOrderInputModel)
{
OrderServiceModel orderServiceModel = productOrderInputModel.To <OrderServiceModel>();
orderServiceModel.IssuerId = this.User.FindFirst(ClaimTypes.NameIdentifier).Value;
await this.orderService.CreateOrder(orderServiceModel);
return(this.Redirect("/"));
}
public IActionResult Create(OrderCreateInputModel orderCreateInputModel)
{
string userId = this.User.FindFirst(ClaimTypes.NameIdentifier).Value;
OrderServiceModel orderServiceModel = AutoMapper.Mapper.Map <OrderServiceModel>(orderCreateInputModel);
this.orderService.Create(orderServiceModel, userId);
return(Redirect("/Order/Details"));
}
/// <summary>
/// Verfiying and placing of Order object into the database
/// </summary>
/// <param name="order">Partially assembled Order object</param>
/// <param name="customerId">Cutomer ID of customer placing order</param>
/// <returns>Bool verifying Save, if false, save did not occur and Amount cannot be 0</returns>
public bool PlaceOrder(Order order, int customerId)
{
Customer customer = CustomerRepository.Load(customerId);
OrderServiceModel result = OrderVerification(order, customer);
if (result.Result)
{
orderRepository.Save(result.Order);
}
return(result.Result);
}
/// <summary>
/// Add new Order to DB
/// </summary>
/// <param name="order"></param>
/// <returns>new Orders's id</returns>
public async Task <Guid> SaveAsync(OrderServiceModel order)
{
var repositoryOrder = new Order
{
Id = order.Id,
AddressId = order.AddressId,
CustomerId = order.CustomerId
};
return(await this.orderRepository.InsertAsync(repositoryOrder));
}
public async Task <IActionResult> Order(ProductOrderInputModel inputModel)
{
OrderServiceModel orderServiceModel = inputModel.To <OrderServiceModel>();
//orderServiceModel.IssuerId = this.User.Identity.Name;
//note: това търси този, който го е създал, а не този, който купува!!!! ?????
orderServiceModel.IssuerId = this.User.FindFirst(ClaimTypes.NameIdentifier).Value;
await this.orderService.CreateOrder(orderServiceModel);
return(this.Redirect("/Home/Index"));
}
public async Task <bool> CreateOrder(OrderServiceModel orderServiceModel)
{
Order order = orderServiceModel.To <Order>();
order.OrderStatus = await this.context.OrderStatuses.SingleOrDefaultAsync(orderStatus => orderStatus.Name == GlobalConstants.OrderStatusActive);
order.CreatedOn = DateTime.UtcNow;
this.context.Orders.Add(order);
int result = await this.context.SaveChangesAsync();
return(result > 0);
}
public async Task <IActionResult> Order(string id)
//TODO: add quantity in details view
{
var inputModel = new OrderServiceModel();
OrderServiceModel orderServiceModel = inputModel.To <OrderServiceModel>();
orderServiceModel.IssuerId = await Task.Run(() => this.User.FindFirst(ClaimTypes.NameIdentifier).Value);
orderServiceModel.ProductId = id;
await this.ordersService.Create(orderServiceModel);
return(this.RedirectToAction("Cart", "Orders"));
}
public async Task <bool> Create(OrderServiceModel orderServiceModel)
{
Order order = new Order
{
Status = OrderStatus.Active,
DatePlaced = DateTime.UtcNow,
Quantity = orderServiceModel.Quantity
};
this.dbContext.Orders.Add(order);
int result = await this.dbContext.SaveChangesAsync();
return(result > 0);
}
public async Task Create_WithValidModel_ShouldWorkCorrectly()
{
// Arrange
const int ticketsCount = 10;
var context = new EventuresDbContext(new DbContextOptionsBuilder <EventuresDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var ordersService = new OrdersService(context);
var user = new EventuresUser
{
UserName = "******"
};
await context.Users.AddAsync(user);
var eventModel = new EventuresEvent
{
Name = "TestEvent",
TotalTickets = ticketsCount
};
await context.Events.AddAsync(eventModel);
await context.SaveChangesAsync();
var model = new OrderServiceModel
{
OrderedOn = DateTime.UtcNow,
EventId = eventModel.Id,
TicketsCount = 2
};
// Act
var result = await ordersService.Create(model, user.UserName);
// Assert
Assert.True(result);
var remainingTickets = (await context.Events.SingleAsync()).TotalTickets;
Assert.Equal(ticketsCount - model.TicketsCount, remainingTickets);
var count = await context.Orders.CountAsync();
Assert.Equal(1, count);
var orderUserId = (await context.Orders.SingleAsync()).UserId;
Assert.Equal(user.Id, orderUserId);
}
public async Task <bool> CreateOrderAsync(OrderServiceModel orderServiceModel)
{
Order order = orderServiceModel.To <Order>();
order.Status = await finalWebProjectDbContext.OrderStatuses
.SingleOrDefaultAsync(orderStatus => orderStatus.Name == "Active");
order.IssuedOn = DateTime.UtcNow;
this.finalWebProjectDbContext.Orders.Add(order);
int result = await this.finalWebProjectDbContext.SaveChangesAsync();
return(result > 0);
}
public async Task <IActionResult> Order(ProductOrderInputModel productOrderInputModel)
{
var orderServiceModel = new OrderServiceModel
{
ProductId = productOrderInputModel.ProductId,
Quantity = productOrderInputModel.Quantity,
};
orderServiceModel.IssuerId = this.User.FindFirst(ClaimTypes.NameIdentifier).Value;
await this.orderService.CreateOrder(orderServiceModel);
return(this.Redirect("/"));
}
public OrderServiceModel GetOrderById(int orderId)
{
OrderServiceModel orderFromDb = this.context.Orders
.Include(x => x.OrderProducts)
.ThenInclude(x => x.Product.Images)
.To <OrderServiceModel>()
.SingleOrDefault(x => x.Id == orderId);
if (orderFromDb == null)
{
throw new ArgumentNullException(nameof(orderFromDb));
}
return(orderFromDb);
}
public async Task <bool> CreateOrder(OrderServiceModel orderServiceModel)
{
var order = orderServiceModel.To <Order>();
order.Id = Guid.NewGuid().ToString();
order.Status = await this.context.OrderStatuses.FirstOrDefaultAsync(status => status.Name == "Active");
order.IssuedOn = DateTime.UtcNow;
await this.context.Orders.AddAsync(order);
var result = await this.context.SaveChangesAsync();
return(result > 0);
}
public async Task CreateOrder_WithCorrectData_ShouldSuccessfullyCreateOrder()
{
string errorMessagePrefix = "OrderService Create() method does not work properly.";
var context = ContextFactory.Initializer();
await SeedData(context);
this.orderService = new OrderService(context);
OrderServiceModel testReceipt = new OrderServiceModel();
bool actualResult = await this.orderService.CreateOrderAsync(testReceipt);
Assert.True(actualResult, errorMessagePrefix);
}
public async Task <IActionResult> Order(WineOrderInputModel wineOrderInputModel)
{
OrderServiceModel orderServiceModel = new OrderServiceModel
{
WineId = wineOrderInputModel.WineId,
Quantity = wineOrderInputModel.Quantity
};
orderServiceModel.IssuerId = this.User.FindFirst(ClaimTypes.NameIdentifier).Value;
await this.ordersService.CreateOrder(orderServiceModel);
return(Redirect("/Wines/All"));
}
public async Task Create_WithNotEnoughAvailableTickets_ShouldNotAddToDatabase()
{
// Arrange
const int ticketsCount = 10;
var context = new ApplicationDbContext(new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var ordersService = new OrdersService(context);
var user = new EventuresUser
{
UserName = "******"
};
await context.Users.AddAsync(user);
var eventModel = new Event
{
Name = "TestEvent123",
TotalTickets = ticketsCount
};
await context.Events.AddAsync(eventModel);
await context.SaveChangesAsync();
var model = new OrderServiceModel
{
OrderedOn = DateTime.UtcNow,
EventId = eventModel.Id,
TicketsCount = 20
};
// Act
var result = await ordersService.Create(model, user.UserName);
// Assert
Assert.False(result);
var remainingTickets = (await context.Events.SingleAsync()).TotalTickets;
Assert.Equal(ticketsCount, remainingTickets);
var count = await context.Orders.CountAsync();
Assert.Equal(0, count);
}
public async Task ReduceQuantity_WithExistentIdAndOneQuantity_ShouldNotReduceQuantity()
{
string errorMessagePrefix = "OrderService ReduceQuantity() method does not work properly.";
var context = StopifyDbContextInMemoryFactory.InitializeContext();
await SeedData(context);
this.orderService = new OrderService(context);
OrderServiceModel testOrder = context.Orders.First(order => order.Quantity == 1).To <OrderServiceModel>();
await this.orderService.ReduceQuantity(testOrder.Id);
int expectedQuantity = 1;
int actualQuantity = context.Orders.First(order => order.Id == testOrder.Id).Quantity;
Assert.True(expectedQuantity == actualQuantity, errorMessagePrefix);
}
public async Task <bool> InsertOrderAsync(OrderServiceModel order)
{
try
{
await _unitOfWork.BeginTransactionAsync();
var products = await _unitOfWork.ProductRepository.GetAllAsyncWithTracking();
var users = await _unitOfWork.UserRepository.GetAllAsyncWithNoTracking();
var user = users.FirstOrDefault(x => x.Id == order.UserId);
if (user == null)
{
_validationDictionary.AddError("UserId", "შეყვანილი იუზერი არ არსებობს!");
return(false);
}
var newOrder = new OrderDTO {
UserId = order.UserId,
};
await _unitOfWork.OrderRepository.InsertAsync(newOrder);
if (!await AddOrderProduct(order, products.ToList(), newOrder.Id))
{
await _unitOfWork.RollbackAsync();
return(false);
}
await _unitOfWork.SaveChangesAsync();
await _unitOfWork.CommitAsync();
return(true);
}
catch (Exception)
{
await _unitOfWork.RollbackAsync();
throw;
}
}
public async Task <string> CreateAsync(OrderServiceModel input)
{
var billingFrequency = input.ServiceFrequency == ServiceFrequency.Once ? BillingFrequency.Once : BillingFrequency.Monthly;
var teamId = this.teamsService
.GetFreeTeams <TeamServiceModel>(input.AppointmentDate, input.AppointmentDate.AddHours(input.ServiceDuration), input.CityId, input.ServiceId, input.ServiceFrequency)
.OrderBy(t => this.GetTotalMonthJobsTime(input.ServiceId, input.AppointmentDate, t.Id))
.FirstOrDefault().Id;
var order = new Order()
{
ServiceId = input.ServiceId,
Status = OrderStatus.Pending,
ClientId = input.ClientId,
AddresId = input.AddressId,
BillingFrequency = billingFrequency,
ServiceFrequency = input.ServiceFrequency,
TeamId = teamId,
};
await this.ordersRepository.AddAsync(order);
await this.ordersRepository.SaveChangesAsync();
var appointment = await this.appointmentsService.CreateAsync(input.AppointmentDate, input.ServiceDuration, order.Id);
order.AppointmetnId = appointment.Id;
await this.jobsService.CreateAsync(order.Id, order.ServiceFrequency, appointment.StartDate, appointment.EndDate);
if (!input.IsRecurrent || order.BillingFrequency == BillingFrequency.Once)
{
var jobsCount = this.ordersRepository.All()
.Where(o => o.Id == order.Id)
.SelectMany(o => o.Jobs)
.Where(j => j.JobStatus == JobStatus.InProgress)
.Count();
await this.invoicesService.CreateAsync(order.Id, order.ClientId, order.ServiceId, order.ServiceFrequency, order.AddresId, jobsCount);
}
return(order.Id);
}
public async Task Create(OrderServiceModel order)
{
var actionItem = await _actionItemRepository.Get(order.ActionItemId);
if (actionItem == null)
{
throw new EntryNotFoundException($"The entry with id '{order.ActionItemId}' was not found");
}
var newOrder = new Order()
{
ActionItem = actionItem,
Customer = order.Customer,
Tickets = order.Tickets
};
_ordersRepository.Create(newOrder);
await _ordersRepository.SaveChanges();
}