public void CompareProducts_Returns_Valid_Comparison_First_Basic_Product()
{
// Arrange
var basicProduct = new BasicProduct();
var packagedProduct = new PackagedProduct();
var comparisonService = new ComparisonService();
var validConsumption = 3000;
var expectedResultCount = 2;
var expectedResult = new List <IProduct>()
{
basicProduct,
packagedProduct
};
comparisonService.Add(basicProduct);
comparisonService.Add(packagedProduct);
// Act
var actualResult = comparisonService.CompareProducts(validConsumption);
// Assert
Assert.IsNotNull(actualResult);
Assert.AreEqual(expectedResultCount, actualResult.Count());
Assert.IsTrue(actualResult.SequenceEqual(expectedResult));
}
public void RemoveProduct(PackagedProduct toRemove)
{
List <PackagedProduct> newList = new List <PackagedProduct>();
bool useNewList = false;
foreach (PackagedProduct packagedProduct in products)
{
if (packagedProduct.uniqueID == toRemove.uniqueID)
{
if (packagedProduct.quantity > 1)
{
packagedProduct.quantity--;
}
else if (packagedProduct.quantity <= 1)
{
useNewList = true;
}
}
else
{
newList.Add(packagedProduct);
}
}
if (useNewList)
{
products = newList;
}
StorageBox storageBox = (StorageBox)product;
storageBox.products = products;
}
public void AddProduct(PackagedProduct newPackagedProduct)
{
newPackagedProduct.parentBox = this;
products.Add(newPackagedProduct);
StorageBox storageBox = (StorageBox)product;
storageBox.products = products;
}
public void CalculateAnnualCosts_Throws_Argument_Exception_Less_Then_Zero()
{
// Assert
var inValidConsumption = -1;
var product = new PackagedProduct();
// Act
product.CalculateAnnualCosts(inValidConsumption);
}
public void Name_Returns_Packaged_Name()
{
// Assert
var expectedName = "Packaged tariff";
// Act
var product = new PackagedProduct();
// Arrange
Assert.IsNotNull(product);
Assert.IsNotNull(product.Name);
Assert.AreEqual(expectedName, product.Name);
}
public void CalculateAnnualCosts_Returns_23600()
{
// Assert
var expectedAnnualCosts = 23600;
var validConsumption = 80000;
var product = new PackagedProduct();
// Act
product.CalculateAnnualCosts(validConsumption);
// Arrange
Assert.IsNotNull(product);
Assert.AreEqual(expectedAnnualCosts, product.AnnualCosts);
}
public void CompareProducts_Throws_Argument_Exception_Less_Then_Zero()
{
// Arrange
var basicProduct = new BasicProduct();
var packagedProduct = new PackagedProduct();
var comparisonService = new ComparisonService();
var inValidConsumption = -1;
comparisonService.Add(basicProduct);
comparisonService.Add(packagedProduct);
// Act
var actualResult = comparisonService.CompareProducts(inValidConsumption);
}
private void MapShippedItemInstance(Model.ShippedItemInstance shippedItemInstance)
{
//-----------------------
//PackagedProductInstance
//-----------------------
//The PackagedProductInstance represents a single product shipment and maps 1:1 to the ShippedItemInstance
PackagedProductInstance packagedProductInstance = new PackagedProductInstance();
//Description and quantity are set on the related class properties
packagedProductInstance.Description = string.Format("Shipment {0}", shippedItemInstance.Identifier?.Content);
if (double.TryParse(shippedItemInstance.Quantity?.Content, out double quantity))
{
packagedProductInstance.ProductQuantity = CreateRepresentationValue(quantity, shippedItemInstance.Quantity.UnitCode);
}
else
{
Errors.Add(new Error(string.Empty, "ShippedItemInstanceMapper.MapShippedItemInstance", $"Quantity {shippedItemInstance.Quantity?.Content} is invalid.", string.Empty));
}
//The remaining data is somewhat specific to the ShippedItemInstance and is persisted as ContextItems
//The ContextItem data generally is intended to be passed out of the ApplicationDataModel and passed back in unaltered,
//in order that the data may return, e.g., on a logged planting operation and reconcile that planting operation
//back to this ShippedItemInstance.
packagedProductInstance.ContextItems.AddRange(CreatePackagedProductInstanceContextItems(shippedItemInstance));
//-----------------------
//PackagedProduct
//-----------------------
//Packaged product is defined a product within a specific packaging.
//Multiple ShippedItemInstances may map to the same PackagedProduct
PackagedProduct packagedProduct = GetPackagedProduct(shippedItemInstance);
if (packagedProduct != null)
{
packagedProductInstance.PackagedProductId = packagedProduct.Id.ReferenceId;
}
else
{
Errors.Add(new Error(null, "Mapper.MapShippedItemInstance", $"Couldn't create PackagedProduct for PackageProductInstance {packagedProductInstance.Id.ReferenceId}", null));
}
//Add the PackagedProductInstance to the Catalog. The PackagedProduct is added in the subroutine above.
Catalog.PackagedProductInstances.Add(packagedProductInstance);
//Set other contextual information from the ShippedItemInstance into relevant ADAPT classes
SetManufacturerAndBrand(shippedItemInstance);
SetCrop(shippedItemInstance);
SetGrower(shippedItemInstance);
}
public void AddProduct(StoreObjectReference newReference)
{
print("Adding reference");
int checkValue = CheckAgainstList(newReference);
if (checkValue == -1)
{
PackagedProduct newPackagedProduct = new PackagedProduct(this, newReference, 1);
newPackagedProduct.uniqueID = Dispensary.GetUniqueProductID();
products.Add(newPackagedProduct);
}
else if (checkValue >= 0)
{
products[checkValue].AddProduct();
}
currentWeight += product.boxWeight;
StorageBox storageBox = (StorageBox)product;
storageBox.products = products;
}
public void Print_Should_Not_Throw_Exception()
{
// Arrange
var basicProduct = new BasicProduct();
var packagedProduct = new PackagedProduct();
var comparisonService = new ComparisonService();
comparisonService.Add(basicProduct);
comparisonService.Add(packagedProduct);
// Act
try
{
comparisonService.PrintProducts();
}
catch (Exception ex)
{
Assert.Fail($"Print function has thrown an exception. Exception message: {ex.Message}");
}
}
/// <summary>
/// Import any PackagedProduct & PackagedProductInstance classes as may be defined in the LinkList/ContextItems
/// Any export process (above) will have named the context items with with integer prefixes so that we can identify
/// the source object hierarchy.
/// E.g., 1.1.Code|Value is the first PackagedProduct and the first PackagedProduct belonging to it.
/// The 1.1, etc. convention is internal to this plugin. As LinkList.xml items classified in ManufacturerGLN LGP's, the
/// data carries a proprietary definition that, in this case, is internal to the Import/Export methods in this class and serves
/// no purpose other than ensuring exported data is reimported in its same form. If in future there is a need to expose
/// other product data in this way, we need simply alter these to methods to allow for the same.
/// </summary>
/// <param name="isoProduct"></param>
/// <param name="product"></param>
private void ImportPackagedProductClasses(ISOProduct isoProduct, Product product)
{
List <ContextItem> ppContextItems = ImportContextItems(isoProduct.ProductId, "ADAPT_Context_Items:PackagedProduct");
List <ContextItem> ppiContextItems = ImportContextItems(isoProduct.ProductId, "ADAPT_Context_Items:PackagedProductInstance");
int packagedProductIndex = 1;
ContextItem relevantPPContextItem = ppContextItems.FirstOrDefault(ci => ci.Code == packagedProductIndex.ToString());
while (relevantPPContextItem != null)
{
//PackagedProduct
PackagedProduct packagedProduct = new PackagedProduct();
packagedProduct.ProductId = product.Id.ReferenceId;
packagedProduct.ContextItems = relevantPPContextItem.NestedItems;
packagedProduct.Description = packagedProduct.ContextItems.FirstOrDefault()?.Value;
DataModel.Catalog.PackagedProducts.Add(packagedProduct);
//PackagedProductInstance
ContextItem containingContextItem = ppiContextItems.FirstOrDefault(ci => ci.Code == packagedProductIndex.ToString());
if (containingContextItem != null)
{
int packagedProductInstanceIndex = 1;
ContextItem relevantPPIContextItem = containingContextItem.NestedItems.FirstOrDefault(ci => ci.Code == packagedProductInstanceIndex.ToString());
while (relevantPPIContextItem != null)
{
PackagedProductInstance packagedProductInstance = new PackagedProductInstance();
packagedProductInstance.PackagedProductId = packagedProduct.Id.ReferenceId;
packagedProductInstance.ContextItems = relevantPPIContextItem.NestedItems;
packagedProductInstance.Description = packagedProductInstance.ContextItems.FirstOrDefault()?.Value;
DataModel.Catalog.PackagedProductInstances.Add(packagedProductInstance);
//Increment the counter and see if there is a PackagedProductInstance 1.2, etc.
int index = ++packagedProductInstanceIndex;
relevantPPIContextItem = containingContextItem.NestedItems.FirstOrDefault(ci => ci.Code == index.ToString());
}
}
//Increment the counter and see if there is a PackagedProduct 2, etc.
relevantPPContextItem = ppContextItems.FirstOrDefault(ci => ci.Code == (++packagedProductIndex).ToString());
}
}
public int CheckAgainstList(StoreObjectReference reference)
{
int toReturn = -1;
for (int i = 0; i < products.Count; i++)
{
PackagedProduct packagedProduct = products[i];
try
{
if (packagedProduct.productReference.objectID == reference.objectID)
{
int tempIndex = i;
return(tempIndex);
}
}
catch (NullReferenceException)
{
print("Something went wrong");
}
}
return(toReturn);
}
private PackagedProduct GetPackagedProduct(Model.ShippedItemInstance shippedItemInstance)
{
PackagedProduct packagedProduct = null;
Model.Item item = shippedItemInstance.Item;
if (item?.ManufacturerItemIdentification?.Identifier == null && item?.Gtinid == null && item?.Upcid == null)
{
// No ids specified so use the descriptionn to find a PackageProduct that matches
packagedProduct = Catalog.PackagedProducts.FirstOrDefault(pp => pp.Description == item?.Description);
}
else
{
// Try to find a matching PackagedProduct based on the ManufacturerItemIdentifier, UPC Id or GTIN Id
if (!string.IsNullOrEmpty(item?.ManufacturerItemIdentification?.TypeCode) && !string.IsNullOrEmpty(item?.ManufacturerItemIdentification?.Identifier))
{
packagedProduct = Catalog.PackagedProducts.FirstOrDefault(pp => pp.ContextItems.Any(i => (i.Code == item?.ManufacturerItemIdentification?.TypeCode && i.Value == item?.ManufacturerItemIdentification?.Identifier)));
}
else if (!string.IsNullOrEmpty(item?.Gtinid) && !string.IsNullOrEmpty(item?.Upcid))
{
packagedProduct = Catalog.PackagedProducts.FirstOrDefault(pp => pp.ContextItems.Any(i => (i.Code == "UPC" && i.Value == item?.Upcid) || (i.Code == "GTIN" && i.Value == item?.Gtinid)));
}
}
if (packagedProduct == null && item?.Description != null)
{
// Didn't find a match so create a new object
packagedProduct = new PackagedProduct();
packagedProduct.Description = item?.Description;
// Set context items
//Set description so that it can in theory persist as data for models (e.g., ISO) that do not have the PackagedProduct object.
if (item?.Description != null)
{
packagedProduct.ContextItems.Add(
new ContextItem()
{
Code = "Description",
Value = item?.Description
});
}
//The below identifiers are set as ContextItems vs. UniqueIDs so that they can import/export hierarchically
//based on the logic in the ISO plugin to handle hierarchical PackagedProducts & PackagedProductInstances
if (item?.ManufacturerItemIdentification?.Identifier != null)
{
packagedProduct.ContextItems.Add(
new ContextItem()
{
Code = item?.ManufacturerItemIdentification?.TypeCode,
Value = item?.ManufacturerItemIdentification?.Identifier
});
}
if (item?.Upcid != null)
{
packagedProduct.ContextItems.Add(
new ContextItem()
{
Code = "UPC",
Value = item?.Upcid
});
}
if (item?.Gtinid != null)
{
packagedProduct.ContextItems.Add(
new ContextItem()
{
Code = "GTIN",
Value = item?.Gtinid
});
}
Catalog.PackagedProducts.Add(packagedProduct);
// Tie to a Product object
Product product = GetProduct(shippedItemInstance);
if (product != null)
{
packagedProduct.ProductId = product.Id.ReferenceId;
}
else
{
Errors.Add(new Error(null, "Mapper.GetPackagedProduct", $"Unable to create Product for Packaged Product {packagedProduct.Id.ReferenceId}", null));
}
}
return(packagedProduct);
}
//public int parentBoxUniqueID;
public PackagedProduct_s(PackagedProduct product) : base(Product.type_.packagedProduct, product.productReference.objectID, product.productReference.subID, product.productReference.productName)
{
productQuantity = product.quantity;
//parentBoxUniqueID = product.parentBox.product.uniqueID;
}
