public async Task <IActionResult> AddItemToBasket(BasketItemCreateViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest("Invalid model"));
}
BasketViewModel basket = await _basketViewModelService.GetOrCreateBasketForUserAsync(User.Identity.Name);
var priceResult = Pounds.Create(model.PriceInPounds);
if (priceResult.IsFailure)
{
return(BadRequest(priceResult.Error));
}
var result = await _basketService.AddItemToBasketAsync(basket.Id, model.ProductId, model.Quantity, priceResult.Value);
if (result.IsFailure)
{
return(NotFound(result.Error));
}
BasketItemViewModel item = await _basketViewModelService.GetBasketItemForUserAsync(User.Identity.Name, result.Value);
return(CreatedAtAction("GetItem", new { id = item.Id }, item));
}
public void Create_WithPartOfPennyAmount_ShouldReturnFailure()
{
// Arrange
var result = Pounds.Create(0.001m);
// Assert
Assert.True(result.IsFailure);
}
public void Create_WithNegativeAmount_ShouldReturnFailure()
{
// Arrange
var result = Pounds.Create(-1);
// Assert
Assert.True(result.IsFailure);
}
public void Constructor_WithNegativeQuantity_ShouldThrowContractException()
{
// Arrange
Func <BasketItem> createBasketItem = () => new BasketItem(1, -1, Pounds.Of(1));
// Assert
Assert.Throws <ContractException>(createBasketItem);
}
public void Constructor_WithPriceZero_ShouldThrowContractException()
{
// Arrange
Func <BasketItem> createBasketItem = () => new BasketItem(1, 1, Pounds.Of(0));
// Assert
Assert.Throws <ContractException>(createBasketItem);
}
public void Convert_Kilograms_and_Pounds()
{
double kgs_lbs = new Kilograms(12).To<Pounds>(); // 26.4555
double lbs_kgs = new Pounds(25).To<Kilograms>(); // 11.3398
Assert.AreEqual(26.4555, Math.Round(kgs_lbs, 4));
Assert.AreEqual(11.3398, Math.Round(lbs_kgs, 4));
}
public void Create_WithBigAmount_ShouldReturnFailure()
{
// Arrange
var result = Pounds.Create(Pounds.MaxPoundAmount + 1);
// Assert
Assert.True(result.IsFailure);
}
public void Create_WithValidAmount_ShouldReturnSuccess()
{
// Arrange
var result = Pounds.Create(1);
// Assert
Assert.True(result.IsSuccess);
}
public void Convert_Kilograms_and_Pounds()
{
double kgs_lbs = new Kilograms(12).To <Pounds>(); // 26.4555
double lbs_kgs = new Pounds(25).To <Kilograms>(); // 11.3398
Assert.AreEqual(26.4555, Math.Round(kgs_lbs, 4));
Assert.AreEqual(11.3398, Math.Round(lbs_kgs, 4));
}
public void ChangeQuantity_WithNegativeQuantity_ShouldThrowContractException()
{
// Arrange
var basketItem = new BasketItem(1, 2, Pounds.Of(3));
Action changeQuantity = () => basketItem.ChangeQuantity(-1);
// Assert
Assert.Throws <ContractException>(changeQuantity);
}
public void Constructor_WithValidArguments_ShouldInitializeFields()
{
// Arrange
var basketItem = new BasketItem(1, 2, Pounds.Of(3));
// Assert
Assert.Equal(1, basketItem.ProductId);
Assert.Equal(2, basketItem.Quantity);
Assert.Equal(Pounds.Of(3), basketItem.PriceInPounds);
}
public void ChangeQuantity_WithValidQuantity_ShouldChangeQuantity()
{
// Arrange
var basketItem = new BasketItem(1, 2, Pounds.Of(3));
// Act
basketItem.ChangeQuantity(4);
// Assert
Assert.Equal(4, basketItem.Quantity);
}
public void OperatorConvertToDecimal_ShouldConvertPoundsToDecimal()
{
// Arrange
var pounds = Pounds.Of(5);
// Act
decimal value = pounds;
// Assert
Assert.Equal(5, value);
}
public void AddItemToBasketAsync_WithNonExistentBasket_ShouldReturnFailure()
{
// Arrange
_basketRepositoryMock.Setup(x => x.GetByIdAsync(It.IsAny<int>())).Returns(Task.FromResult<Basket>(null));
// Act
var result = _basketService.AddItemToBasketAsync(1, 1, 1, Pounds.Of(1)).Result;
// Assert
Assert.True(result.IsFailure);
}
public void OperatorMultiplication_ShouldMultiplyAmounts()
{
// Arrange
var pounds = Pounds.Of(2);
// Act
var result = pounds * 5;
// Assert
Assert.Equal(Pounds.Of(10), result);
}
public void AddItem_WithNonExistentBasketItem_ShouldAddItemToList()
{
// Arrange
var basket = new Basket();
// Act
basket.AddItem(1, 1, Pounds.Of(1));
// Assert
Assert.Equal(1, basket.Items.Count);
}
public void AddItem_WithNonExistentBasketItem_ShouldReturnNewlyCreatedItem()
{
// Arrange
var basket = new Basket();
// Act
var item = basket.AddItem(1, 1, Pounds.Of(1));
// Assert
Assert.NotNull(item);
}
public void OperatorAdd_ShouldAddAmounts()
{
// Arrange
var pounds1 = Pounds.Of(2);
var pounds2 = Pounds.Of(3);
// Act
var result = pounds1 + pounds2;
// Assert
Assert.Equal(Pounds.Of(5), result);
}
public void AddItemToBasketAsync_WithExistentBasket_ShouldReturnSuccess()
{
// Arrange
var basket = new Basket();
_basketRepositoryMock.Setup(x => x.GetByIdAsync(It.IsAny<int>())).Returns(Task.FromResult(basket));
// Act
var result = _basketService.AddItemToBasketAsync(1, 1, 1, Pounds.Of(1)).Result;
// Assert
Assert.True(result.IsSuccess);
}
public void AddItemToBasketAsync_WithExistentBasket_ShouldCallUpdateInRepository()
{
// Arrange
var basket = new Basket();
_basketRepositoryMock.Setup(x => x.GetByIdAsync(It.IsAny<int>())).Returns(Task.FromResult(basket));
_basketRepositoryMock.Setup(x => x.UpdateAsync(It.IsAny<Basket>())).Returns(Task.CompletedTask);
// Act
var result = _basketService.AddItemToBasketAsync(1, 1, 1, Pounds.Of(1)).Result;
// Assert
_basketRepositoryMock.Verify(x => x.UpdateAsync(basket), Times.Once);
}
public void ChangeItemQuantityAsync_WithExistentBasketItem_ShouldReturnSuccess()
{
// Arrange
var basket = new Basket();
basket.AddItem(1, 1, Pounds.Of(1));
var basketItem = basket.Items.First();
basketItem.Id = 1;
_basketRepositoryMock.Setup(x => x.GetByUserIdAsync(It.IsAny<string>())).Returns(Task.FromResult(basket));
// Act
var result = _basketService.ChangeItemQuantityAsync("user", 1, 2).Result;
// Asert
Assert.True(result.IsSuccess);
}
public void AddItem_WithExistentBasketItem_ShouldUpdateBasketItemQuantity()
{
// Arrange
var basket = new Basket();
basket.AddItem(1, 1, Pounds.Of(1));
// Act
basket.AddItem(1, 1, Pounds.Of(1));
// Assert
var item = basket.Items.First();
Assert.Equal(2, item.Quantity);
}
public void ChangeItemQuantityAsync_WithExistentBasketItem_ShouldCallUpdateInRepository()
{
// Arrange
var basket = new Basket();
basket.AddItem(1, 1, Pounds.Of(1));
var basketItem = basket.Items.First();
basketItem.Id = 1;
_basketRepositoryMock.Setup(x => x.GetByUserIdAsync(It.IsAny<string>())).Returns(Task.FromResult(basket));
// Act
var result = _basketService.ChangeItemQuantityAsync("user", 1, 2).Result;
// Asert
_basketRepositoryMock.Verify(x => x.UpdateAsync(basket), Times.Once);
}
public void RemoveItem_WithExistentBasketItem_ShouldReturnSucces()
{
// Arrange
var basket = new Basket();
basket.AddItem(1, 1, Pounds.Of(1));
var basketItem = basket.Items.First();
basketItem.Id = 1;
// Act
var result = basket.RemoveItem(1);
// Assert
Assert.True(result.IsSuccess);
}
public void RemoveItem_WithExistentBasketItem_ShouldReturnRemoveItem()
{
// Arrange
var basket = new Basket();
basket.AddItem(1, 1, Pounds.Of(1));
var basketItem = basket.Items.First();
basketItem.Id = 1;
// Act
basket.RemoveItem(1);
// Assert
Assert.Equal(0, basket.Items.Count);
}
public void Clear_ShouldClearBasketItemsList()
{
// Arrange
var basket = new Basket();
basket.AddItem(1, 1, Pounds.Of(1));
var basketItem = basket.Items.First();
basketItem.Id = 1;
// Act
basket.Clear();
// Assert
Assert.Equal(0, basket.Items.Count);
}
public int CompareTo(object obj)
{
PoundsAndOunces other = (PoundsAndOunces)obj;
if (Pounds.CompareTo(other.Pounds) < 0)
{
return(-1);
}
else if (Pounds.CompareTo(other.Pounds) > 0)
{
return(1);
}
else
{
return(Ounces.CompareTo(other.Ounces));
}
}
public void InputPayrollFormDetails(string FormTypetoCreate, string CurrentOrClosedWeekending)
{
//Inputs all information needed to create a new payroll form
FormType.SelectByText(FormTypetoCreate, "FormType");
CenterDropDown.SelectByIndex(1, "Center");
var routeNumberValue = GenerateRandomRouteNumber();
//Save this route number value for use later
ScenarioContext.Current["RouteNumber"] = routeNumberValue;
RouteNumber.EnterText(routeNumberValue, "RouteNumber");
RouteNumber.SendKeys(Keys.Tab);
var WeekendingDateToSelect = DateTime.Now;
if (CurrentOrClosedWeekending == "Current")
{
WeekendingDateToSelect = (DateTime.Now.AddDays(6 - (int)DateTime.Now.DayOfWeek));
}
else
{
DateTime StartOfWeek = DateTime.Today.AddDays(-(int)DateTime.Today.DayOfWeek);
WeekendingDateToSelect = StartOfWeek.AddDays(-1);
}
var departDateValue = WeekendingDateToSelect.AddDays(-2).ToShortDateString();
ScenarioContext.Current["DepartDate"] = departDateValue;
DepartDate.EnterText(departDateValue, "DepartDate");
DepartDate.SendKeys(Keys.Tab);
WeekendingDate.EnterText(WeekendingDateToSelect.ToShortDateString(), "WeekendingDate");
WeekendingDate.SendKeys(Keys.Tab);
driver.RobustWait();
if (FormTypetoCreate == "Regular")
{
Cases.EnterText("25", "Cases");
Pounds.EnterText("4000", "Cases");
Cubes.EnterText("25", "Cubes");
Stops.EnterText("5", "Stops");
}
}
public string ToString(string format, IFormatProvider formatProvider)
{
if (string.IsNullOrEmpty(format))
{
format = "G";
}
formatProvider = formatProvider ?? CultureInfo.CurrentCulture;
switch (format)
{
case "G":
string price = "";
if (Pounds > 0)
{
price += "£" + Pounds.ToString(formatProvider);
}
if (Shillings > 0)
{
price += (price.Length > 0 ? " " : "") + Shillings.ToString(formatProvider) + "s";
}
if (Pence > 0)
{
price += (price.Length > 0 ? " " : "") + Pence.ToString(formatProvider) + "d";
}
if (price.Length == 0)
{
price = "0";
}
return(price);
case "M":
return(ModernEquivalent.ToString("N2", formatProvider));
}
throw new FormatException(string.Format("Unsupported format '{0}'", format));
}
public async Task <Result <int> > AddItemToBasketAsync(int basketId, int productId, int quantity, Pounds priceInPounds)
{
Basket basket = await _basketRepository.GetByIdAsync(basketId);
if (basket == null)
{
var message = string.Format(ErrorMessage.BasketWithIdDoesntExists, basketId);
_logger.LogInformation(message);
return(Result.Fail <int>(message));
}
BasketItem basketItem = basket.AddItem(productId, quantity, priceInPounds);
await _basketRepository.UpdateAsync(basket);
return(Result.Ok(basketItem.Id));
}
public void WriteToXml(ref XmlTextWriter xw)
{
SortDimensions();
xw.WriteStartElement("Package");
xw.WriteAttributeString("ID", Id);
// Package Info
xw.WriteElementString("Service", TranslateServiceCodeToString(Service));
if (Service == DomesticServiceType.FirstClass ||
Service == DomesticServiceType.FirstClassHoldForPickupCommercial)
{
xw.WriteElementString("FirstClassMailType", TranslateContainerCode(Container));
}
xw.WriteElementString("ZipOrigination", ZipOrigination);
xw.WriteElementString("ZipDestination", ZipDestination);
xw.WriteElementString("Pounds", Pounds.ToString(CultureInfo.InvariantCulture));
xw.WriteElementString("Ounces", Math.Round(Ounces, 1).ToString(CultureInfo.InvariantCulture));
// Container and First Class Types
if (Service == DomesticServiceType.FirstClass ||
Service == DomesticServiceType.FirstClassHoldForPickupCommercial)
{
xw.WriteElementString("Container", "");
}
else
{
xw.WriteElementString("Container", TranslateContainerCode(Container));
}
// Size
if (DeterminePackageSize() == DomesticPackageSize.Large)
{
xw.WriteElementString("Size", "LARGE");
}
else
{
xw.WriteElementString("Size", "REGULAR");
}
// Dimesions here
if (DeterminePackageSize() == DomesticPackageSize.Large)
{
if (HasDimensions())
{
xw.WriteElementString("Width", Math.Round(Width, 1).ToString(CultureInfo.InvariantCulture));
xw.WriteElementString("Length", Math.Round(Length, 1).ToString(CultureInfo.InvariantCulture));
xw.WriteElementString("Height", Math.Round(Height, 1).ToString(CultureInfo.InvariantCulture));
}
else
{
xw.WriteElementString("Width", Math.Round(3.0, 1).ToString(CultureInfo.InvariantCulture));
xw.WriteElementString("Length", Math.Round(6.0, 1).ToString(CultureInfo.InvariantCulture));
xw.WriteElementString("Height", Math.Round(0.25, 1).ToString(CultureInfo.InvariantCulture));
}
if (Container == DomesticPackageType.NonRectangular ||
Container == DomesticPackageType.Variable ||
Container == DomesticPackageType.Ignore)
{
xw.WriteElementString("Girth", Math.Round(Girth(), 1).ToString(CultureInfo.InvariantCulture));
}
}
// Machinable
if (IsMachinable() == DomesticMachinable.Yes)
{
xw.WriteElementString("Machinable", "true");
}
if (IsMachinable() == DomesticMachinable.No)
{
xw.WriteElementString("Machinable", "false");
}
if (DeclaredValue > 0)
{
xw.WriteElementString("Value", Math.Round(DeclaredValue, 2).ToString(CultureInfo.InvariantCulture));
}
if (AmountToCollect > 0)
{
xw.WriteElementString("AmountToCollect",
Math.Round(AmountToCollect, 2).ToString(CultureInfo.InvariantCulture));
}
// Special Services
if (SpecialServices.Count > 0)
{
xw.WriteStartElement("SpecialServices");
foreach (var s in SpecialServices)
{
xw.WriteElementString("SpecialService", ((int)s).ToString(CultureInfo.InvariantCulture));
}
xw.WriteEndElement();
}
// End Package
xw.WriteEndElement();
}
