Example #1
0
        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);
        }
        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);
        }
Example #3
0
        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);
        }
        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(ComponentDto consideredDto)
        {
            ValidationOutput validationOutput = new ValidationOutputBadRequest();

            if (!NameIsValid(consideredDto.Name))
            {
                validationOutput.AddError("Component's name", "Component's name is invalid!");
            }
            var animation = consideredDto.Animation;

            if (animation != null)
            {
                var errors = _animationDTOValidator.DTOIsValid(animation);
                if (errors.HasErrors())
                {
                    validationOutput.Join(errors);
                }
            }
            return(validationOutput);
        }