public IHttpActionResult CheckOutABook(CheckOutInfo info )
{
Book book = db.Books.Find(info.BookId);
if (book == null)
{
return NotFound();
}
Student student = db.Students.Find(info.StudentId);
if (student == null)
{
return NotFound();
}
// var hasacheckout = db.Checkouts.Where(x => x.Book == book && x.ReturnDate != null);
var isalreadycheckout = book.checkouts.Any(x => x.ReturnDate == null);
if (isalreadycheckout)
{
return BadRequest("book is checked out");
}
Checkout cob = new Checkout();
cob.Book = book;
cob.Student = student;
cob.CheckoutDate = DateTime.Now;
cob.DueDate = cob.CheckoutDate.AddMonths(1);
db.Checkouts.Add(cob);
db.SaveChanges();
var result = new { CheckedOut = cob.CheckoutDate.ToShortDateString(), DueBackOn = cob.DueDate.Value.ToShortDateString(), Book = cob.Book.Title, Student= cob.Student.Name };
return Ok(result);
}
public void Checkout(string name)
{
_currentBranch.Invalidate();
var command = new Checkout {BranchName = name};
_repositoryService.Git.Execute(command);
}
public IHttpActionResult PutCheckout(int id, Checkout checkout)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
if (id != checkout.Id)
{
return BadRequest();
}
db.Entry(checkout).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!CheckoutExists(id))
{
return NotFound();
}
else
{
throw;
}
}
return StatusCode(HttpStatusCode.NoContent);
}
public void Have_A_Total_Of_45p_When_The_Basket_Contains_2_Bananas()
{
var checkout = new Checkout();
checkout.Scan(Bananas);
checkout.Scan(Bananas);
Assert.That(checkout.Total, Is.EqualTo(.45m));
}
public void ShouldAddDiscountToDiscountDictionary()
{
var priceFinder = new Mock<IPriceFinder>();
var checkout = new Checkout(new Mock<IDiscounter>().Object, priceFinder.Object);
checkout.Scan("A");
}
public void TestGivenAValidCheckoutWhenANullBasketIsProcessedThenAnExceptionIsThrown()
{
// Arrange
var checkout = new Checkout();
// Act
double total = checkout.Process(null);
// Assert
}
public void Given_No_Items_In_Cart_Total_Should_Return_Zero()
{
// ACT
var result = new Checkout(priceStrategies).Total();
// ASSERT
Assert.AreEqual(0, result);
}
public void GettingTotalWithDiscountAppliesDiscount()
{
var discounter = new Mock<IDiscounter>();
discounter.Setup(v => v.DiscountFor(It.IsAny<string>())).Returns(20);
var checkout = new Checkout(discounter.Object, new Mock<IPriceFinder>().Object);
checkout.Scan("a");
Assert.That(checkout.Total(), Is.EqualTo(-20));
}
public void Have_A_Total_Of_1_Pound_And_25p_When_Three_Apples_Are_Bought()
{
var checkout = new Checkout();
checkout.Scan(Apple);
checkout.Scan(Apple);
checkout.Scan(Apple);
Assert.That(checkout.Total, Is.EqualTo(1.25m));
}
public void ReturnTheItemPriceWhenASingleItemIsScannedOnce(string sku, int price)
{
var checkout = new Checkout(new StockRoom());
var scannedItemPrice = checkout.GetTotal(sku);
Assert.That(scannedItemPrice, Is.EqualTo(price));
}
public void ShouldRetrieveCorrectPriceForOneItem()
{
var priceFinder = new Mock<IPriceFinder>();
var subject = new Checkout(new Mock<IDiscounter>().Object, priceFinder.Object);
subject.Scan("A");
priceFinder.Verify(v => v.PriceFor(It.IsAny<string>()));
}
public void Return0WhenNoItemIsScanned()
{
var checkout = new Checkout(new StockRoom());
var scannedItemPrice = checkout.GetTotal(string.Empty);
Assert.That(scannedItemPrice, Is.EqualTo(0));
}
public void Checkout_Products_Price(string productist, int finalPrice)
{
var checkout = new Checkout();
checkout.AddProductRuleRange(_productRules);
var price = checkout.GetPrice(productist);
Assert.AreEqual(finalPrice, price);
}
public void Have_A_Total_Of_1_Pound_And_50p_When_The_Basket_Totals_150_Without_Offers()
{
var checkout = new Checkout();
checkout.Scan(Apple);
checkout.Scan(Apple);
checkout.Scan(Bananas);
checkout.Scan(Cherries);
Assert.That(checkout.Total, Is.EqualTo(1.50m));
}
public void TestGivenAValidCheckoutWhenAnEmptyBasketIsProcessedThenTotalIsZero()
{
// Arrange
var checkout = new Checkout();
// Act
double total = checkout.Process(new Basket());
// Assert
Assert.AreEqual(0.0, total);
}
public void Given_item_d_is_scanned_Then_price_is_15()
{
var display = this;
var totalCalculator = new TotalCalculator(display, new PriceListRepository());
var checkout = new Checkout(totalCalculator, new DiscountCalculator(totalCalculator, new ItemDiscountRepository()));
const string item = "D";
checkout.Scan(item);
checkout.Finish();
Assert.That(_totalRecieved, Is.EqualTo(15));
}
public void ShouldRetrieveCorrectPriceForMultipleItems()
{
var priceFinder = new Mock<IPriceFinder>();
var subject = new Checkout(new Mock<IDiscounter>().Object, priceFinder.Object);
var items = "AB";
subject.Scan(items);
priceFinder.Verify(v => v.PriceFor(It.IsAny<string>()), Times.Exactly(items.Length));
}
public RedirectToRouteResult AddTariffToCheckout(Checkout order, int TariffId, string returnUrl)
{
Tariff chosenTariff = tariffRepo.Tariffs
.FirstOrDefault(p => p.Id == TariffId);
if (chosenTariff != null)
{
order.InitCalc(new ValueCalculator());
order.SetTariff(chosenTariff);
}
return RedirectToAction("Index", new { returnUrl });
}
public void QuandoVadoAPagare()
{
var productRules = ScenarioContext.Current.Retrieve<List<IProductRule>>("productRules");
var productList = ScenarioContext.Current["productList"].ToString();
var checkout = new Checkout();
checkout.AddProductRuleRange(productRules);
var finalPrice = checkout.GetPrice(productList);
ScenarioContext.Current.Add("finalPrice", finalPrice);
}
public void TestIncremental()
{
var co = new Checkout(PricingRules);
Assert.AreEqual(0, co.Total);
co.Scan("A"); Assert.AreEqual(50, co.Total);
co.Scan("B"); Assert.AreEqual(80, co.Total);
co.Scan("A"); Assert.AreEqual(130, co.Total);
co.Scan("A"); Assert.AreEqual(160, co.Total);
co.Scan("B"); Assert.AreEqual(175, co.Total);
}
public IHttpActionResult PostCheckout(Checkout checkout)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
db.Checkouts.Add(checkout);
db.SaveChanges();
return CreatedAtRoute("DefaultApi", new { id = checkout.Id }, checkout);
}
public void TestGivenAValidCheckoutWhenBasketWithOneBookIsProcessedThenTotalIsSameAsPriceOfBook()
{
// Arrange
const double PRICE = 1.99;
var checkout = new Checkout();
var basket = new Basket();
basket.Add(new Book() { Price = PRICE });
// Act
double total = checkout.Process(basket);
// Assert
Assert.AreEqual(PRICE, total);
}
public void Given_A_and_B_items_are_scanned_Then_total_price_is_80()
{
var display = this;
var totalCalculator = new TotalCalculator(display, new PriceListRepository());
var checkout = new Checkout(totalCalculator, new DiscountCalculator(totalCalculator, new ItemDiscountRepository()));
const string itemA = "A";
const string itemB = "B";
checkout.Scan(itemA);
checkout.Scan(itemB);
checkout.Finish();
Assert.That(_totalRecieved, Is.EqualTo(80));
}
public CheckoutTests()
{
_itemFinder.Items.Add(_itemA);
_itemFinder.Items.Add(_itemB);
_itemFinder.Items.Add(_itemC);
_itemFinder.Items.Add(_itemD);
_specials.Add(new SpecialPrice() { ItemName = "A", ItemCount = 3, TotalAmount = 130 });
_specials.Add(new SpecialPrice() { ItemName = "B", ItemCount = 2, TotalAmount = 45 });
_checkout = new Checkout(_itemFinder, _specials);
}
public void Given_One_Milk_Scanned_Total_Should_Return_1_15()
{
// ARRANGE
var items = "milk";
var checkout = new Checkout(priceStrategies);
// ACT
checkout.Scan(items);
var result = checkout.Total();
// ASSERT
Assert.AreEqual(1.15, result);
}
public void Given_One_Bread_Butter_Milk_Total_Should_Return_2_95()
{
// ARRANGE
var items = "bread,milk,butter";
var checkout = new Checkout(priceStrategies);
// ACT
checkout.Scan(items);
var result = checkout.Total();
// ASSERT
Assert.AreEqual(2.95, result);
}
public void ShouldCheckOutTheSelectedItemsFromTheBasket()
{
var item1 = new Item { ProductName = "Butter", PriceOfProduct = "3", NoOfProducts = 2, ItemCreatedDate = new DateTime(2013, 09, 18), ItemExpiryDate = new DateTime(2013, 09, 21) };
var item2 = new Item { ProductName = "Milk", PriceOfProduct = "2", NoOfProducts = 2, ItemCreatedDate = new DateTime(2013, 09, 18), ItemExpiryDate = new DateTime(2013, 09, 21) };
IBasket basket = new Basket();
basket.AddItemsToTheBasket(item1);
basket.AddItemsToTheBasket(item2);
var checkout = new Checkout(basket);
IList<Item> itemsForCheckout = checkout.ItemsSelectedForCheckOut().ToList();
Assert.That(itemsForCheckout.Count, Is.EqualTo(2));
}
public void Have_An_Offer_Of_3_Cherries_For_50p_When_I_Add_Three_Cherries_The_Total_Is_50p()
{
var offers = new List<Tuple<string, int, decimal>>
{
new Tuple<string, int, decimal>("C", 3, 0.50m),
new Tuple<string, int, decimal>("HEI-454", 3, 3.00m)
};
var checkout = new Checkout(offers);
checkout.Scan(Cherries);
checkout.Scan(Cherries);
checkout.Scan(Cherries);
Assert.That(checkout.Total, Is.EqualTo(0.5m));
}
public void Have_An_Offer_Of_3_Heinz_For_3GBP_When_I_Add_Three_Heinz_The_Total_Is_3GBP()
{
var offers = new List<Tuple<string, int, decimal>>
{
new Tuple<string, int, decimal>("C", 3, 0.50m),
new Tuple<string, int, decimal>("HEI-454", 3, 3.00m)
};
var checkout = new Checkout(offers);
checkout.Scan(HeinzBeans);
checkout.Scan(HeinzBeans);
checkout.Scan(HeinzBeans);
Assert.That(checkout.Total, Is.EqualTo(3m));
}
public void ShouldCalculateThePriceForTheChekedOutItems()
{
var item1 = new Item { ProductName = "Butter", PriceOfProduct = "3", NoOfProducts = 2, ItemCreatedDate = new DateTime(2013, 09, 18), ItemExpiryDate = new DateTime(2013, 09, 21) };
var item2 = new Item { ProductName = "Milk", PriceOfProduct = "2", NoOfProducts = 2, ItemCreatedDate = new DateTime(2013, 09, 18), ItemExpiryDate = new DateTime(2013, 09, 21) };
int totalPrice = 5;
IBasket basket = new Basket();
basket.AddItemsToTheBasket(item1);
basket.AddItemsToTheBasket(item2);
var checkout = new Checkout(basket);
var actual = checkout.CalculatePriceForcheckOut();
Assert.That(actual,Is.EqualTo(totalPrice));
}
public ActionResult ProcessPreapproval(int preapproval_id, decimal amt)
{
var req = new CheckoutCreateRequest
{
account_id = WePayConfig.accountId, accessToken = WePayConfig.accessToken,
mode = "regular",
type = "SERVICE",
amount = amt,
short_description = "checkout test",
redirect_uri = GlobalVars.hostUrl + @"/Home/CheckoutStatus",
preapproval_id = preapproval_id
};
var resp = new Checkout().Post(req);
if (resp.Error != null)
{
ViewBag.Error = resp.Error.error + " - " + resp.Error.error_description;
return(View("Status"));
}
return(Redirect(GlobalVars.hostUrl + @"/Home/CheckoutStatus?checkout_id=" + resp.checkout_id));
}
public async void CanCreateCheckoutProduct()
{
DbContextOptions <NurseryDbContext> options = new DbContextOptionsBuilder <NurseryDbContext>().UseInMemoryDatabase("test").Options;
using (NurseryDbContext context = new NurseryDbContext(options))
{
InventoryService inventoryService = new InventoryService(context);
CheckoutProductService checkoutProductService = new CheckoutProductService(context);
CheckoutService checkoutService = new CheckoutService(context);
Checkout checkout = new Checkout();
await checkoutService.CreateCheckoutAsync(checkout);
Product product = new Product();
await inventoryService.CreateProduct(product);
await checkoutProductService.AddCheckoutProduct(product.ID, 3, checkout.ID);
var expected = await context.CheckoutProducts.FirstOrDefaultAsync(p => p.CheckoutID == checkout.ID && p.ProductID == product.ID);
Assert.NotNull(expected);
}
}
public void If_MultiPriceRule_A_3_130_And_MultiPriceRule_A_5_190_And_Scan_AAAAA_Then_Price_is_190()
{
IPricingEngine pe = new PricingEngine(
new List <IPricingRule> {
new QuantityPricingRule("A", 50),
new QuantityPricingRule("A", 3, 130),
new QuantityPricingRule("A", 5, 190),
});
ICheckout co = new Checkout(pe);
co.Scan("A");
co.Scan("A");
co.Scan("A");
co.Scan("A");
co.Scan("A");
decimal price = co.GetTotalPrice();
decimal expectedPrice = 190;
Assert.AreEqual(expectedPrice, price);
}
private TransactionRequest InitTransactionRequest(
Checkout checkout,
CustomerRequest user,
AddressRequest shippingAddress,
AddressRequest billingAddress)
{
var transactionRequest = new TransactionRequest()
{
Customer = user,
BillingAddress = billingAddress,
ShippingAddress = shippingAddress,
//Amount = checkout.Amount,
//PaymentMethodNonce = checkout.BraintreeNonce,
Options = new TransactionOptionsRequest
{
SubmitForSettlement = true,
StoreInVault = true
}
};
return(transactionRequest);
}
public void CheckoutItem(Item item, Student student, int months)
{
// save the current time and add the chosen month amount
var time = DateTime.Now;
var returnTime = time.AddMonths(months);
var checkout = new Checkout
{
Item = item,
Student = student,
From = time,
Until = returnTime
};
_context.Add(checkout);
UpdateStatus(item.Id, "Uitgeleend");
item.Borrower = student.Name;
_context.SaveChanges();
}
public void GetBasketTotalWithMultipleOffers()
{
Dictionary <string, Item> items = new Dictionary <string, Item>()
{
{ "A99", new Item {
SKU = "A99", Price = 0.50m
} },
{ "B15", new Item {
SKU = "B15", Price = 0.30m
} },
};
List <SpecialOffer> specialOffers = new List <SpecialOffer>()
{
new SpecialOffer()
{
SKU = "A99", Quantity = 3, Price = 1.30m
},
new SpecialOffer()
{
SKU = "B15", Quantity = 2, Price = 0.45m
},
};
ItemLookup itemLookup = new ItemLookup(items);
SpecialOfferLookup specialOfferLookup = new SpecialOfferLookup(specialOffers);
Checkout checkout = new Checkout(itemLookup, specialOfferLookup);
_ = checkout.AddItemToBasket("A99");
_ = checkout.AddItemToBasket("A99");
_ = checkout.AddItemToBasket("A99");
_ = checkout.AddItemToBasket("B15");
_ = checkout.AddItemToBasket("B15");
var result = checkout.GetTotalPrice();
Assert.Equal(1.75m, result);
}
public void CheckoutItem(int assetId, int libraryCardId)
{
var now = DateTime.Now;
if (IsCheckedOut(assetId))
{
// Might add some logic to notify the user
return;
}
var item = _context.LibraryAssets
.FirstOrDefault(asset => asset.Id == assetId);
UpdateAssetStatus(assetId, "Checked Out");
var libraryCard = _context.LibraryCards
.Include(card => card.Checkouts)
.FirstOrDefault(card => card.Id == libraryCardId);
var checkout = new Checkout
{
LibraryAsset = item,
LibraryCard = libraryCard,
Since = now,
Until = GetDefaultCheckoutTime(now)
};
_context.Add(checkout);
var checkoutHistory = new CheckoutHistory
{
CheckedOut = now,
LibraryAsset = item,
LibraryCard = libraryCard
};
_context.Add(checkoutHistory);
_context.SaveChanges();
}
public void CheckOutItem(int assetId, int libraryCardId)
{
var now = DateTime.Now;
if (IsCheckedOut(assetId))
{
return;
}
else
{
var item = _DbContext.LibraryAssets.FirstOrDefault(p => p.Id == assetId);
MarkItem(assetId, "Checked Out");
var card = _DbContext.LibraryCards
.Include(p => p.Checkouts)
.FirstOrDefault(p => p.Id == libraryCardId);
var newCheckOut = new Checkout
{
LibraryAsset = item,
LibraryCard = card,
Since = now,
Until = GetDefaultCheckoutTime(now)
};
_DbContext.Add(newCheckOut);
var checkoutHistory = new CheckoutHistory
{
CheckedOut = now,
LibraryAsset = item,
LibraryCard = card
};
_DbContext.Add(checkoutHistory);
_DbContext.SaveChanges();
}
}
public double ProcessCheckout(Checkout checkout)
{
double total = 0;
this.itemPrices = this._dataAccess.GetItemPrices();
this.offers = this._dataAccess.GetOffers();
Dictionary <string, int> multiples = new Dictionary <string, int>();
foreach (string item in checkout.Items)
{
if (multiples.ContainsKey(item))
{
multiples[item]++;
}
else
{
multiples.Add(item, 1);
}
}
foreach (string item in multiples.Keys)
{
Offer offer = this.offers.FirstOrDefault(o => o.Item == item);
ItemPrice itemPrice = this.itemPrices.FirstOrDefault(ip => ip.Item == item);
if (offer != null && itemPrice != null)
{
int numberOfOffers = multiples[item] / offer.Number;
int remainer = multiples[item] % offer.Number;
total = total + (numberOfOffers * offer.Price) + (remainer * itemPrice.Price);
}
else if (itemPrice != null)
{
total = total + (multiples[item] * itemPrice.Price);
}
}
return(total);
}
private static void CheckReceiptTaxedPrice(int n, IReadOnlyList <Category> categories, Country supplierCountry, Country checkoutCountry, Tax expectedTax)
{
var catalog = new Catalog();
var checkout = new Checkout(checkoutCountry, catalog, new TaxEngine());
decimal nonTaxedPrice = 0;
Enumerable.Range(1, n)
.ForEach(x =>
{
var category = categories[x % categories.Count];
var name = Guid.NewGuid().ToString();
var price = x;
var article = new Article(x, supplierCountry, category, name, price);
catalog.TryAdd(article);
var quantity = x;
var origin = checkoutCountry == supplierCountry ? Origin.Local : Origin.Imported;
var good = new Good(article.Name, quantity, price, origin);
checkout.Scan(good);
nonTaxedPrice += x * x;
});
Assert.Equal(expectedTax.ApplyTo(nonTaxedPrice), checkout.EmitReceipt().Total);
}
public ActionResult Index()
{
if (!Request.Cookies.AllKeys.Contains("cart"))
{
return(RedirectToAction("Index", "Basket"));
}
MultipleModelInOneView model = new MultipleModelInOneView();
Checkout modelOne = new Checkout();
if (User.Identity.IsAuthenticated)
{
ApplicationDbContext entities = new ApplicationDbContext();
var user = entities.Users.FirstOrDefault(x => x.UserName == User.Identity.Name);
if (user != null)
{
modelOne.NameOnCard = user.UserName + " " + user.LastName;
modelOne.ContactEmail = user.Email;
}
}
return(View(modelOne));
}
public void TestForProductAWithThreeItem()
{
var cart = new Cart
{
Products = new List <Product> {
new Product {
Id = 1, Name = "A", Price = 50
},
new Product {
Id = 1, Name = "A", Price = 50
},
new Product {
Id = 1, Name = "A", Price = 50
},
}
};
var checkout = new Checkout();
var result = checkout.CalculateCartPrice(cart);
Assert.AreEqual(130, result);
}
public void If_MultiPriceRule_B_2_45_And_MultiPriceRule_A_3_130_And_Scan_AAABB_Then_Price_is_175()
{
IPricingEngine pe = new PricingEngine();
pe.AddQuantityPricingRule(new QuantityPricingRule("A", 50));
pe.AddQuantityPricingRule(new QuantityPricingRule("B", 30));
pe.AddQuantityPricingRule(new QuantityPricingRule("A", 3, 130));
pe.AddQuantityPricingRule(new QuantityPricingRule("B", 2, 45));
ICheckout co = new Checkout(pe);
co.Scan("A");
co.Scan("A");
co.Scan("A");
co.Scan("B");
co.Scan("B");
decimal price = co.GetTotalPrice();
decimal expectedPrice = 175;
Assert.AreEqual(expectedPrice, price);
}
public void TestForProductCDItem3()
{
var cart = new Cart
{
Products = new List <Product> {
new Product {
Id = 4, Name = "D", Price = 15
},
new Product {
Id = 4, Name = "D", Price = 15
},
new Product {
Id = 3, Name = "C", Price = 20
},
}
};
var checkout = new Checkout();
var result = checkout.CalculateCartPrice(cart);
Assert.AreEqual(45, result);
}
// Polls until the web checkout has completed.
protected void PollCheckoutCompletionStatus(Checkout checkout)
{
ShowLoadingDialog(Resource.String.getting_checkout_status);
SampleApplication.GetCheckoutCompletionStatus(
(complete, response) =>
{
if (complete)
{
DismissLoadingDialog();
OnCheckoutComplete();
}
else
{
pollingHandler.PostDelayed(() =>
{
PollCheckoutCompletionStatus(checkout);
}, PollDelay);
}
},
OnError);
}
public void GetTotalPrice_WhenGetBasicPriceMultipleItems_MustBeCorrect(string[] skuList, int totalPrice)
{
//arrange
var repository = A.Fake <IStockRepository>();
foreach (var key in _stockListDict.Keys)
{
A.CallTo(() => repository.GetStockItem(key)).Returns(_stockListDict[key]);
A.CallTo(() => repository.GetSpecialPrice(A <string> .Ignored)).Returns(null);
}
var sut = new Checkout(repository);
//act
foreach (var sku in skuList)
{
sut.Scan(sku);
}
var result = sut.GetTotalPrice();
//assert
Assert.AreEqual(totalPrice, result);
}
/// <summary>
/// Update an existing checkout object with a specified item_id, member_id, and item_type
/// </summary>
/// <param name="member_id">The id of the member that checked out the item</param>
/// <param name="item_id">The id of the item that was checked out</param>
/// <param name="item_type">The type of item that was checked out [book|dvd|technology]</param>
public HttpResponseMessage Put(int item_id, int member_id, String item_type, [FromBody] Checkout value)
{
CheckoutPersistence checkp = new CheckoutPersistence();
checkp.addCallField("item_id", item_id, System.Data.SqlDbType.Int, 4);
checkp.addCallField("member_id", member_id, System.Data.SqlDbType.Int, 4);
checkp.addCallField("item_type", item_type, System.Data.SqlDbType.VarChar, 50);
bool recordExisted = checkp.Update(value);
HttpResponseMessage response;
if (recordExisted)
{
response = Request.CreateResponse(HttpStatusCode.NoContent);
}
else
{
response = Request.CreateResponse(HttpStatusCode.NotFound);
}
return(response);
}
public ActionResult Create([Bind(Include = "CheckoutID,BookID,CheckoutDate,Quantity,DueDate")] Checkout checkout, int id)
{
if (ModelState.IsValid)
{
//create the due date 7 days from checkout date
checkout.DueDate = checkout.CheckoutDate.AddDays(7);
//find the book that is being checked out and update its quantity
Book book = db.Books.Find(id);
book.Quantity = book.Quantity - checkout.Quantity;
checkout.Books = book;
string x = User.Identity.GetUserId();
checkout.ApplicationUsers = db.Users.Find(x);
db.Checkouts.Add(checkout);
db.SaveChanges();
return(RedirectToAction("Index", new { id = checkout.BookId }));
}
return(View(checkout));
}
public void SingleItem()
{
// Arrange
var items = new List <ShopItem>
{
new ShopItem
{
SKU = 'A',
UnitPrice = 30
}
};
var checkout = new Checkout(items);
checkout.Scan("A");
// Act
var result = checkout.GetTotalPrice();
// Assert
Assert.AreEqual(30, result);
}
public async Task <IActionResult> OrderSummary(Checkout order)
{
SetUserData();
//Okay, cheating a bit here by re-generating the order's details instead of passing the same model from Checkout to Summary.
double tmpTotalCost = SimpleShoppingCart.ShoppingCart.Sum(i => (i.Quantity * i.Price));
int tmpTotalItems = SimpleShoppingCart.ShoppingCart.Sum(i => i.Quantity);
var user = _context.Users.FirstOrDefault <User>(u => u.UserID == HttpContext.Session.GetInt32("userid"));
var taxrate = await GetTaxRate(user.Zipcode);
double TaxRateParsed;
double.TryParse(taxrate, out TaxRateParsed);
CartItem[] Cartcopy = new CartItem[SimpleShoppingCart.ShoppingCart.Count];
SimpleShoppingCart.ShoppingCart.CopyTo(Cartcopy);
var temporaryCart = new ShoppingCart
{
//Cart = SimpleShoppingCart.ShoppingCart,
Cart = Cartcopy.ToList(),
TaxRate = TaxRateParsed,
TaxTotal = (tmpTotalCost * TaxRateParsed),
SubTotal = tmpTotalCost,
GrandTotal = tmpTotalCost + (tmpTotalCost * TaxRateParsed),
TotalItems = tmpTotalItems
};
var temporaryCheckout = new Checkout
{
Cart = temporaryCart,
User = user
};
//One behavior item to take care of AFTER creating out return product:
// Clear the global shopping cart's inventory.
SimpleShoppingCart.RemoveAll(); //Commented out for now, as this is killing the only copy of the static shopping cart.
return(View(temporaryCheckout));
}
public void CheckOutItem(int assetId, int libraryCardId)
{
if (IsCheckedOut(assetId))
{
return;
//add logic here to handle feedback to the user;
}
var item = _context.LibraryAssets
.FirstOrDefault(a => a.Id == assetId);
updateAssetStatus(assetId, "Checked Out");
var libraryCard = _context.LibraryCards
.Include(card => card.Checkouts)
.FirstOrDefault(card => card.Id == libraryCardId);
var now = DateTime.Now;
var checkout = new Checkout
{
LibraryAsset = item,
LibraryCard = libraryCard,
Since = now,
Until = GetDefaultCheckoutTime(now)
};
_context.Add(checkout);
var checkoutHistory = new CheckoutHistory
{
CheckedOut = now,
LibraryAsset = item,
LibraryCard = libraryCard
};
_context.Add(checkoutHistory);
_context.SaveChanges();
}
public ActionResult Checkout([Bind(Include = "Id,UserId,Name,Address,City,State,Zip")] Checkout checkout)
{
if (ModelState.IsValid)
{
db.Checkouts.Add(checkout);
int cartId = (int)Session["cartId"]; // extract values from session to variable and use it in the query
// Set the cartId ordered value to true
var cartOrder = db.CartProducts.Where(c => c.CartId == cartId).ToList();
foreach (var i in cartOrder)
{
i.Ordered = true;
var order = new Order
{
CheckoutId = checkout.Id,
ProductId = i.ProductId,
Quantity = i.Quantity
};
db.Orders.Add(order);
}
db.CartProducts.RemoveRange(db.CartProducts.Where(c => c.CartId == cartId));
Guid userId = (Guid)Session["userId"];
var cart = db.Carts.Where(p => p.UserId == userId).SingleOrDefault();
db.Carts.Remove(cart);
db.SaveChanges();
Session["checkoutId"] = checkout.Id;
Session["address"] = checkout.Address;
Session["cartItemsCount"] = 0;
return(RedirectToAction("Success"));
}
return(View(checkout));
}
public void TotalsOnlyWithSpecialOffers()
{
var checkOut = new Checkout();
checkOut.Scan(new Item()
{
SKU = "A99"
});
checkOut.Scan(new Item()
{
SKU = "A99"
});
checkOut.Scan(new Item()
{
SKU = "A99"
});
checkOut.Scan(new Item()
{
SKU = "A99"
});
checkOut.Scan(new Item()
{
SKU = "B15"
});
checkOut.Scan(new Item()
{
SKU = "B15"
});
checkOut.Scan(new Item()
{
SKU = "B15"
});
checkOut.Scan(new Item()
{
SKU = "C40"
});
Assert.IsTrue(checkOut.Total() == 3.15m);
}
public async Task CheckOutDevices(int employeeId, params int[] devicesId)
{
if (employeeId == 0)
{
return;
}
var employee = await _context.Employees.FindAsync(employeeId);
var now = DateTime.Now;
foreach (var id in devicesId)
{
var deviceEntity = await _context.Devices.FindAsync(id);
var checkout = new Checkout
{
Employee = employee,
Device = deviceEntity,
Since = now
};
var history = new CheckoutHistory
{
Employee = employee,
Device = deviceEntity,
CheckedOut = now
};
deviceEntity.Status = DeviceStatus.CheckedOut;
_context.Checkouts.Add(checkout);
_context.CheckoutHistories.Add(history);
}
await _context.SaveChangesAsync();
}
public async Task <IActionResult> Checkout(CheckoutViewModel cvm)
{
Checkout checkout = await _context.GetCheckoutByUserId(cvm.Email, cvm.ID);
checkout.Address = cvm.Address;
checkout.City = cvm.City;
checkout.State = cvm.State;
checkout.ZipCode = cvm.ZipCode;
string userEmail = User.Identity.Name;
var userRaw = await _userManager.FindByEmailAsync(userEmail);
userRaw.Address = cvm.Address;
userRaw.State = cvm.State;
userRaw.City = cvm.City;
userRaw.ZipCode = cvm.ZipCode;
await _userManager.UpdateAsync(userRaw);
Payment payment = new Payment(_configuration);
string response = payment.Run(cvm);
if (response == "Payment Successful")
{
Basket basket = await _basketcontext.GetBasketByUserId(userRaw.Id);
var basketProducts = await _basketProduct.GetBasket(basket.ID);
foreach (var product in basketProducts)
{
await _basketProduct.DeleteBasketProductByID(basket.ID, product.ProductID);
}
return(Redirect($"Receipt/{cvm.ID}"));
}
else
{
return(View(cvm));
}
}
public SveaWebPayClient(HttpClient checkoutApihttpClient,
HttpClient paymentAdminApiClient,
Credentials credentials,
ILogger logger = null)
{
if (!ServicePointManager.SecurityProtocol.HasFlag(SecurityProtocolType.Tls12))
{
ServicePointManager.SecurityProtocol |= SecurityProtocolType.Tls12;
}
if (checkoutApihttpClient == null)
{
throw new ArgumentNullException(nameof(checkoutApihttpClient));
}
if (paymentAdminApiClient == null)
{
throw new ArgumentNullException(nameof(paymentAdminApiClient));
}
if (checkoutApihttpClient.BaseAddress == null)
{
throw new ArgumentNullException(nameof(checkoutApihttpClient), $"{nameof(checkoutApihttpClient.BaseAddress)} cannot be null.");
}
if (paymentAdminApiClient.BaseAddress == null)
{
throw new ArgumentNullException(nameof(paymentAdminApiClient), $"{nameof(paymentAdminApiClient.BaseAddress)} cannot be null.");
}
var sveaLogger = logger ?? NullLogger.Instance;
var checkoutApiClient = new SveaHttpClient(checkoutApihttpClient, credentials, sveaLogger);
var paymentAdminClient = new SveaHttpClient(paymentAdminApiClient, credentials, sveaLogger);
Checkout = new Checkout(checkoutApiClient);
PaymentAdmin = new PaymentAdmin(paymentAdminClient);
}
public void CheckoutItem(int id, int libraryCardId)
{
if (IsCheckedOut(id))
{
return;
}
var item = _context.LibraryAssets
.FirstOrDefault(a => a.Id == id);
UpdateAssetStatus(id, "Checked Out");
var now = DateTime.Now;
var libraryCard = _context.LibraryCards
.Include(c => c.Checkouts)
.FirstOrDefault(a => a.Id == libraryCardId);
var checkout = new Checkout
{
LibraryAsset = item,
LibraryCard = libraryCard,
Since = now,
Until = GetDefaultCheckoutTime(now)
};
_context.Add(checkout);
var checkoutHistory = new CheckoutHistory
{
CheckedOut = now,
LibraryAsset = item,
LibraryCard = libraryCard
};
_context.Add(checkoutHistory);
_context.SaveChanges();
}
public void Get_Library_Card_By_Asset_Id()
{
var options = new DbContextOptionsBuilder <LibraryContext>()
.UseInMemoryDatabase("Gets_library_card_for_asset")
.Options;
using (var context = new LibraryContext(options))
{
var card = new LibraryCard
{
Id = 16,
Created = new DateTime(1999, 1, 1),
Fees = 0M
};
var checkout = new Checkout
{
Id = 87,
LibraryAsset = new Book {
Id = 300
},
LibraryCard = card
};
context.Checkouts.Add(checkout);
context.SaveChanges();
}
using (var context = new LibraryContext(options))
{
var sut = new LibraryAssetService(context);
var result = sut.GetById(300);
result.Should()
.BeEquivalentTo(new LibraryCard {
Id = 16, Created = new DateTime(1999, 1, 1), Fees = 0M
});
}
}
public void ManyItems_WithSpecialOffer_ExpectTotalToReflectOffer()
{
//Arrange
ICheckout checkout = new Checkout(_repository);
//Act
checkout.Scan("B");
checkout.Scan("D");
checkout.Scan("A");
checkout.Scan("B");
checkout.Scan("C");
checkout.Scan("A");
checkout.Scan("D");
checkout.Scan("B");
checkout.Scan("D");
checkout.Scan("A");
checkout.Scan("C");
checkout.Scan("B");
checkout.Scan("D");
checkout.Scan("C");
checkout.Scan("A");
checkout.Scan("A");
checkout.Scan("C");
checkout.Scan("A");
checkout.Scan("B");
checkout.Scan("B");
//A = 6 = 260
//B = 6 = 135
//C = 4 = 80
//D = 4 = 60
//Total = 535
decimal total = checkout.GetTotalPrice();
//Assert
Assert.AreEqual(535m, total);
}
public void GivenListOfItems_WhenItemssAreValid_ReturnsTotalCostWithDiscounts()
{
//arrange
var listOfItems = TestVariables.GetFakeListOfItems();
Decimal totalApplePriceInList = listOfItems.Where(x => x.ItemName.ToLower() == "apple").Sum(y => y.ItemPrice);
Decimal totalOrangePriceInList = listOfItems.Where(x => x.ItemName.ToLower() == "orange").Sum(y => y.ItemPrice);
var appleDiscountPercent = 0.5M;
var orangeDiscountPercent = 2M / 3M;
var totalPriceInLIst = listOfItems.Sum(x => x.ItemPrice);
var totalDiscountedPrice = totalPriceInLIst - ((totalApplePriceInList * appleDiscountPercent) + (totalOrangePriceInList * orangeDiscountPercent));
var sut = new Checkout();
//act
var result = Decimal.Round(sut.CalculateTotalPriceAndApplyDiscounts(listOfItems), 2);
//Assert
Assert.Equal(Decimal.Round(totalDiscountedPrice, 2), result);
}
