コード例 #1
0
        public async Task <AddProductValidationResult> Validate(AddProductCommand command, string subject)
        {
            if (command == null)
            {
                throw new ArgumentNullException(nameof(command));
            }

            if (string.IsNullOrWhiteSpace(command.ShopId))
            {
                return(new AddProductValidationResult(string.Format(ErrorDescriptions.TheParameterIsMandatory, Constants.DtoNames.Product.ShopId)));
            }

            if (string.IsNullOrWhiteSpace(command.UnitOfMeasure))
            {
                return(new AddProductValidationResult(string.Format(ErrorDescriptions.TheParameterIsMandatory, Constants.DtoNames.Product.UnitOfMeasure)));
            }

            var shop = await _shopRepository.Get(command.ShopId);

            if (shop == null)
            {
                return(new AddProductValidationResult(ErrorDescriptions.TheShopDoesntExist));
            }

            if (shop.Subject != subject)
            {
                return(new AddProductValidationResult(ErrorDescriptions.TheProductCannotBeAddedByYou));
            }

            if (!IsValid(command.Name, 1, 50))
            {
                return(new AddProductValidationResult(string.Format(ErrorDescriptions.TheParameterIsMandatoryAndShouldContainsBetween, Constants.DtoNames.Product.Name, 1, 15)));
            }

            if (!IsValid(command.Description, 1, 255))
            {
                return(new AddProductValidationResult(string.Format(ErrorDescriptions.TheParameterIsMandatoryAndShouldContainsBetween, Constants.DtoNames.Product.Description, 1, 255)));
            }

            if (command.Price < 0)
            {
                return(new AddProductValidationResult(ErrorDescriptions.ThePriceCannotBeLessThanZero));
            }

            if (command.Quantity < 0)
            {
                return(new AddProductValidationResult(ErrorDescriptions.TheQuantityCannotBeLessThanZero));
            }

            if (command.AvailableInStock != null && command.AvailableInStock < 0)
            {
                return(new AddProductValidationResult(ErrorDescriptions.TheAvailableInStockCannotBeLessThanZero));
            }

            var unitOfMeasure = _unitOfMeasures.FirstOrDefault(u => command.UnitOfMeasure.ToLowerInvariant().Equals(u, StringComparison.CurrentCultureIgnoreCase));

            if (string.IsNullOrWhiteSpace(unitOfMeasure))
            {
                return(new AddProductValidationResult(string.Format(ErrorDescriptions.TheUnitOfMeasureIsNotCorrect, string.Join(",", _unitOfMeasures))));
            }

            if (command.Filters != null && command.Filters.Any())
            {
                var filterValuesIds = command.Filters.Select(f => f.ValueId);
                var filters         = await _filterRepository.Search(new SearchFilterValuesParameter
                {
                    FilterValueIds = filterValuesIds
                });

                if (filters.Filters.Count() != filterValuesIds.Count())
                {
                    return(new AddProductValidationResult(ErrorDescriptions.SomeFiltersAreNotValid));
                }
            }

            return(new AddProductValidationResult());
        }
コード例 #2
0
        public async Task <UpdateProductValidationResult> Validate(UpdateProductCommand command, string subject)
        {
            if (command == null)
            {
                throw new ArgumentNullException(nameof(command));
            }

            if (string.IsNullOrWhiteSpace(subject))
            {
                throw new ArgumentNullException(nameof(subject));
            }

            var record = await _productRepository.Get(command.Id);

            var shop = await _shopRepository.Get(record.ShopId);

            if (record == null)
            {
                return(new UpdateProductValidationResult(ErrorDescriptions.TheProductDoesntExist));
            }

            if (shop == null)
            {
                return(new UpdateProductValidationResult(ErrorDescriptions.TheShopDoesntExist));
            }

            if (shop.Subject != subject)
            {
                return(new UpdateProductValidationResult(ErrorDescriptions.TheProductCannotBeUpdatedByYou));
            }

            if (!IsValid(command.Name, 1, 50))
            {
                return(new UpdateProductValidationResult(string.Format(ErrorDescriptions.TheParameterIsMandatoryAndShouldContainsBetween, Constants.DtoNames.Product.Name, 1, 15)));
            }

            if (!IsValid(command.Description, 1, 255))
            {
                return(new UpdateProductValidationResult(string.Format(ErrorDescriptions.TheParameterIsMandatoryAndShouldContainsBetween, Constants.DtoNames.Product.Description, 1, 255)));
            }

            if (command.Price < 0)
            {
                return(new UpdateProductValidationResult(ErrorDescriptions.ThePriceCannotBeLessThanZero));
            }

            if (command.Quantity < 0)
            {
                return(new UpdateProductValidationResult(ErrorDescriptions.TheQuantityCannotBeLessThanZero));
            }

            if (command.AvailableInStock != null && command.AvailableInStock < 0)
            {
                return(new UpdateProductValidationResult(ErrorDescriptions.TheAvailableInStockCannotBeLessThanZero));
            }

            if (command.PartialImagesUrl != null)
            {
                foreach (var image in command.PartialImagesUrl)
                {
                    Uri uri;
                    if (Uri.TryCreate(image, UriKind.Absolute, out uri) && (uri.Scheme == "http" || uri.Scheme == "https"))
                    {
                        continue;
                    }

                    try
                    {
                        var base64Encoded = image;
                        base64Encoded = base64Encoded.Substring(image.IndexOf(',') + 1);
                        base64Encoded = base64Encoded.Trim('\0');
                        Convert.FromBase64String(base64Encoded);
                    }
                    catch
                    {
                        return(new UpdateProductValidationResult(ErrorDescriptions.TheProductImageCanBeUrlOrBase64Encoded));
                    }
                }
            }

            var unitOfMeasure = _unitOfMeasures.FirstOrDefault(u => command.UnitOfMeasure.ToLowerInvariant().Equals(u, StringComparison.CurrentCultureIgnoreCase));

            if (string.IsNullOrWhiteSpace(unitOfMeasure))
            {
                return(new UpdateProductValidationResult(string.Format(ErrorDescriptions.TheUnitOfMeasureIsNotCorrect, string.Join(",", _unitOfMeasures))));
            }

            if (command.Filters != null && command.Filters.Any())
            {
                var filterValuesIds = command.Filters.Select(f => f.ValueId);
                var filters         = await _filterRepository.Search(new SearchFilterValuesParameter
                {
                    FilterValueIds = filterValuesIds
                });

                if (filters.Filters.Count() != filterValuesIds.Count())
                {
                    return(new UpdateProductValidationResult(ErrorDescriptions.SomeFiltersAreNotValid));
                }
            }

            return(new UpdateProductValidationResult());
        }