/// <summary>
/// Build a mockup for a food item.
/// </summary>
/// <param name="isActive">Indicates whether the food item should be active or inactive.</param>
/// <param name="dataProvider">Data provider who owns one of the foreign keys.</param>
/// <param name="translations">Collection of translation mockups for the food item.</param>
/// <returns>Mockup for a food item.</returns>
public static IFoodItem BuildFoodItemMock(bool isActive = true, IDataProvider dataProvider = null, IEnumerable <ITranslation> translations = null)
{
Guid identifier = Guid.NewGuid();
IFoodGroup primaryFoodGroupMock = BuildFoodGroupMock();
IList <IFoodGroup> foodGroupMockCollection = new List <IFoodGroup>
{
primaryFoodGroupMock,
BuildFoodGroupMock(),
BuildFoodGroupMock()
};
IFoodItem foodItemMock = MockRepository.GenerateMock <IFoodItem>();
foodItemMock.Stub(m => m.Identifier)
.Return(identifier)
.Repeat.Any();
foodItemMock.Stub(m => m.PrimaryFoodGroup)
.Return(primaryFoodGroupMock)
.Repeat.Any();
foodItemMock.Stub(m => m.IsActive)
.Return(isActive)
.Repeat.Any();
foodItemMock.Stub(m => m.FoodGroups)
.Return(foodGroupMockCollection)
.Repeat.Any();
foodItemMock.Stub(m => m.Translation)
.Return(BuildTranslationMock(identifier))
.Repeat.Any();
foodItemMock.Stub(m => m.Translations)
.Return(translations ?? BuildTranslationMockCollection(identifier))
.Repeat.Any();
foodItemMock.Stub(m => m.ForeignKeys)
.Return(BuildForeignKeyMockCollection(identifier, typeof(IFoodItem), dataProvider))
.Repeat.Any();
return(foodItemMock);
}
public new void AddFoodItem(IFoodItem fooditem)
{
if (!(fooditem is EfcFoodItem))
{
throw new NotImplementedException("Must be compatible with EF Core");
}
AddFoodItem(fooditem as EfcFoodItem);
}
protected FoodItemDecorator(IFoodItem foodItem)
{
if (foodItem == null)
{
throw new ArgumentNullException("foodItem"); //nameof(foodItem)
}
this.baseObject = foodItem;
}
public Ingredient(double amount, IFoodItem foodItem) : base(foodItem)
{
if (amount < 0)
{
throw new ArgumentException("'amount' cannot be a negative number.", "amount"); //nameof(amount)
}
this.amount = amount;
}
/// <summary>
/// Creates a data proxy for a given relation between a food item and a food group in the food waste domain.
/// </summary>
/// <param name="foodItem">Food item which should be in the relation between a food item and a food group in the food waste domain.</param>
/// <param name="foodGroup">Food group which should be in the relation between a food item and a food group in the food waste domain.</param>
public FoodItemGroupProxy(IFoodItem foodItem, IFoodGroup foodGroup)
{
ArgumentNullGuard.NotNull(foodItem, nameof(foodItem))
.NotNull(foodGroup, nameof(foodGroup));
FoodItem = foodItem;
FoodGroup = foodGroup;
}
/// <summary>
/// Builds a generic food item,
/// food item type index defines the sprite type
/// </summary>
/// <param name="type"></param>
/// <param name="index"></param>
/// <param name="boardSize"></param>
/// <returns></returns>
private IFoodItem BuildFoodItem(int type, int index, int boardSize)
{
ConstructorInfo[] info = mFoodItemType.GetConstructors();
object[] args = (mCanvas == null) ? new object[3] : new object[4];
args[0] = type;
args[1] = index;
args[2] = boardSize;
if (mCanvas != null)
{
args[3] = mCanvas;
}
object obj = info[0].Invoke(args);
IFoodItem foodItem = obj as IFoodItem;
return(foodItem);
}
public SimpleNutritionItem(IFoodItem nutritionixIngredient)
{
var servingQuantity = nutritionixIngredient.Serving_qty ?? 1;
switch (nutritionixIngredient)
{
case InstantSearchResponse.Common common:
Name = common.Food_name;
MeasurementUnit = common.Serving_unit;
CaloriesPerMeasurementUnit = 0;
break;
case NutrientResponse.Food food:
var calories = food.Nf_calories ?? 1;
Name = food.Food_name;
MeasurementUnit = food.Serving_unit;
CaloriesPerMeasurementUnit = calories / servingQuantity;
break;
}
}
public void SetFoodItem(IFoodItem foodItem)
{
_fooditem = foodItem;
}
public CustomColorDecorator(IFoodItem baseFoodItem, Color newColor)
{
_baseFoodItem = baseFoodItem;
Color = newColor;
}
public void Initialize()
{
this.amount = 1;
this.foodItem = new FoodItemMock();
this.ingredient = new Ingredient(this.amount, this.foodItem);
}
public void GivenIHaveFoodItemsForMyMeal()
{
_foodItemOneMealOne = new FoodItem("Sandwich", 250);
_foodItemTwoMealOne = new FoodItem("Crisps", 100);
}
public static void CustomizePizza(IFoodItem pizza)
{
pizza999 = pizza;
}
public void GivenIHaveAnotherFoodItemForMySecondMeal()
{
_foodItemOneMealTwo = new FoodItem("Hotdog", 150);
}
public DoubleEffectDecorator(IFoodItem baseFoodItem)
{
_baseFoodItem = baseFoodItem;
Color = baseFoodItem.Color;
}
public void GivenIHaveAnotherFoodItemForMySecondSnack()
{
_foodItemOneSnackTwo = new FoodItem("Cookie", 100);
}
public void AddFoodItem(IFoodItem foodItem)
{
_fooditems.Add(foodItem);
base.Update();
}
public void AddItem(IFoodItem item)
{
FoodItemList.Add(item);
}
public void AddFood(IFoodItem item)
{
_meal.Add(item);
}
public void AddDrink(IFoodItem item)
{
_meal.Add(item);
}
private void Cart_Updated(IFoodItem item, float total)
{
Console.WriteLine($"{item.Name} added to the cart. Total = {total.ToString("00.00")}");
}
public void WhenICreateAFoodItem()
{
_foodItem = new FoodItem(_foodItemName, _calories);
}
public void GivenIHaveFoodItemsForMySnack()
{
_foodItemOneSnackOne = new FoodItem("Apple", 80);
}
public void GivenIHaveAFoodItemToBeDeleted()
{
_foodItem = new FoodItem("Hotdog", 120);
Assert.IsFalse(_foodItem.Deleted);
}
/// <summary>
/// Deletes an identifiable domain object in the repository.
/// </summary>
/// <typeparam name="TIdentifiable">Type of the identifiable domain object.</typeparam>
/// <param name="identifiable">Identifiable domain object to delete.</param>
public void Delete <TIdentifiable>(TIdentifiable identifiable) where TIdentifiable : IIdentifiable
{
if (Equals(identifiable, null))
{
throw new ArgumentNullException(nameof(identifiable));
}
IHousehold household = identifiable as IHousehold;
if (household != null)
{
Delete <IHousehold, IHouseholdProxy>(household);
return;
}
IStorage storage = identifiable as IStorage;
if (storage != null)
{
Delete <IStorage, IStorageProxy>(storage);
return;
}
IStorageType storageType = identifiable as IStorageType;
if (storageType != null)
{
Delete <IStorageType, IStorageTypeProxy>(storageType);
return;
}
IHouseholdMember householdMember = identifiable as IHouseholdMember;
if (householdMember != null)
{
Delete <IHouseholdMember, IHouseholdMemberProxy>(householdMember);
return;
}
IPayment payment = identifiable as IPayment;
if (payment != null)
{
Delete <IPayment, IPaymentProxy>(payment);
return;
}
IFoodItem foodItem = identifiable as IFoodItem;
if (foodItem != null)
{
Delete <IFoodItem, IFoodItemProxy>(foodItem);
return;
}
IFoodGroup foodGroup = identifiable as IFoodGroup;
if (foodGroup != null)
{
Delete <IFoodGroup, IFoodGroupProxy>(foodGroup);
return;
}
IForeignKey foreignKey = identifiable as IForeignKey;
if (foreignKey != null)
{
Delete <IForeignKey, IForeignKeyProxy>(foreignKey);
return;
}
IStaticText staticText = identifiable as IStaticText;
if (staticText != null)
{
Delete <IStaticText, IStaticTextProxy>(staticText);
return;
}
IDataProvider dataProvider = identifiable as IDataProvider;
if (dataProvider != null)
{
Delete <IDataProvider, IDataProviderProxy>(dataProvider);
return;
}
ITranslation translation = identifiable as ITranslation;
if (translation != null)
{
Delete <ITranslation, ITranslationProxy>(translation);
return;
}
ITranslationInfo translationInfo = identifiable as ITranslationInfo;
if (translationInfo != null)
{
Delete <ITranslationInfo, ITranslationInfoProxy>(translationInfo);
return;
}
throw new NotSupportedException();
}
public void Add(IFoodItem item)
{
_items.Add(item);
}
