public void InitializeTest()
{
_cartRepository = new CartRepository();
_cartRepository.Add(new CartItem(_products[0], 1));
_cartRepository.Add(new CartItem(_products[1], 2));
}
public void AddProductstoCart_DifferentProduct()
{
var waitValue = 3;
var p = new Product("Muz", 15, 1);
_cartRepository.Add(new CartItem(p, 3));
Assert.AreEqual(waitValue, _cartRepository.CartItemCount(userId));
}
public Cart Create(CartItem cartItem)
{
var cartId = cartRepository.Create();
cartItem.CartId = cartId;
cartRepository.Add(cartItem);
var newCart = cartRepository.Get(cartId);
return(newCart);
}
public async Task <IActionResult> AddCourseToCart([FromBody] CartViewModel cartViewModel)
{
try
{
Cart cart = await cartRepository.GetByCourseIdAndStudentId(cartViewModel.CourseId, cartViewModel.StudentId);
if (cart == null)
{
Cart cartMapped = mapper.Map <Cart>(cartViewModel);
await cartRepository.Add(cartMapped);
return(Ok(new
{
Results = cartMapped
}));
}
else
{
return(BadRequest(new
{
Errors = new { Code = "CourseExistedInCart", Description = "Course has already existed in Cart!" }
}));
}
}
catch (Exception e)
{
Console.WriteLine($"ErrorMesages: {e}");
return(BadRequest(new
{
Errors = new { Code = "InvalidInputParameters", Description = "Invalid Input Parameters!" }
}));
}
}
public bool Add(int id, Guid guid, int price)
{
if (id > 0)
{
cartRepository.Add(id, guid, price);
return(true);
}
return(false);
}
public IActionResult AddToCart(int id)
{
CartRepository repositoryCart = new CartRepository();
Cart b = new Cart();
b.AlbumId = id;
repositoryCart.Add(b);
return(RedirectToAction("Index", "Home"));
}
/// <summary>
/// Creates a new cart for the User / Anonymous.
/// </summary>
/// <returns></returns>
private CartModel CreateCart()
{
CartModel cart = new CartModel();
cart.LastAccessed = DateTime.Now;
cart.CartItems = new List <CartItemModel>();
if (User.Identity.IsAuthenticated)
{
cart.UserId = User.Identity.GetUserId();
}
carts.Add(cart);
if (!User.Identity.IsAuthenticated)
{
BrowserStorage.SetCartId(System.Web.HttpContext.Current, cart.Id);
}
return(cart);
}
public bool Add(CartAddViewModel cartAddVm)
{
var cart = new Cart()
{
BuyerId = cartAddVm.BuyerId,
AdvertisementId = cartAddVm.AdvertisementId,
CartDetail = new CartDetail()
{
CreatedOn = DateTime.Now,
ModifiedOn = DateTime.Now,
Quantity = cartAddVm.Quantity,
TotalAmount = cartAddVm.TotalAmount
}
};
_cartRepository.Add(cart);
return(true);
}
public int Add(Carts carts)
{
if (carts.Product_id == 0)
{
return(0);
}
if (carts.Cart_id == 0)
{
carts.Cart_id = this.GetRandomCartId();
cartRepository.Add(carts);
return(carts.Cart_id);
}
else
{
this.cartRepository.Add(carts);
return(carts.Cart_id);
}
}
public void AddToCart(Excursionn excursion, int nbrAdultes, int nbrEnfants, int nbrBebes)
{
excursionnRepository.Add(excursion);
excursionnRepository.Save();
// Get the matching cart and album instances
var cartItem = cartRepository.FindOne(
c => c.CartId == ShoppingCartId &&
c.excursionnId == excursion.excursionnId);
if (cartItem == null)
{
// Create a new cart item if no cart item exists
//Excursionn ex = new Excursionn();
//ex = excursion;
cartItem = new Cart
{
excursionnId = excursion.excursionnId,
//Excursionn = ex,
CartId = ShoppingCartId,
CountAdulte = nbrAdultes,
CountEnfant = nbrEnfants,
CountBebe = nbrBebes,
DateCreated = DateTime.Now
};
cartRepository.Add(cartItem);
}
else
{
// If the item does exist in the cart, then add one to the quantity
/*********/
//cartItem.Count++;
cartItem.CountAdulte += nbrAdultes;
cartItem.CountEnfant += nbrEnfants;
cartItem.CountBebe += nbrBebes;
}
// Save changes
cartRepository.Save();
}
public async Task Add_WhenCalled_AndExceptionOccurs_ShouldEventually_ReturnException()
{
var newItem = new CartItem(Guid.NewGuid().ToString(), "some-name-1", 45.99m, "some-manufacturer", DateTime.UtcNow);
var expected = new Exception("Unknown error occurred!");
var response = TryOptionAsync <CartItem>(() => throw expected);
var documentDbClient = new Mock <IDocumentDbClient <CartItem> >();
documentDbClient.Setup(mock => mock.CreateDocumentAsync(It.IsAny <CartItem>()))
.Returns(response);
var sut = new CartRepository(documentDbClient.Object);
await match <Exception, Option <CartItem> >(sut.Add(newItem),
Right : _ => Assert.False(true, "Shouldn't get here!"),
Left : ex => Assert.Equal(expected, ex)
);
documentDbClient.Verify(
mock => mock.CreateDocumentAsync(It.Is <CartItem>(item => item.Equals(newItem))),
Times.Once
);
}
public void Add(CartItem cartitem)
{
repository.Add(cartitem);
}
public void AddCart(Cart cart)
{
_repo_Cart.Add(cart);
}
public void Add(Product product, int quantity)
{
_cartRepository.Add(product, quantity);
}
public async Task <OrderView> Process(ulong userId, int paymentMethod, List <Item> items, List <Meal> meals, decimal price)
{
var user = await _userRepository.SingleAsync(user => user.UserId == userId);
if (user == null)
{
return(new OrderView());
}
// Create cart
var cart = new Cart()
{
UserId = user.UserId
};
await _cartRepository.Add(cart);
// Fetch newly created id of cart
var cartId = (await _cartRepository.SingleAsync(cart => cart.UserId == user.UserId)).CartId;
// Create cart-item junctions
if (items.Count > 0)
{
foreach (var cartItem in items.Select(item => item.CartItem.ElementAt(0)))
{
cartItem.CartId = cartId;
await _cartItemRepository.Add(cartItem);
}
}
// Create cart-meal junctions
if (meals.Count > 0)
{
foreach (var cartMeal in meals.Select(meal => meal.CartMeal.ElementAt(0)))
{
cartMeal.CartId = cartId;
await _cartMealRepository.Add(cartMeal);
}
}
// Create order
var order = new Order()
{
UserId = user.UserId,
CartId = cartId,
Price = price,
CreatedAt = DateTime.UtcNow,
DeliveryAt = DateTime.MinValue,
IsAccepted = "pending",
IsCanceled = 0,
IsDelivered = 0,
PaymentOption = "cash"
};
await _orderRepository.Add(order);
// Simulate approve order
// Will be replaced by dispatcher service
order.IsAccepted = "yes";
order.DeliveryAt = order.CreatedAt.AddMinutes(45);
// var orderId = (await _orderRepository.SingleAsync(order => order.UserId == user.UserId)).OrderId;
// .Where(cartItem => cartItem.CartId == cartId)
// .Include(cartItem => cartItem.Item)
// .Include(cartItem => cartItem.Portion)
var cartItems = await _cartItemRepository.GetAll(
cartItem => cartItem.CartId == cartId,
cartItem => cartItem.Item, cartItem => cartItem.Portion
);
var orderItems = cartItems.Select(cartItem =>
new OrderItem()
{
Title = cartItem.Item.Title,
PersonalPreference = cartItem.PersonalPreference,
PortionTitle = cartItem.Portion.Title,
Amount = cartItem.Amount,
Price = Math.Round(cartItem.Item.Price * cartItem.Portion.PriceMultiplier * cartItem.Amount, 2, MidpointRounding.ToEven)
}).ToList();
var cartMeals = await _cartMealRepository.GetAll(
cartMeal => cartMeal.CartId == cartId,
cartMeal => cartMeal.Meal
);
var orderMeals = cartMeals.Select(cartMeal =>
new OrderMeal()
{
Title = cartMeal.Meal.Title,
PersonalPreference = cartMeal.PersonalPreference,
Amount = cartMeal.Amount,
Price = cartMeal.Meal.Price * cartMeal.Amount
}).ToList();
var orderEmailView = new OrderView()
{
OrderId = order.OrderId,
Price = order.Price,
PaymentOption = order.PaymentOption,
// TODO: Fetch dispatcher input
DeliveryAt = order.DeliveryAt,
CreatedAt = order.CreatedAt,
OrderItems = orderItems,
OrderMeals = orderMeals
};
var isSent = _publisher.PublishOrderEmail(user.UserId, $"{user.FirstName} {user.LastName}", user.Email, orderEmailView);
return(!isSent ? new OrderView() : orderEmailView);
}
public bool Add(string guid, int id)
{
return(cartRepository.Add(guid, id));
}
