/// <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);
}
/// <summary>
/// Build a mockup for a food group.
/// </summary>
/// <param name="parentMock">Mockup for the parent food group.</param>
/// <param name="isActive">Indicates whether the food group should be active or inactive.</param>
/// <param name="dataProvider">Data provider who owns one of the foreign keys.</param>
/// <param name="translations">Collection for translation mockups for the food group.</param>
/// <returns>Mockup for a food group.</returns>
public static IFoodGroup BuildFoodGroupMock(IFoodGroup parentMock = null, bool isActive = true, IDataProvider dataProvider = null, IEnumerable <ITranslation> translations = null)
{
Guid identifier = Guid.NewGuid();
IFoodGroup foodGroupMock = MockRepository.GenerateMock <IFoodGroup>();
foodGroupMock.Stub(m => m.Identifier)
.Return(identifier)
.Repeat.Any();
foodGroupMock.Stub(m => m.Parent)
.Return(parentMock)
.Repeat.Any();
foodGroupMock.Stub(m => m.IsActive)
.Return(isActive)
.Repeat.Any();
foodGroupMock.Stub(m => m.Children)
.Return(parentMock != null ? new List <IFoodGroup>(0) : BuildFoodGroupMockCollection(foodGroupMock))
.Repeat.Any();
foodGroupMock.Stub(m => m.Translation)
.Return(BuildTranslationMock(identifier))
.Repeat.Any();
foodGroupMock.Stub(m => m.Translations)
.Return(translations ?? BuildTranslationMockCollection(identifier))
.Repeat.Any();
foodGroupMock.Stub(m => m.ForeignKeys)
.Return(BuildForeignKeyMockCollection(identifier, typeof(IFoodGroup), dataProvider))
.Repeat.Any();
return(foodGroupMock);
}
/// <summary>
/// Functionality which handles a query for getting the collection of food items.
/// </summary>
/// <param name="query">Query for getting the collection of food items.</param>
/// <returns>Collection of food items.</returns>
public virtual TFoodItemCollectionView Query(FoodItemCollectionGetQuery query)
{
if (query == null)
{
throw new ArgumentNullException("query");
}
var translationInfo = _systemDataRepository.Get <ITranslationInfo>(query.TranslationInfoIdentifier);
var dataProvider = _systemDataRepository.DataProviderForFoodItemsGet();
IFoodGroup foodGroup = null;
if (query.FoodGroupIdentifier.HasValue)
{
foodGroup = _systemDataRepository.Get <IFoodGroup>(query.FoodGroupIdentifier.Value);
}
dataProvider.Translate(translationInfo.CultureInfo);
var foodItemCollection = foodGroup == null
? GetFoodItemsForDataProvider(_systemDataRepository.FoodItemGetAll(), dataProvider)
: GetFoodItemsForDataProvider(_systemDataRepository.FoodItemGetAllForFoodGroup(foodGroup), dataProvider);
if (OnlyActive)
{
foodItemCollection.RemoveInactiveFoodItems();
}
return(_foodWasteObjectMapper.Map <IFoodItemCollection, TFoodItemCollectionView>(foodItemCollection, translationInfo.CultureInfo));
}
/// <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>
/// Adds a food group which this food item should belong to.
/// </summary>
/// <param name="foodGroup">Food group which this food item should belong to.</param>
public virtual void FoodGroupAdd(IFoodGroup foodGroup)
{
if (foodGroup == null)
{
throw new ArgumentNullException("foodGroup");
}
_foodGroups.Add(foodGroup);
}
/// <summary>
/// Creates a food item.
/// </summary>
/// <param name="primaryFoodGroup">Primary food group for the food item.</param>
public FoodItem(IFoodGroup primaryFoodGroup)
{
if (primaryFoodGroup == null)
{
throw new ArgumentNullException("primaryFoodGroup");
}
_primaryFoodGroup = primaryFoodGroup;
_foodGroups.Add(primaryFoodGroup);
}
/// <summary>
/// Build a collection of mockups for some food groups.
/// </summary>
/// <param name="parentMock">Mockup for the parent food group.</param>
/// <returns>Collection of mockups for some food groups.</returns>
public static IEnumerable <IFoodGroup> BuildFoodGroupMockCollection(IFoodGroup parentMock = null)
{
List <IFoodGroup> result = new List <IFoodGroup>(Random.Next(1, 5));
while (result.Count < result.Capacity)
{
result.Add(BuildFoodGroupMock(parentMock));
}
return(result);
}
/// <summary>
/// Build an instance of <see cref="FoodItemGroupProxy"/>.
/// </summary>
/// <param name="foodItemProxy">The <see cref="IFoodItemProxy"/> included in the <see cref="FoodItemGroupProxy"/>.</param>
/// <param name="foodGroup">The <see cref="IFoodGroup"/> include in the <see cref="FoodItemGroupProxy"/>.</param>
/// <param name="isPrimary">Indicates whether this <see cref="FoodItemGroupProxy"/> describes the primary <param name="foodGroup"> for the <paramref name="foodItemProxy"/>.</param></param>
/// <returns>Instance of <see cref="FoodItemGroupProxy"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="foodItemProxy"/> or <paramref name="foodGroup"/> is null.</exception>
internal static FoodItemGroupProxy Build(IFoodItemProxy foodItemProxy, IFoodGroup foodGroup, bool isPrimary)
{
ArgumentNullGuard.NotNull(foodItemProxy, nameof(foodItemProxy))
.NotNull(foodGroup, nameof(foodGroup));
return(new FoodItemGroupProxy(foodItemProxy, foodGroup)
{
Identifier = Guid.NewGuid(),
IsPrimary = isPrimary
});
}
/// <summary>
/// Executes the command which handles a command for importing a food group from a given data provider.
/// </summary>
/// <param name="command">Command which imports a food group from a given data provider.</param>
/// <returns>Service receipt.</returns>
public virtual ServiceReceiptResponse Execute(FoodGroupImportFromDataProviderCommand command)
{
if (command == null)
{
throw new ArgumentNullException("command");
}
var dataProvider = SystemDataRepository.Get <IDataProvider>(command.DataProviderIdentifier);
var translationInfo = SystemDataRepository.Get <ITranslationInfo>(command.TranslationInfoIdentifier);
IFoodGroup parentFoodGroup = null;
var parentKey = command.ParentKey;
if (string.IsNullOrWhiteSpace(parentKey) == false)
{
parentFoodGroup = SystemDataRepository.FoodGroupGetByForeignKey(dataProvider, parentKey);
}
Specification.IsSatisfiedBy(() => CommonValidations.IsNotNull(dataProvider), new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.IdentifierUnknownToSystem, command.DataProviderIdentifier)))
.IsSatisfiedBy(() => CommonValidations.IsNotNull(translationInfo), new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.IdentifierUnknownToSystem, command.TranslationInfoIdentifier)))
.IsSatisfiedBy(() => CommonValidations.HasValue(command.Key), new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.ValueMustBeGivenForProperty, "Key")))
.IsSatisfiedBy(() => CommonValidations.ContainsIllegalChar(command.Key) == false, new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.ValueForPropertyContainsIllegalChars, "Key")))
.IsSatisfiedBy(() => CommonValidations.HasValue(command.Name), new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.ValueMustBeGivenForProperty, "Name")))
.IsSatisfiedBy(() => CommonValidations.ContainsIllegalChar(command.Name) == false, new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.ValueForPropertyContainsIllegalChars, "Name")))
.IsSatisfiedBy(() => string.IsNullOrWhiteSpace(parentKey) || (string.IsNullOrWhiteSpace(parentKey) == false && CommonValidations.IsNotNull(parentFoodGroup)), new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.IllegalValue, parentKey, "ParentKey")))
.Evaluate();
var foodGroup = SystemDataRepository.FoodGroupGetByForeignKey(dataProvider, command.Key);
if (foodGroup == null)
{
var insertedfoodGroup = SystemDataRepository.Insert <IFoodGroup>(new FoodGroup {
IsActive = true, Parent = parentFoodGroup
});
var foreignKey = new ForeignKey(dataProvider, insertedfoodGroup.Identifier.HasValue ? insertedfoodGroup.Identifier.Value : default(Guid), insertedfoodGroup.GetType(), command.Key);
foreignKey.Identifier = _logicExecutor.ForeignKeyAdd(foreignKey);
insertedfoodGroup.ForeignKeyAdd(foreignKey);
ImportTranslation(insertedfoodGroup, translationInfo, command.Name, _logicExecutor);
return(ObjectMapper.Map <IIdentifiable, ServiceReceiptResponse>(insertedfoodGroup));
}
foodGroup.IsActive = command.IsActive;
foodGroup.Parent = parentFoodGroup;
var updatedFoodGroup = SystemDataRepository.Update(foodGroup);
ImportTranslation(updatedFoodGroup, translationInfo, command.Name, _logicExecutor);
return(ObjectMapper.Map <IIdentifiable, ServiceReceiptResponse>(updatedFoodGroup));
}
/// <summary>
/// Gets all the food items which belongs to a given food group.
/// </summary>
/// <param name="foodGroup">Food group which the food items should belong to.</param>
/// <returns>All food items which belongs to the given food group.</returns>
public virtual IEnumerable <IFoodItem> FoodItemGetAllForFoodGroup(IFoodGroup foodGroup)
{
ArgumentNullGuard.NotNull(foodGroup, nameof(foodGroup));
try
{
if (foodGroup.Identifier.HasValue == false)
{
throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.IllegalValue, foodGroup.Identifier, "Identifier"));
}
MySqlCommand command = FoodItemProxy.BuildSystemDataCommandForSelecting("INNER JOIN FoodItemGroups AS fig ON fig.FoodItemIdentifier=fi.FoodItemIdentifier WHERE fig.FoodGroupIdentifier=@foodGroupIdentifier", systemCommandBuilder => systemCommandBuilder.AddFoodGroupIdentifierParameter(foodGroup.Identifier));
return(DataProvider.GetCollection <FoodItemProxy>(command));
}
catch (IntranetRepositoryException)
{
throw;
}
catch (Exception ex)
{
throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.RepositoryError, MethodBase.GetCurrentMethod().Name, ex.Message), ex);
}
}
/// <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();
}
/// <summary>
/// Creates a data proxy for a food item.
/// </summary>
/// <param name="primaryFoodGroup">Primary food group for the food item.</param>
public FoodItemProxy(IFoodGroup primaryFoodGroup)
: base(primaryFoodGroup)
{
_foodGroupCollectionHasBeenLoaded = true;
}
/// <summary>
/// Save relations.
/// </summary>
/// <param name="dataProvider">Implementation of the data provider used to access data.</param>
/// <param name="isInserting">Indication of whether we are inserting or updating.</param>
public virtual void SaveRelations(IDataProviderBase <MySqlDataReader, MySqlCommand> dataProvider, bool isInserting)
{
ArgumentNullGuard.NotNull(dataProvider, nameof(dataProvider));
if (Identifier.HasValue == false)
{
throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.IllegalValue, Identifier, "Identifier"));
}
if (PrimaryFoodGroup != null && PrimaryFoodGroup.Identifier.HasValue == false)
{
throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.IllegalValue, PrimaryFoodGroup.Identifier, "PrimaryFoodGroup.Identifier"));
}
IFoodGroup foodGroupWithoutIdentifier = FoodGroups.FirstOrDefault(foodGroup => foodGroup.Identifier.HasValue == false);
if (foodGroupWithoutIdentifier != null)
{
throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.IllegalValue, foodGroupWithoutIdentifier.Identifier, "FoodGroups[].Identifier"));
}
IList <FoodItemGroupProxy> foodItemGroups = FoodItemGroupProxy.GetFoodItemGroups(dataProvider, Identifier.Value).ToList();
if (PrimaryFoodGroup?.Identifier != null && foodItemGroups.SingleOrDefault(foodItemGroup => foodItemGroup.FoodGroupIdentifier.HasValue && foodItemGroup.FoodGroupIdentifier.Value == PrimaryFoodGroup.Identifier.Value) == null)
{
using (IFoodWasteDataProvider subDataProvider = (IFoodWasteDataProvider)dataProvider.Clone())
{
foodItemGroups.Add(subDataProvider.Add(FoodItemGroupProxy.Build(this, PrimaryFoodGroup, true)));
}
}
IFoodGroup missingFoodGroup = FoodGroups.FirstOrDefault(foodGroup => foodGroup.Identifier.HasValue && foodItemGroups.Any(foodItemGroup => foodItemGroup.FoodGroupIdentifier.HasValue && foodItemGroup.FoodGroupIdentifier.Value == foodGroup.Identifier.Value) == false);
while (missingFoodGroup != null)
{
using (IFoodWasteDataProvider subDataProvider = (IFoodWasteDataProvider)dataProvider.Clone())
{
foodItemGroups.Add(subDataProvider.Add(FoodItemGroupProxy.Build(this, missingFoodGroup, false)));
}
missingFoodGroup = FoodGroups.FirstOrDefault(foodGroup => foodGroup.Identifier.HasValue && foodItemGroups.Any(foodItemGroup => foodItemGroup.FoodGroupIdentifier.HasValue && foodItemGroup.FoodGroupIdentifier.Value == foodGroup.Identifier.Value) == false);
}
FoodItemGroupProxy noLongerExistingFoodItemGroup = foodItemGroups.FirstOrDefault(foodItemGroup => foodItemGroup.FoodGroupIdentifier.HasValue && FoodGroups.Any(foodGroup => foodGroup.Identifier.HasValue && foodGroup.Identifier.Value == foodItemGroup.FoodGroupIdentifier.Value) == false);
while (noLongerExistingFoodItemGroup != null)
{
using (IFoodWasteDataProvider subDataProvider = (IFoodWasteDataProvider)dataProvider.Clone())
{
subDataProvider.Delete(noLongerExistingFoodItemGroup);
foodItemGroups.Remove(noLongerExistingFoodItemGroup);
}
noLongerExistingFoodItemGroup = foodItemGroups.FirstOrDefault(foodItemGroup => foodItemGroup.FoodGroupIdentifier.HasValue && FoodGroups.Any(foodGroup => foodGroup.Identifier.HasValue && foodGroup.Identifier.Value == foodItemGroup.FoodGroupIdentifier.Value) == false);
}
if (PrimaryFoodGroup == null || PrimaryFoodGroup.Identifier.HasValue == false)
{
_dataProvider = (IFoodWasteDataProvider)dataProvider;
return;
}
FoodItemGroupProxy primaryFoodItemGroup = foodItemGroups.SingleOrDefault(foodItemGroup => foodItemGroup.FoodGroupIdentifier.HasValue && foodItemGroup.FoodGroupIdentifier.Value == PrimaryFoodGroup.Identifier.Value);
if (primaryFoodItemGroup != null && primaryFoodItemGroup.IsPrimary == false)
{
primaryFoodItemGroup.IsPrimary = true;
using (IFoodWasteDataProvider subDataProvider = (IFoodWasteDataProvider)dataProvider.Clone())
{
foodItemGroups.Remove(primaryFoodItemGroup);
foodItemGroups.Add(subDataProvider.Save(primaryFoodItemGroup));
}
}
FoodItemGroupProxy nonPrimaryFoodItemGroup = foodItemGroups.Where(foodItemGroup => foodItemGroup.FoodGroupIdentifier.HasValue && foodItemGroup.FoodGroupIdentifier.Value != PrimaryFoodGroup.Identifier.Value).SingleOrDefault(foodItemGroup => foodItemGroup.IsPrimary);
while (nonPrimaryFoodItemGroup != null)
{
nonPrimaryFoodItemGroup.IsPrimary = false;
using (IFoodWasteDataProvider subDataProvider = (IFoodWasteDataProvider)dataProvider.Clone())
{
foodItemGroups.Remove(nonPrimaryFoodItemGroup);
foodItemGroups.Add(subDataProvider.Save(nonPrimaryFoodItemGroup));
}
nonPrimaryFoodItemGroup = foodItemGroups.Where(foodItemGroup => foodItemGroup.FoodGroupIdentifier.HasValue && foodItemGroup.FoodGroupIdentifier.Value != PrimaryFoodGroup.Identifier.Value).SingleOrDefault(foodItemGroup => foodItemGroup.IsPrimary);
}
_dataProvider = (IFoodWasteDataProvider)dataProvider;
}
