Beispiel #1
0
        private List <StorageValidatorError> ValidateBodyPictures(List <IFormFile> bodyPictures)
        {
            List <StorageValidatorError> errors = new List <StorageValidatorError>();

            if (bodyPictures.Count > 5)
            {
                errors.Add(new StorageValidatorError("Erro ao anexar", "O número máximo de imagens dessa medição foi excedido."));
            }

            foreach (IFormFile bodyPicture in bodyPictures)
            {
                StorageValidatorResult storageValidator = new ImageStorageValidator().Validate(bodyPicture);
                if (!storageValidator.Success)
                {
                    errors.AddRange(storageValidator.Errors);
                }
            }

            return(errors);
        }
Beispiel #2
0
        public async Task <CommandResult> Handle(SetAvatarImageCommand request, CancellationToken cancellationToken)
        {
            StorageValidatorResult storageValidator = new ImageStorageValidator().Validate(request.AvatarImage);

            if (!storageValidator.Success)
            {
                return(FailureDueToFileValidationFailure(storageValidator.Errors.ToList()));
            }

            Profile profile = await _profileRepository.GetByIdAsync(request.ProfileId);

            if (!FoundValidProfile(profile))
            {
                return(FailureDueToProfileNotFound());
            }

            Image image = null;

            using (MemoryStream stream = new MemoryStream())
            {
                string containerName = _containerOptions.Value.ProfileImageContainerName;

                await request.AvatarImage.CopyToAsync(stream);

                StorageResult result = await _storageService.UploadFileToStorageAsync(containerName, stream, Guid.NewGuid().ToString());

                if (!result.Success)
                {
                    return(FailureDueToUploadFailure());
                }

                image = new Image(result.FileUrl, result.FileName);
            }

            profile.SetAvatarImage(image);

            await _profileRepository.UpdateAsync(profile);

            return(await CommitAndPublishDefaultAsync());
        }
        public async Task <CommandResult> Handle(RegisterPostCommand request, CancellationToken cancellationToken)
        {
            Image image = null;

            if (request.AttachedImage != null)
            {
                StorageValidatorResult storageValidator = new ImageStorageValidator().Validate(request.AttachedImage);
                if (!storageValidator.Success)
                {
                    return(FailureDueToFileValidationFailure(storageValidator.Errors.ToList()));
                }

                using (MemoryStream stream = new MemoryStream())
                {
                    string containerName = _containerOptions.Value.PostImageContainerName;

                    await request.AttachedImage.CopyToAsync(stream);

                    StorageResult result = await _storageService.UploadFileToStorageAsync(containerName, stream, Guid.NewGuid().ToString());

                    if (!result.Success)
                    {
                        return(FailureDueToUploadFailure());
                    }

                    image = new Image(result.FileUrl, result.FileName);
                }
            }

            Post post = new Post(
                _currentProfileId,
                request.Title,
                request.Body,
                attachedImage: image
                );

            await _postRepository.RegisterAsync(post);

            return(await CommitAndPublishDefaultAsync());
        }