public override ValidationOutput DTOIsValidForUpdate(MaterialDto consideredDto) { ValidationOutput validationOutput = new ValidationOutputBadRequest(); if (consideredDto.Name != null) { if (!NameIsValid(consideredDto.Name)) { validationOutput.AddError("Name of material", "New name'" + consideredDto.Name + "' is not valid!"); } } if (consideredDto.Description != null) { if (!DescriptionIsValid(consideredDto.Description)) { validationOutput.AddError("Description of material", "New description'" + consideredDto.Description + "' is not valid!"); } } if (consideredDto.Price != null) { ValidationOutput priceDTOValidationOutput = _priceDTOValidator.DTOIsValid(consideredDto.Price); if (priceDTOValidationOutput.HasErrors()) { priceDTOValidationOutput.AppendToAllkeys("Material '" + consideredDto.Reference + "' > "); validationOutput.Join(priceDTOValidationOutput); } } return(validationOutput); }
public override ValidationOutput DTOIsValid(ModelGroupDto consideredDto) { ValidationOutput validationOutput = new ValidationOutputBadRequest(); if (!RelativeURLIsValid(consideredDto.RelativeURL)) { validationOutput.AddError("RelativeURL", "URL to OBJ file is invalid!"); return(validationOutput); } var components = consideredDto.Components; if (!(components.Count > 0)) { validationOutput.AddError("Components", "There are no components"); return(validationOutput); } foreach (var component in components) { validationOutput = _componentDTOValidator.DTOIsValid(component); if (validationOutput.HasErrors()) { return(validationOutput); } } return(validationOutput); }
public override ValidationOutput DTOIsValidForRegister(CategoryDto consideredDto) { ValidationOutput validationOutput = new ValidationOutputBadRequest(); if (consideredDto.IsExternal != null) { if (!IsExternalIsValid(consideredDto.IsExternal)) { validationOutput.AddError("Verification of category", "The is external verification'" + consideredDto.IsExternal + "' is not valid!"); } } if (!NameIsValid(consideredDto.Name)) { validationOutput.AddError("Name of category", "The name'" + consideredDto.Name + "' is not valid!"); } if (!DescriptionIsValid(consideredDto.Description)) { validationOutput.AddError("Description of category", "The description'" + consideredDto.Description + "' is not valid!"); } if (!ParentCategoryReferenceIsValid(consideredDto.ParentCategoryReference)) { validationOutput.AddError("Parent category reference of category", "The parent category reference '" + consideredDto.ParentCategoryReference + "' is not valid!"); } return(validationOutput); }
public ValidationOutput PossibleWidthsIsValid(DimensionValuesDto consideredDto) { ValidationOutput validationOutput = new ValidationOutputBadRequest(); List <ValuesDto> possibleWidths = new List <ValuesDto>(); foreach (var setOfValuesDto in consideredDto.PossibleWidths) { ValidationOutput eachValueValidationOutput = _valuesDTOValidator.DTOIsValid(setOfValuesDto); if (eachValueValidationOutput.HasErrors()) { validationOutput.Join(eachValueValidationOutput); return(validationOutput); } validationOutput = new ValidationOutputBadRequest(); if (possibleWidths.Contains(setOfValuesDto)) { if (setOfValuesDto is ContinuousValueDto) { ContinuousValueDto temp = (ContinuousValueDto)setOfValuesDto; validationOutput.AddError("Dimension's widths", "The width interval [" + temp.MinValue + ", " + temp.MaxValue + "] is duplicated in the list of possible widths."); } if (setOfValuesDto is DiscreteValueDto) { validationOutput.AddError("Dimension's widths", "The width '" + setOfValuesDto + "' is duplicated in the list of possible widths."); } return(validationOutput); } possibleWidths.Add(setOfValuesDto); } return(validationOutput); }
/** * Method that will add new configured products to the collection with the passed reference. * It is assumed that a list with 1 or more objects is received. * * Validations performed: * 1. Validation of the passed collection's reference (database); * 2. The received list has 1 or more elements. * FOREACH RECEIVED string (Configured Product reference) { * 3. Validation of current configured product reference (database); * 4. Validation of the existence of current configured product in the collection with the passed reference * 5. Validation for duplication between each configured product reference received */ public ValidationOutput AddConfiguredProducts(string reference, IEnumerable <ConfiguredProductDto> enumerableConfiguredProduct) { //1. ValidationOutput validationOutput = new ValidationOutputNotFound(); if (!CollectionExists(reference)) { validationOutput.AddError("Reference of collection", "No collection with the reference '" + reference + "' exists in the system."); return(validationOutput); } Collection collectionToModify = _collectionRepository.GetByReference(reference); List <ConfiguredProductDto> configuredProductList = new List <ConfiguredProductDto>(enumerableConfiguredProduct); //2. validationOutput = new ValidationOutputBadRequest(); if (configuredProductList.Count == 0) { validationOutput.AddError("Selected configured products", "No configured products were selected!"); return(validationOutput); } List <string> configuredProductListToAdd = new List <string>(); foreach (var configuredProduct in configuredProductList) { //3. if (!ConfiguredProductExists(configuredProduct.Reference)) { validationOutput.AddError("Reference of configured product", "No configured product with the reference '" + configuredProduct.Reference + "' exists in the system."); return(validationOutput); } //4. if (collectionToModify.ConfiguredProductIsInCollection(configuredProduct.Reference)) { validationOutput.AddError("Configured product", "Configured product '" + configuredProduct.Reference + "' already belongs to collection with reference '" + reference + "'."); return(validationOutput); } //5. if (configuredProductListToAdd.Contains(configuredProduct.Reference)) { validationOutput.AddError("Configured product", "Configured product '" + configuredProduct.Reference + "' is duplicated in the list of configured product selected!"); return(validationOutput); } configuredProductListToAdd.Add(configuredProduct.Reference); } foreach (var configuredProductToAdd in configuredProductListToAdd) { collectionToModify.AddConfiguredProduct(configuredProductToAdd); } validationOutput.DesiredReturn = configuredProductListToAdd; _collectionRepository.Update(collectionToModify); return(validationOutput); }
public override ValidationOutput DTOIsValidForUpdate(FinishDto consideredDto) { ValidationOutput validationOutput = new ValidationOutputBadRequest(); if (!ReferenceIsValid(consideredDto.Reference)) { validationOutput.AddError("Reference of finish", "New reference '" + consideredDto.Reference + "' is invalid!"); } if (!NameIsValid(consideredDto.Name)) { validationOutput.AddError("Name of finish", "New name '" + consideredDto.Name + "' is invalid!"); } if (!DescriptionIsValid(consideredDto.Description)) { validationOutput.AddError("Description of finish", "New description '" + consideredDto.Description + "' is invalid!"); } if (consideredDto.Price != null) { ValidationOutput priceDTOValidationOutput = _priceDTOValidator.DTOIsValid(consideredDto.Price); if (priceDTOValidationOutput.HasErrors()) { priceDTOValidationOutput.AppendToAllkeys("Finish '" + consideredDto.Reference + "' | "); validationOutput.Join(priceDTOValidationOutput); } } else { validationOutput.AddError("Price of finish", "The price has can not be null!"); } return(validationOutput); }
public override ValidationOutput DTOIsValid(RatioAlgorithmDto consideredDto) { ValidationOutput validationOutput = new ValidationOutputBadRequest(); if (consideredDto == null) { validationOutput.AddError("Ratio algorithm", "Null."); return(validationOutput); } if (!ValueDescIsValid(consideredDto.FirstValueDesc)) { validationOutput.AddError("Ratio algorithm's First Value", "Inputed value description '" + consideredDto.FirstValueDesc + "' is not valid!"); } if (!ValueDescIsValid(consideredDto.SecondValueDesc)) { validationOutput.AddError("Ratio algorithm's Second Value", "Inputed value description '" + consideredDto.SecondValueDesc + "' is not valid!"); } if (!OperatorIsValid(consideredDto.Operator)) { validationOutput.AddError("Ratio algorithm's Operator", "Inputed operator '" + consideredDto.Operator + "' is not valid!"); } if (!RatioIsValid(consideredDto.Ratio)) { validationOutput.AddError("Ratio algorithm's Ratio", "Inputed ratio '" + consideredDto.Ratio + "' is not valid!"); } return(validationOutput); }
public override ValidationOutput DTOIsValidForUpdate(ProductDto consideredDto) { ValidationOutput validationOutput = new ValidationOutputBadRequest(); if (consideredDto.Name != null) { if (!NameIsValid(consideredDto.Name)) { validationOutput.AddError("Name of product", "New name '" + consideredDto.Name + "' is not valid!"); } } if (consideredDto.Description != null) { if (!DescriptionIsValid(consideredDto.Description)) { validationOutput.AddError("Description of product", "New description '" + consideredDto.Description + "' is not valid!"); } } if (consideredDto.Price != null) { ValidationOutput priceDTOValidationOutput = _priceDTOValidator.DTOIsValid(consideredDto.Price); if (priceDTOValidationOutput.HasErrors()) { priceDTOValidationOutput.AppendToAllkeys("Product '" + consideredDto.Reference + "' > "); validationOutput.Join(priceDTOValidationOutput); } } if (consideredDto.SlotDefinition != null) { ValidationOutput slotDefinitionDTOValidationOutput = _slotDefinitionDTOValidator.DTOIsValid(consideredDto.SlotDefinition); if (slotDefinitionDTOValidationOutput.HasErrors()) { slotDefinitionDTOValidationOutput.AppendToAllkeys("Product '" + consideredDto.Reference + "' > "); validationOutput.Join(slotDefinitionDTOValidationOutput); } } var modelGroup = consideredDto.ModelGroup; if (modelGroup != null) { ValidationOutput modelGroupValidationOutput = _modelGroupDTOValidator.DTOIsValid(modelGroup); if (validationOutput.HasErrors()) { validationOutput.Join(modelGroupValidationOutput); } } return(validationOutput); }
/** * Method that will delete configured products, that belong to a certain, existing collection, (in the form of ProductCollection objects) from the catalog with the passed reference. * It is assumed that a list with 1 or more objects is received. * * Validations performed: * 1. Validation of the passed catalog's reference (database); * 2. The received list has 1 or more elements. * FOREACH RECEIVED ProductCollection { * 3. Validation of the existence of current ProductCollection received, in the catalog with the passed reference * 4. Validation for duplication between each ProductCollection received * } */ public ValidationOutput DeleteVariousProductCollection(string reference, IEnumerable <ProductCollectionDto> enumerableProductCollectionDto) { //1. ValidationOutput validationOutput = new ValidationOutputBadRequest(); if (!CatalogExists(reference)) { validationOutput.AddError("Reference of catalog", "No catalog with the '" + reference + "' exists in the system!"); return(validationOutput); } Catalog catalogToModify = _catalogRepository.GetByReference(reference); List <ProductCollectionDto> productCollectionDtoList = new List <ProductCollectionDto>(enumerableProductCollectionDto); //2. validationOutput = new ValidationOutputBadRequest(); if (productCollectionDtoList.Count == 0) { validationOutput.AddError("Selected 'configured product - collection' items", "No 'configured product - collection' items were selected!"); return(validationOutput); } List <ProductCollection> productCollectionListToRemove = new List <ProductCollection>(); foreach (var currentProductCollectionDto in productCollectionDtoList) { ProductCollection currentProdCollection = _mapper.Map <ProductCollection>(currentProductCollectionDto); //3. if (!catalogToModify.ContainsProductCollection(currentProdCollection)) { validationOutput.AddError("'Configured product - collection' item", "'Configured product - collection' item with configured product '" + currentProdCollection.ConfiguredProductReference + "' that is associated with the collection '" + currentProdCollection.CollectionReference + "' does not belong to catalog with reference '" + reference + "'"); return(validationOutput); } //4. if (productCollectionListToRemove.Contains(currentProdCollection)) { validationOutput.AddError("'Configured product - collection' item", "'Configured product - collection' item with configured product '" + currentProdCollection.ConfiguredProductReference + "' that is associated with the collection '" + currentProdCollection.CollectionReference + "' is duplicated in the list of 'configured product - collection' items selected!"); return(validationOutput); } productCollectionListToRemove.Add(currentProdCollection); } foreach (var productCollectionToRemove in productCollectionListToRemove) { catalogToModify.RemoveProductCollection(productCollectionToRemove); } _catalogRepository.Update(catalogToModify); return(validationOutput); }
public ValidationOutput DTOIsValidForRegister(ColorDto consideredDto) { ValidationOutput validationOutput = new ValidationOutputBadRequest(); if (!NameIsValid(consideredDto.Name)) { validationOutput.AddError("Name of color", "The name'" + consideredDto.Name + "' is not valid!"); } if (!HexCodeIsValid(consideredDto.HexCode)) { validationOutput.AddError("Hex Code of color", "The hex code'" + consideredDto.HexCode + "' is not valid!"); } return(validationOutput); }
public override ValidationOutput DTOIsValidForUpdate(CollectionDto consideredDto) { ValidationOutput validationOutput = new ValidationOutputBadRequest(); if (!NameIsValid(consideredDto.Name)) { validationOutput.AddError("Name of collection", "New name'" + consideredDto.Name + "' is not valid!"); } if (!DescriptionIsValid(consideredDto.Description)) { validationOutput.AddError("Description of collection", "New description'" + consideredDto.Description + "' is not valid!"); } return(validationOutput); }
public override ValidationOutput DTOIsValid(AlgorithmDto consideredDto) { if (consideredDto is MaterialFinishPartAlgorithmDto) { return(new ValidationOutputBadRequest()); } if (consideredDto is MaterialPartAlgorithmDto) { return(new ValidationOutputBadRequest()); } if (consideredDto is RatioAlgorithmDto) { return(_ratioAlgorithmDTOValidator.DTOIsValid((RatioAlgorithmDto)consideredDto)); } if (consideredDto is SizePartAlgorithmDto) { return(new ValidationOutputBadRequest()); } if (consideredDto is SizePercentagePartAlgorithmDto) { return(_sizePercentagePartAlgorithmDTOValidator.DTOIsValid((SizePercentagePartAlgorithmDto)consideredDto)); } ValidationOutput validationOutput = new ValidationOutputBadRequest(); validationOutput.AddError("Inputed algorithm", "Algorithm not recongized."); return(validationOutput); }
private ValidationOutput ValidateConfiguredProduct(ChildConfiguredProductDto configuredDto) { ValidationOutput validationOutput = new ValidationOutputBadRequest(); var product = _productRepository.GetByReference(configuredDto.ProductReference); if (!product.ChosenDimensionDtoIsValid(configuredDto.ConfiguredDimension)) { validationOutput.AddError("Configured Product's dimension", "Chosen Dimension does not belong to any possible dimension"); return(validationOutput); } if (!product.ConfiguredMaterialDtoExists(configuredDto.ConfiguredMaterial)) { validationOutput.AddError("Configured Material's reference", "Product does not support the chosen material"); return(validationOutput); } ValidateMaterial(configuredDto, validationOutput); if (validationOutput.HasErrors()) { return(validationOutput); } ValidateSlotDefinition(product, configuredDto, validationOutput); if (validationOutput.HasErrors()) { return(validationOutput); } var parentConfiguredProduct = _configuredProductRepository.GetByReference(configuredDto.ParentReference); if (parentConfiguredProduct != null) { ChildrenFits(configuredDto.SlotReference, parentConfiguredProduct, configuredDto, validationOutput); if (validationOutput.HasErrors()) { return(validationOutput); } } if (!ObeysRestrictions(configuredDto)) { validationOutput.AddError("Restriction", "Configured Product does not obey to defined restrictions!"); } validationOutput.DesiredReturn = new Price[] { product.Price, ((Price[])validationOutput.DesiredReturn)[1], ((Price[])validationOutput.DesiredReturn)[0] }; return(validationOutput); }
public override ValidationOutput DTOIsValid(DimensionValuesDto consideredDto) { ValidationOutput validationOutput = new ValidationOutputBadRequest(); if (string.IsNullOrEmpty(consideredDto.Reference)) { validationOutput.AddError("Dimension's Reference", "There is no reference."); return(validationOutput); } //================== PossibleHeights attribute ================== if (consideredDto.PossibleHeights == null || consideredDto.PossibleHeights.Count <= 0) { validationOutput.AddError("Dimension's heights", "There are no heights."); return(validationOutput); } validationOutput = this.PossibleHeightsIsValid(consideredDto); if (validationOutput.HasErrors()) { return(validationOutput); } //================== PossibleWidths attribute ================== if (consideredDto.PossibleWidths == null || consideredDto.PossibleWidths.Count <= 0) { validationOutput.AddError("Dimension's widths", "There are no widths."); return(validationOutput); } validationOutput = this.PossibleWidthsIsValid(consideredDto); if (validationOutput.HasErrors()) { return(validationOutput); } //================== PossibleDepths attribute ================== if (consideredDto.PossibleDepths == null || consideredDto.PossibleDepths.Count <= 0) { validationOutput.AddError("Dimension's depths", "There are no depths"); return(validationOutput); } validationOutput = this.PossibleDepthsIsValid(consideredDto); return(validationOutput); }
// ============ Methods to CREATE something ============ /** * Method that will validate and create a new material in the database. * * Validations performed: * 1. Validation of the new material's reference (business rules); * 2. Validation of the new material's reference (database); * 3. Validation of the received info. (name, description, colors, finishes) (business rules) */ public ValidationOutput Register(MaterialDto dto) { //1. ValidationOutput validationOutput = _materialDTOValidator.DTOReferenceIsValid(dto.Reference); if (validationOutput.HasErrors()) { return(validationOutput); } //2. validationOutput = new ValidationOutputBadRequest(); if (MaterialExists(dto.Reference)) { validationOutput.AddError("Reference of material", "A material with the reference '" + dto.Reference + "' already exists in the system!"); return(validationOutput); } //3. validationOutput = _materialDTOValidator.DTOIsValidForRegister(dto); if (validationOutput.HasErrors()) { return(validationOutput); } if (dto.Colors.Count > 0) { validationOutput = PrivateAddColorsWithMaterial(dto.Colors); if (validationOutput.HasErrors()) { return(validationOutput); } } if (dto.Finishes.Count > 0) { validationOutput = PrivateAddFinishesWithMaterial(dto.Finishes); if (validationOutput.HasErrors()) { return(validationOutput); } } //NOTA: Ainda que este método verifique se o atributo Price é != null, nós, aqui no Register, nunca deixamos que seja null devido às validações AddNewPriceToMaterialHistory(dto); foreach (var finish in dto.Finishes) { finish.IsActive = true; } //If we reached here then that means we can add the new material validationOutput.DesiredReturn = _mapper.Map <MaterialDto>( _materialRepository.Add(_mapper.Map <Material>(dto))); return(validationOutput); }
public override ValidationOutput DTOIsValid(ColorDto consideredDto) { ValidationOutput validationOutput = new ValidationOutputBadRequest(); if (!NameIsValid(consideredDto.Name)) { validationOutput.AddError("Color's name", "New name '" + consideredDto.Name + "' is not valid!"); } if (!DescriptionIsValid(consideredDto.Description)) { validationOutput.AddError("Color's description", "Description '" + consideredDto.Description + "' is not valid!"); } if (!HexCodeIsValid(consideredDto.HexCode)) { validationOutput.AddError("Color's hex code", "Hex Code '" + consideredDto.HexCode + "' is not valid!"); } return(validationOutput); }
public ValidationOutput DTOIsValidForUpdate(ColorDto consideredDto) { ValidationOutput validationOutput = new ValidationOutputBadRequest(); if (!NameIsValid(consideredDto.Name)) { validationOutput.AddError("Name of color", "New name'" + consideredDto.Name + "' is not valid!"); } if (!DescriptionIsValid(consideredDto.Description)) { validationOutput.AddError("Description of color", "New description'" + consideredDto.Description + "' is not valid!"); } if (!HexCodeIsValid(consideredDto.HexCode)) { validationOutput.AddError("Hex Code", "The hex code '" + consideredDto.HexCode + "' is not valid!"); } return(validationOutput); }
/** * Validations performed: * * 1. The received list has 1 or more elements. * FOREACH RECEIVED Color{ * 2. Validation of each color's definition (business rules); * 3. Validation of the existence of each Color received, in the material with the passed reference * 4. Validation for duplication between received colors * } */ private ValidationOutput PrivateAddColorsWithMaterial(IEnumerable <ColorDto> enumerableColorDto) { List <ColorDto> listColorDto = new List <ColorDto>( enumerableColorDto); //Since we receive an IEnumerable, we need to have something concrete //1. ValidationOutput validationOutput = new ValidationOutputBadRequest(); if (listColorDto.Count == 0) { validationOutput.AddError("Selected colors", "No colors were selected!"); return(validationOutput); } List <ColorDto> colorsToAdd = new List <ColorDto>(); foreach (var currentColorDto in listColorDto) { validationOutput = new ValidationOutputBadRequest(); //2. validationOutput = _colorDTOValidator.DTOReferenceIsValid(currentColorDto.HexCode); if (validationOutput.HasErrors()) { return(validationOutput); } validationOutput = _colorDTOValidator.DTOIsValid(currentColorDto); if (validationOutput.HasErrors()) { return(validationOutput); } //3. validationOutput = _colorDTOValidator.DTOIsValidForRegister(currentColorDto); if (validationOutput.HasErrors()) { return(validationOutput); } //4. if (colorsToAdd.Contains(currentColorDto)) { validationOutput.AddError("Color", "Color with the hex code '" + currentColorDto.HexCode + "' is duplicated in the list of selected colors."); return(validationOutput); } colorsToAdd.Add(currentColorDto); } return(validationOutput); }
public override ValidationOutput DTOIsValid(PriceDto consideredDto) { ValidationOutput validationOutput = new ValidationOutputBadRequest(); if (!ValueIsValid(consideredDto.Value)) { validationOutput.AddError("Price", "Inputed price is invalid!"); } return(validationOutput); }
public override ValidationOutput DTOIsValid(ContinuousValueDto consideredDto) { ValidationOutput validationOutput = new ValidationOutputBadRequest(); if (consideredDto.MinValue <= 0 || consideredDto.MinValue > consideredDto.MaxValue) { validationOutput.AddError("Continuous value", " A continuous value is not valid!"); } return(validationOutput); }
public override ValidationOutput DTOReferenceIsValid(string configuredProductReference) { ValidationOutput validationOutput = new ValidationOutputBadRequest(); if (!ReferenceIsValid(configuredProductReference)) { validationOutput.AddError("Configured product reference", "Configured product reference is invalid!"); } return(validationOutput); }
public override ValidationOutput DTOIsValid(DiscreteValueDto consideredDto) { ValidationOutput validationOutput = new ValidationOutputBadRequest(); if (consideredDto.Value <= 0) { validationOutput.AddError("Discrete value", " A discrete value is not valid!"); } return(validationOutput); }
public override ValidationOutput DTOReferenceIsValid(string finishReference) { ValidationOutput validationOutput = new ValidationOutputBadRequest(); if (!ReferenceIsValid(finishReference)) { validationOutput.AddError("Reference of finish", "The reference '" + finishReference + "' is not valid!"); } return(validationOutput); }
public ValidationOutput DTOReferenceIsValid(string colorCode) { ValidationOutput validationOutput = new ValidationOutputBadRequest(); if (!HexCodeIsValid(colorCode)) { validationOutput.AddError("Hex Code of color", "The hex code '" + colorCode + "' is not valid!"); } return(validationOutput); }
public override ValidationOutput DTOIsValid(PriceHistoryDto consideredDto) { ValidationOutput validationOutput = new ValidationOutputBadRequest(); if (consideredDto.Date < DateTime.Now) { validationOutput.AddError("Price history item", "A price history item has a date that has already passed."); return(validationOutput); } return(validationOutput); }
public override ValidationOutput DTOIsValid(SizePercentagePartAlgorithmDto consideredDto) { ValidationOutput validationOutput = new ValidationOutputBadRequest(); if (consideredDto.Min <= 0 || consideredDto.Max <= 0 || consideredDto.Min > 100 || consideredDto.Max > 100 || consideredDto.Max < consideredDto.Min || (!string.Equals(consideredDto.SizeType, "height", StringComparison.Ordinal) && !string.Equals(consideredDto.SizeType, "depth", StringComparison.Ordinal) && !string.Equals(consideredDto.SizeType, "width", StringComparison.Ordinal))) { validationOutput.AddError("SizePercentagePart's attribute", "SizePercentagePart's attribute not valid!"); } return(validationOutput); }
public override ValidationOutput DTOReferenceIsValid(string materialReference) { ValidationOutput validationOutput = new ValidationOutputBadRequest(); if (!ReferenceIsValid(materialReference)) { validationOutput.AddError("Reference of product", "The reference '" + materialReference + "' is not valid!"); } return(validationOutput); }
/** * Validations performed: * * 1. The received list has 1 or more elements. * FOREACH FINISH RECEIVED { * 2. Validation of each finish's reference (business rules); * 3. Validation of each finish's definition (business rules); * 4. Validation of the existence of each finish received, in the material with the passed reference. * 5. Validation for duplication between received finishes. * } */ private ValidationOutput PrivateAddFinishesWithMaterial(IEnumerable <FinishDto> enumerableFinishDto) { List <FinishDto> listFinishDto = new List <FinishDto>( enumerableFinishDto); //Since we receive an IEnumerable, we need to have something concrete //1. ValidationOutput validationOutput = new ValidationOutputBadRequest(); if (listFinishDto.Count == 0) { validationOutput.AddError("Finishes selected", "No finishes were selected!"); return(validationOutput); } List <FinishDto> finishesToAdd = new List <FinishDto>(); foreach (var currentFinishDto in listFinishDto) { validationOutput = new ValidationOutputBadRequest(); //2. validationOutput = _finishDTOValidator.DTOReferenceIsValid(currentFinishDto.Reference); if (validationOutput.HasErrors()) { return(validationOutput); } //3. validationOutput = _finishDTOValidator.DTOIsValidForRegister(currentFinishDto); if (validationOutput.HasErrors()) { return(validationOutput); } //5. if (finishesToAdd.Contains(currentFinishDto)) { validationOutput.AddError("Finish", "Finish with the reference '" + currentFinishDto.Reference + "' is duplicated in the list of selected finishes."); return(validationOutput); } AddNewPriceToFinishHistory(currentFinishDto); finishesToAdd.Add(currentFinishDto); } return(validationOutput); }
public override ValidationOutput DTOIsValidForRegister(CatalogDto consideredDto) { ValidationOutput validationOutput = new ValidationOutputBadRequest(); if (consideredDto.Name != null) { if (!NameIsValid(consideredDto.Name)) { validationOutput.AddError("Name of catalog", "The name'" + consideredDto.Name + "' is not valid!"); } } if (consideredDto.Description != null) { if (!DescriptionIsValid(consideredDto.Description)) { validationOutput.AddError("Description of catalog", "The description'" + consideredDto.Description + "' is not valid!"); } } return(validationOutput); }
public override ValidationOutput DTOIsValid(SlotDefinitionDto consideredDto) { ValidationOutput validationOutput = new ValidationOutputBadRequest(); if (consideredDto != null && (consideredDto.MinSize <= 0 || consideredDto.MaxSize <= 0 || consideredDto.MaxSize < consideredDto.MinSize || consideredDto.RecSize > consideredDto.MaxSize || consideredDto.RecSize < consideredDto.MinSize)) { validationOutput.AddError("Slot definition", "The slot definition is not valid!"); } return(validationOutput); }