public async Task <IActionResult> AddCartItem(int?quantity, string productName, string locationName)
{
// Get the user who's azdding the item to the cart
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
VendorAppUser user = await userManager.GetUserAsync(User);
LocationInventory targetLocationInventory = await cartRepo.GetLocationInventoryByProductAndLocationName(locationName, productName);
// Redirect user back to product page if any of the paramerters aren't valid
if (quantity == null || productName == null || locationName == null || targetLocationInventory == null)
{
TempData["ErrorMessage"] = "Please enter valid input";
return(Redirect(Request.Headers["Referer"]));
}
if (quantity > targetLocationInventory.Quanitity || quantity <= 0)
{
TempData["ErrorMessage"] = "Please enter a valid quantity";
return(Redirect(Request.Headers["Referer"]));
}
// Add item to cart
await cartRepo.AddItemToCart(userId, productName, locationName, quantity ?? -1);
// Document changes
TempData["FlashMessage"] = "Added to cart";
cartLogger.LogInformation($"{productName} was added to {user.UserName}'s cart");
// Take client back to list of products
return(RedirectToAction("Index", "Product"));
}
public async void ItShouldRemoveAnOrderItem()
{
//Given
EFCoreOrderRepository orderRepo = new EFCoreOrderRepository(ctx);
EFCoreUserRepository userRepo = new EFCoreUserRepository(ctx);
await userRepo.Add(mockUser);
VendorAppUser newUser = (await userRepo.GetAll()).ElementAt(0);
//When
mockOrder.User = newUser;
await orderRepo.Add(mockOrder);
Order tempOrder = (await orderRepo.GetAll()).ElementAt(0);
tempOrder.OrderItems = new List <OrderItem> {
mockOrderItem
};
await orderRepo.Update(tempOrder);
OrderItem tempOrderItem = (await orderRepo.GetAllOrderItems()).ElementAt(0);
await orderRepo.RemoveOrderItem(tempOrderItem.ID);
//Then
Assert.Equal(0, (await orderRepo.GetAllOrderItems()).Count());
}
public async void ItShouldUpdateAOrder()
{
//Given
EFCoreOrderRepository orderRepo = new EFCoreOrderRepository(ctx);
EFCoreUserRepository userRepo = new EFCoreUserRepository(ctx);
await userRepo.Add(mockUser);
VendorAppUser newUser = (await userRepo.GetAll()).ElementAt(0);
//When
mockOrder.User = newUser;
await orderRepo.Add(mockOrder);
Order tempOrder = (await orderRepo.GetAll()).ElementAt(0);
tempOrder.OrderItems = new List <OrderItem> {
mockOrderItem
};
await orderRepo.Update(tempOrder);
//Then
Order actualOrder = (await orderRepo.GetAll()).ElementAt(0);
Assert.Equal(1, actualOrder.OrderItems.Count());
}
public async void ItShouldUpdateAnOrderItem()
{
//Given
EFCoreOrderRepository orderRepo = new EFCoreOrderRepository(ctx);
EFCoreUserRepository userRepo = new EFCoreUserRepository(ctx);
await userRepo.Add(mockUser);
VendorAppUser newUser = (await userRepo.GetAll()).ElementAt(0);
//When
mockOrder.User = newUser;
await orderRepo.Add(mockOrder);
Order tempOrder = (await orderRepo.GetAll()).ElementAt(0);
tempOrder.OrderItems = new List <OrderItem> {
mockOrderItem
};
await orderRepo.Update(tempOrder);
OrderItem tempOrderItem = (await orderRepo.GetAllOrderItems()).ElementAt(0);
tempOrderItem.ProductName = "New Product Name";
await orderRepo.UpdateOrderItem(tempOrderItem);
//Then
OrderItem actualOrderItem = (await orderRepo.GetAllOrderItems()).ElementAt(0);
Assert.Equal("New Product Name", actualOrderItem.ProductName);
}
/// <summary>
/// Show the cart of the currently logged in user
/// </summary>
/// <returns></returns>
public async Task <IActionResult> Index()
{
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
VendorAppUser vendorAppUser = await userManager.GetUserAsync(User);
Cart userCart = await cartRepo.FindCartByUserId(userId);
// string loggedInUserId = userManager.GetUserId;
// return Content($"Here's a cart for ya -- {userCart.ToString()}");
return(View(userCart));
}
/// <summary>
/// Adds an item to a user's cart. Creates a cart record if one hasn't been added for the
/// user. Returns null if the item was not sucessfully added to the cart.
/// </summary>
/// <param name="userId">Id of the user of the cart</param>
/// <param name="productName">Name of the product being added</param>
/// <param name="quantity">The amount of the product being added</param>
/// <returns></returns>
public async Task <Cart> AddItemToCart(string userId, string productName, string locationName, int quantity)
{
// Get instance of user from id
EFCoreUserRepository userRepo = new EFCoreUserRepository(context);
VendorAppUser user = await userRepo.Get(userId);
Cart userCart;
// If user doesn't exist stop process and return null
if (user == null)
{
return(null);
}
// Check if user already has cart for us to use
// If user has no cart, create one for them
userCart = await FindCartByUserId(userId);
if (userCart == null)
{
// userCart = new Cart
// {
// User = user
// };
user.Cart = new Cart();
}
// add item to cart
CartItem newItem = new CartItem
{
Cart = user.Cart,
ProductName = productName,
LocationName = locationName,
AmountPurchased = quantity
};
context.CartItems.Add(newItem);
// Update the location inventory and the amount of cart items a user has
LocationInventory updateLocatInventory =
await new EFCoreLocationRepository(context)
.RemoveInventory(newItem.AmountPurchased, newItem.LocationName, newItem.ProductName);
// TODO: Update location inventory without using repo
user.NumCartItems++;
// save changes
context.SaveChanges();
return(userCart);
}
/// <summary>
/// Dispalys a list of orders for the current user
/// </summary>
/// <returns>A view to present the user's order</returns>
public async Task <IActionResult> Customer()
{
// Use logged in user to get orders by userId
VendorAppUser user = await userManager.GetUserAsync(User);
List <Order> userOrders = await orderRepo.GetOrdersByUserId(user.Id) as List <Order>;
// return list to view
return(View(new UserOrders {
UserName = user.UserName,
Orders = userOrders
}));
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new VendorAppUser {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = user.Id, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email }));
}
else
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public async void ItShouldCreateAOrder()
{
//Given
EFCoreOrderRepository orderRepo = new EFCoreOrderRepository(ctx);
EFCoreUserRepository userRepo = new EFCoreUserRepository(ctx);
await userRepo.Add(mockUser);
VendorAppUser newUser = (await userRepo.GetAll()).ElementAt(0);
//When
mockOrder.User = newUser;
await orderRepo.Add(mockOrder);
//Then
Order actualOrder = (await orderRepo.GetAll()).ElementAt(0);
Assert.Equal(1, actualOrder.ID);
}
public async void ItShouldRemoveAOrder()
{
//Given
EFCoreOrderRepository orderRepo = new EFCoreOrderRepository(ctx);
EFCoreUserRepository userRepo = new EFCoreUserRepository(ctx);
await userRepo.Add(mockUser);
VendorAppUser newUser = (await userRepo.GetAll()).ElementAt(0);
//When
mockOrder.User = newUser;
await orderRepo.Add(mockOrder);
Order tempOrder = (await orderRepo.GetAll()).ElementAt(0);
await orderRepo.Delete(tempOrder.ID);
//Then
Assert.Equal(0, (await orderRepo.GetAll()).Count());
}
public LogicTest()
{
var opts = new DbContextOptionsBuilder <P1ProtoDBContext>()
.UseSqlite("Filename=Test.db")
.Options;
mockUser = new VendorAppUser
{
UserName = "******"
};
mockLocation = new Location
{
Name = "location"
};
mockProduct = new Product
{
Name = "product",
Catagory = "catagory",
FAClass = "icon"
};
mockLocationInventory = new LocationInventory
{
Product = mockProduct,
Location = mockLocation,
Quanitity = 1
};
mockOrder = new Order();
mockOrderItem = new OrderItem
{
ProductName = "product",
LocationName = "location",
AmountPurchased = 1
};
ctx = new P1ProtoDBContext(opts);
Seed();
}
// TODO: add docs
// public async Task<Cart> RegisterPurchase(string userId)
// {
// Cart userCart = await FindCartByUserId(userId);
// EFCoreOrderRepository orderRepo = new EFCoreOrderRepository(context);
// await orderRepo.RecordOrder(userId);
// return userCart;
// }
// TODO: add docs
public async Task <Cart> RegisterPurchase(int cartId)
{
// Retreive cart by id
Cart cart =
await context.Carts.Include(c => c.User).Include(c => c.CartItems)
.FirstOrDefaultAsync(c => c.ID == cartId);
VendorAppUser cartUser = cart.User;
// Create a blank order record for the user with an empty set of order items
Order newOrder = new Order
{
User = cartUser,
OrderItems = new List <OrderItem>()
};
// store the cart items list to the order items list
foreach (var cartItem in cart.CartItems)
{
newOrder.OrderItems.Add(new OrderItem
{
ProductName = cartItem.ProductName,
LocationName = cartItem.LocationName,
AmountPurchased = cartItem.AmountPurchased
});
}
// Remove the cart and reset users number of cart tiems
cartUser.NumCartItems = 0;
context.Carts.Remove(cart);
// Add order to db
context.Orders.Add(newOrder);
// save the changes
await context.SaveChangesAsync();
return(cart);
}
public async void ItShouldUpdateUsersNumCartItems()
{
//Given
EFCoreCartRepository cartRepo = new EFCoreCartRepository(ctx);
EFCoreUserRepository userRepo = new EFCoreUserRepository(ctx);
VendorAppUser newUser = new VendorAppUser();
//When
await userRepo.Add(newUser);
newUser = (await userRepo.GetAll()).ElementAt(0);
await cartRepo.AddItemToCart(newUser.Id, "product", "location", 1);
//Then
VendorAppUser actualUser = (await userRepo.GetAll()).ElementAt(0);
Assert.Equal(1, actualUser.NumCartItems);
}
public async void ItShouldFetchCartFromUser()
{
// * Arrange
EFCoreCartRepository cartRepo = new EFCoreCartRepository(ctx);
// Mock user
string userId = "user-id";
VendorAppUser tempUser = new VendorAppUser
{
Id = userId
};
Cart newCart = new Cart();
// * Act
newCart.User = tempUser;
await cartRepo.Add(newCart);
// * Assert
Cart actualCart = await cartRepo.FindCartByUserId(userId);
Assert.NotNull(actualCart);
}
public async void ItShouldClearUsersCart()
{
EFCoreCartRepository cartRepo = new EFCoreCartRepository(ctx);
EFCoreUserRepository userRepo = new EFCoreUserRepository(ctx);
VendorAppUser newUser = new VendorAppUser();
await userRepo.Add(newUser);
newUser = (await userRepo.GetAll()).ElementAt(0);
Cart newCart = new Cart
{
User = newUser
};
await cartRepo.Add(newCart);
List <Cart> fetched = await cartRepo.GetAll();
await cartRepo.Delete(fetched.ElementAt(0).ID);
Assert.Equal(0, (await cartRepo.GetAll()).Count());
}
public async void ItShouldAddCartItemsForUser()
{
// * Arrange
EFCoreCartRepository cartRepo = new EFCoreCartRepository(ctx);
// Make a mock user who will own the cart
string userId = "user-id";
VendorAppUser tempUser = new VendorAppUser
{
Id = userId
};
// Mock<EFCoreUserRepository> mockUser = new Mock<EFCoreUserRepository>();
// mockUser.Setup(u => u.Get(userId)).ReturnsAsync(tempUser);
// Make a cart
Cart newCart = new Cart
{
User = tempUser,
CartItems = new List <CartItem>()
};
// * Act
// Add cart to DbContext
await cartRepo.Add(newCart);
// Make some cart items
CartItem c1 = new CartItem
{
Cart = newCart,
ProductName = "Product1",
AmountPurchased = 2
};
CartItem c2 = new CartItem
{
Cart = newCart,
ProductName = "Product2",
AmountPurchased = 2
};
CartItem c3 = new CartItem
{
Cart = newCart,
ProductName = "Product3",
AmountPurchased = 4
};
// Add items to cart
await cartRepo.AddItemToCart(userId, "Product0", "Location0", 2);
await cartRepo.AddItemToCart(userId, "Product1", "Location1", 10);
await cartRepo.AddItemToCart(userId, "Product2", "Location2", 50);
// * Assert
// Retrive Cart back from context
Cart actualCart = await cartRepo.FindCartByUserId(tempUser.Id);
// Assert all values
Assert.Equal(userId, actualCart.User.Id);
// Check all cart items
List <CartItem> actualCartItems = (List <CartItem>)actualCart.CartItems;
Assert.Equal(3, actualCartItems.Count);
Assert.Equal("Product0", actualCartItems[0].ProductName);
Assert.Equal(2, actualCartItems[0].AmountPurchased);
Assert.Equal("Product2", actualCartItems[2].ProductName);
Assert.Equal(50, actualCartItems[2].AmountPurchased);
}
