/// <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; }