public async Task <ImageInputModel> SaveImageAsync(IFormFile formFile)
        {
            var isValid = new ImageAttribute().IsValid(formFile);

            if (formFile == null || !isValid)
            {
                return(null);
            }

            var guid      = Guid.NewGuid().ToString();
            var extension = await Image.DetectFormatAsync(formFile.OpenReadStream());

            var source   = $"/img/{guid}.{extension.Name}";
            var filePath = $"{this.environment.ContentRootPath}/wwwroot{source}";

            using var stream = new FileStream(filePath, FileMode.Create);
            await formFile.CopyToAsync(stream);

            var imageInputModel = new ImageInputModel
            {
                Source = source,
            };

            return(imageInputModel);
        }
Пример #2
0
        public async Task CreatePageHeaderAsyncShouldAddNewPageHeaderAndReturnExpectedId()
        {
            // Arrange
            var expectedId = 8;

            byte[] img = await File.ReadAllBytesAsync($@"C:\Users\nikolaviktor3132\Pictures\test.png");

            var imgInputModel = new ImageInputModel {
                CloudUrl = "sdfsdfsdf", ContentType = "sadasd", CreatedOn = DateTime.Now, ImageByte = img, ImageTitle = "weqeqweq", ImagePath = "dsfsdfsdfs"
            };

            var pageHeaderInputModel = new PageHeaderInputModel
            {
                Image     = imgInputModel,
                SubTitle  = "dfdfd",
                MainTitle = "dsds",
            };

            // Act
            var actualPageHeader = this.pageHeadersRepository.AllWithDeleted().FirstOrDefault(ph => ph.Id == expectedId);

            Assert.True(actualPageHeader == null);
            await this.pageHeaderService.CreatePageHeaderAsync(pageHeaderInputModel);

            actualPageHeader = this.pageHeadersRepository.AllWithDeleted().FirstOrDefault(ph => ph.Id == expectedId);

            // Assert
            Assert.True(actualPageHeader != null);
        }
Пример #3
0
        public async Task <ImageInputModel> SaveImageAsync(IFormFile formFile)
        {
            var isValid = new ImageAttribute().IsValid(formFile);

            if (formFile == null || !isValid)
            {
                return(null);
            }

            var guid      = Guid.NewGuid().ToString();
            var extension = await Image.DetectFormatAsync(formFile.OpenReadStream());

            var fileName   = $"{guid}.{extension.Name}";
            var cloudinary = new Cloudinary(this.account);

            var uploadParams = new ImageUploadParams()
            {
                File = new FileDescription(fileName, formFile.OpenReadStream()),
            };

            var uploadResult = await cloudinary.UploadAsync(uploadParams);

            var imageInput = new ImageInputModel()
            {
                Source = uploadResult.SecureUrl.AbsoluteUri,
            };

            return(imageInput);
        }
        public async Task TestDeleteImageAsync()
        {
            var projectInputModel = new ProjectInputModel
            {
                Name        = "test",
                Description = "Lorem",
                HeadImage   = this.file,
            };

            var projectId = await this.projectsService.CreateProjectAsync(projectInputModel);

            var imageInputModel = new ImageInputModel
            {
                ProjectId   = projectId,
                Description = "Lorem",
                ImageFile   = this.file,
            };

            var id = await this.projectsGalleryService.AddImageToGalleryAsync(imageInputModel);

            await this.projectsGalleryService.DeleteImageAsync(id);

            var currentGallery = await this.projectsGalleryService.GetGalleryAsync(projectId);

            Assert.Equal(0, currentGallery.Count);
        }
        public async Task AddAsyncAddsTheEntityToTheRepository(
            string boulderName,
            string boulderDescription,
            string gradeId,
            string gymId,
            string imageSource,
            string authorId)
        {
            AutoMapperConfig.RegisterMappings(typeof(Test).Assembly, typeof(ErrorViewModel).Assembly);

            var repositoryMock = new Mock <IDeletableEntityRepository <Boulder> >();
            var testData       = new List <Boulder>();

            var boulderInput = new BoulderInputModel()
            {
                Name        = boulderName,
                Description = boulderDescription,
                GradeId     = gradeId,
                GymId       = gymId,
            };

            var imageInput = new ImageInputModel()
            {
                Source = imageSource,
            };

            var saved = false;

            repositoryMock.Setup(x => x.AddAsync(It.IsAny <Boulder>()))
            .Callback((Boulder boulder) =>
            {
                testData.Add(boulder);
            });

            repositoryMock.Setup(x => x.SaveChangesAsync())
            .Callback(() =>
            {
                saved = true;
            });

            var bouldersService = new BouldersService(repositoryMock.Object, AutoMapperConfig.MapperInstance);

            // Act
            await bouldersService.AddAsync(boulderInput, authorId, imageInput);

            // Assert
            var boulder = testData[0];

            Assert.True(saved);
            Assert.Equal(authorId, boulder.AuthorId);
            Assert.Equal(boulderName, boulder.Name);
            Assert.Equal(boulderDescription, boulder.Description);
            Assert.Equal(gradeId, boulder.GradeId);
            Assert.Equal(gymId, boulder.GymId);
            Assert.Equal(imageInput.Source, boulder.Image.Source);
        }
        public async Task <IActionResult> Create(ImageInputModel input)
        {
            if (!this.ModelState.IsValid)
            {
                return(this.View(input));
            }

            await this.imagesService.AddAsync(input);

            return(this.RedirectToAction(nameof(this.AllPerSchool)));
        }
Пример #7
0
        public async Task AddAsync(CityInputModel cityInput, ImageInputModel imageInput)
        {
            this.NullCheck(cityInput, nameof(cityInput));

            var city = this.mapper.Map <City>(cityInput);

            city.Image = this.mapper.Map <Image>(imageInput);

            await this.citiesRepository.AddAsync(city);

            await this.citiesRepository.SaveChangesAsync();
        }
Пример #8
0
        public async Task AddAsync(CategoryInputModel categoryInput, ImageInputModel imageInput)
        {
            this.NullCheck(categoryInput, nameof(categoryInput));

            var category = this.mapper.Map <Category>(categoryInput);

            category.Image = this.mapper.Map <Image>(imageInput);

            await this.categoriesRepository.AddAsync(category);

            await this.categoriesRepository.SaveChangesAsync();
        }
Пример #9
0
        public async Task <IActionResult> AddImage(ImageInputModel input)
        {
            if (!this.ModelState.IsValid || input.ImageFile == null)
            {
                this.ViewData["id"] = input.ProjectId;
                return(this.View());
            }

            await this.projectsGalleryService.AddImageToGalleryAsync(input);

            return(this.RedirectToAction("Gallery", new { id = input.ProjectId }));
        }
Пример #10
0
        public async Task AddAsync(GymInputModel gymInput, ImageInputModel imageInput)
        {
            this.NullCheck(gymInput, nameof(gymInput));

            var country = this.mapper.Map <Gym>(gymInput);

            country.Image = this.mapper.Map <Image>(imageInput);

            await this.gymsRepository.AddAsync(country);

            await this.gymsRepository.SaveChangesAsync();
        }
        public IActionResult Create()
        {
            var viewModel        = new ImageInputModel();
            var userName         = this.User.Identity.Name;
            var currentPrincipal = this.dbContext.Principals
                                   .FirstOrDefault(x => x.User.UserName == userName);
            var schoolId = currentPrincipal.NurserySchoolId;

            viewModel.GroupsItems = this.groupsService.GetAllAsKeyValuePairsPerSchool(schoolId);

            return(this.View(viewModel));
        }
Пример #12
0
        public async Task AddAsync(PostInputModel postInput, ImageInputModel imageInput, string userId)
        {
            this.NullCheck(postInput, nameof(postInput));
            this.NullCheck(userId, nameof(userId));

            var post = this.mapper.Map <Post>(postInput);

            post.Image = this.mapper.Map <Image>(imageInput);

            post.ApplicationUserId = userId;

            await this.postsRepository.AddAsync(post);

            await this.postsRepository.SaveChangesAsync();
        }
Пример #13
0
        public async Task AddAsync(BoulderInputModel boulderInput, string authorId, ImageInputModel imageInput)
        {
            this.NullCheck(boulderInput, nameof(boulderInput));
            this.NullCheck(authorId, nameof(authorId));
            this.NullCheck(imageInput, nameof(imageInput));

            var image   = this.mapper.Map <Image>(imageInput);
            var boulder = this.mapper.Map <Boulder>(boulderInput);

            boulder.AuthorId = authorId;
            boulder.Image    = image;

            await this.bouldersRepository.AddAsync(boulder);

            await this.bouldersRepository.SaveChangesAsync();
        }
Пример #14
0
        public async Task AddUserImageAsyncShouldAddImageToUser()
        {
            // Arrange
            byte[] img = await File.ReadAllBytesAsync($@"C:\Users\nikolaviktor3132\Pictures\test.png");

            var imgInputModel = new ImageInputModel {
                CloudUrl = "sdfsdfsdf", ContentType = "sadasd", CreatedOn = DateTime.Now, ImageByte = img, ImageTitle = "weqeqweq", ImagePath = "dsfsdfsdfs"
            };

            // Act
            var result = await this.userService.AddUserImageAsync(imgInputModel, "*****@*****.**");

            var actualUser = this.usersRepository.All().SingleOrDefault(u => u.UserName == "*****@*****.**");

            // Assert
            Assert.True(actualUser.Image != null);
        }
Пример #15
0
        public Models.PredictionDto GetPrediction(byte[] bytes)
        {
            var imageData = new ImageInputModel()
            {
                Image = bytes
            };
            var predictionEngine = _predictionEnginePool.GetPredictionEngine();
            var prediction       = predictionEngine.Predict(imageData);
            var scores           = GetSortedLabelValues(predictionEngine.OutputSchema, "Score", prediction.Score);
            var result           = new Models.PredictionDto
            {
                CategoryScores = scores,
                PredictedLabel = prediction.PredictedLabel,
            };

            return(result);
        }
        public async Task AddAsync(ImageInputModel input)
        {
            var groupId = this.groupsRepository.AllAsNoTracking()
                          .Where(x => x.Id == int.Parse(input.Group))
                          .Select(x => x.Id)
                          .FirstOrDefault();

            var image = new Image
            {
                Url            = input.Url,
                Extension      = input.Extension,
                NurseryGroupId = groupId,
            };

            await this.imagesRepository.AddAsync(image);

            await this.imagesRepository.SaveChangesAsync();
        }
Пример #17
0
        public async Task <IActionResult> UploadPost([FromForm] ImageInputModel image)
        {
            var user = this.GetUserId();

            var uploadResult = await mediator.Send(new UploadPostCommand(image.File, image.Description, user));

            if (uploadResult.success)
            {
                return(Ok(new UploadResultModel()
                {
                    ImageId = uploadResult.id, IsSuccess = true
                }));
            }

            return(BadRequest(new UploadResultModel()
            {
                IsSuccess = false, ErrorCode = uploadResult.errorCode
            }));
        }
Пример #18
0
        public string UploudPicture(ImageInputModel image, string folderName)
        {
            UploadResult uploadResult;

            using (var ms = new MemoryStream(image.ImageByte))
            {
                ImageUploadParams uploadParams = new ImageUploadParams
                {
                    Folder     = folderName,
                    File       = new FileDescription(image.ImageTitle, ms),
                    PublicId   = Guid.NewGuid().ToString(),
                    Invalidate = true,
                };

                uploadResult = this.cloudinaryUtility.Upload(uploadParams);
            }

            return(uploadResult?.SecureUri.AbsoluteUri);
        }
Пример #19
0
        public async Task EditAsync(string id, CategoryInputModel categoryInput, ImageInputModel imageInput)
        {
            this.NullCheck(id, nameof(id));
            this.NullCheck(categoryInput, nameof(categoryInput));

            var category = this.categoriesRepository
                           .All()
                           .FirstOrDefault(x => x.Id == id);

            if (imageInput != null)
            {
                category.Image = this.mapper.Map <Image>(imageInput);
            }

            category.Name        = categoryInput.Name;
            category.Description = categoryInput.Description;

            await this.categoriesRepository.SaveChangesAsync();
        }
Пример #20
0
        public async Task EditAsync(string id, PostInputModel postInput, ImageInputModel imageInput)
        {
            this.NullCheck(id, nameof(id));
            this.NullCheck(postInput, nameof(postInput));

            var post = this.postsRepository
                       .All()
                       .FirstOrDefault(x => x.Id == id);

            if (imageInput != null)
            {
                post.Image = this.mapper.Map <Image>(imageInput);
            }

            post.Title      = postInput.Title;
            post.Text       = postInput.Text;
            post.CategoryId = postInput.CategoryId;

            await this.postsRepository.SaveChangesAsync();
        }
Пример #21
0
        public async Task <bool> AddUserImageAsync(ImageInputModel imageInputModel, string username)
        {
            var currentUser = await this.users.All().SingleOrDefaultAsync(u => u.UserName == username);

            var cloudUrl = this.cloudinaryService.UploudPicture(imageInputModel, GlobalConstants.UsersFolderName);

            var imgForDb = new Image
            {
                ContentType = imageInputModel.ContentType,
                ImagePath   = imageInputModel.ImagePath,
                ImageTitle  = imageInputModel.ImageTitle,
                CloudUrl    = cloudUrl,
            };

            currentUser.Image = imgForDb;

            int addedImgs = await this.users.SaveChangesAsync();

            return(addedImgs == 1);
        }
Пример #22
0
        public async Task EditAsync(string id, GymInputModel gymInput, ImageInputModel imageInput)
        {
            this.NullCheck(id, nameof(id));
            this.NullCheck(gymInput, nameof(gymInput));

            var gym = this.gymsRepository
                      .All()
                      .FirstOrDefault(x => x.Id == id);

            if (imageInput != null)
            {
                gym.Image = this.mapper.Map <Image>(imageInput);
            }

            gym.Name        = gymInput.Name;
            gym.Description = gymInput.Description;
            gym.CityId      = gymInput.CityId;

            await this.gymsRepository.SaveChangesAsync();
        }
        public async Task <int> AddImageToGalleryAsync(ImageInputModel input)
        {
            var currentProject = await this.projectsService.GetProjectByIdAsync(input.ProjectId);

            var projectName = currentProject.Name;

            var imageId = await this.filesService.UploadToFileSystemAsync(input.ImageFile, "images\\projectImages\\" + projectName, "ImageTo" + projectName + "Gallery");

            var newImageToProject = new GalleryProject
            {
                FileId      = imageId,
                Description = input.Description,
                ProjectId   = input.ProjectId,
            };

            await this.dbImageToProject.AddAsync(newImageToProject);

            await this.dbImageToProject.SaveChangesAsync();

            return(newImageToProject.Id);
        }
Пример #24
0
        public async Task EditAsync(string id, BoulderInputModel boulderInput, ImageInputModel imageInput)
        {
            this.NullCheck(id, nameof(id));
            this.NullCheck(boulderInput, nameof(boulderInput));

            var boulder = this.bouldersRepository
                          .All()
                          .FirstOrDefault(x => x.Id == id);

            if (imageInput != null)
            {
                boulder.Image = this.mapper.Map <Image>(imageInput);
            }

            boulder.Name        = boulderInput.Name;
            boulder.Description = boulderInput.Description;
            boulder.GradeId     = boulderInput.GradeId;
            boulder.GymId       = boulderInput.GymId;

            await this.bouldersRepository.SaveChangesAsync();
        }
        public async Task <IActionResult> MyPatients(ImageInputModel photo)
        {
            if (!this.ModelState.IsValid)
            {
                return(this.View());
            }

            var photoName = Guid.NewGuid().ToString();
            var photoUrl  = await this.cloudinaryService.UploadImageAsync(photo.Image, photoName);

            var user = await this.userManager.GetUserAsync(this.HttpContext.User);

            var donorPatient = await this.donorsPatientsService.GetDonorsPatientsByDonorsUserIdAsync(user.Id);

            donorPatient.Patient.NeededBloodBanks--;
            donorPatient.ImageId = photoUrl.PublicId;

            await this.donorsPatientsService.AddImageAsync(donorPatient, photoUrl?.SecureUri.AbsoluteUri);

            return(this.Redirect("/"));
        }
        public async Task TestAddImageToGallery()
        {
            var projectInputModel = new ProjectInputModel
            {
                Name        = "test",
                Description = "Lorem",
                HeadImage   = this.file,
            };

            var projectId = await this.projectsService.CreateProjectAsync(projectInputModel);

            var imageInputModel = new ImageInputModel
            {
                ProjectId   = projectId,
                Description = "Lorem",
                ImageFile   = this.file,
            };

            var id = await this.projectsGalleryService.AddImageToGalleryAsync(imageInputModel);

            Assert.NotEqual(0, id);
        }
        public async Task EditAsyncEditsThePorpertiesAndSavesTheChanges(
            string name,
            string description,
            string gradeId,
            string gymId,
            string newName,
            string newDescription,
            string newGradeId,
            string newGymId,
            bool imageNull,
            string imageSource,
            string newImageSource)
        {
            // Arrange
            AutoMapperConfig.RegisterMappings(typeof(Test).Assembly, typeof(ErrorViewModel).Assembly);
            var saved = true;

            var boulder = new Boulder()
            {
                Name        = name,
                Description = description,
                GradeId     = gradeId,
                GymId       = gymId,
                Image       = new Image()
                {
                    Source = imageSource,
                },
            };

            var bouldersList = new List <Boulder>()
            {
                new Boulder(),
                new Boulder(),
                new Boulder(),
                boulder,
                new Boulder(),
                new Boulder(),
            };

            var repositoryMock = new Mock <IDeletableEntityRepository <Boulder> >();

            repositoryMock.Setup(x => x.All())
            .Returns(bouldersList.AsQueryable());

            repositoryMock.Setup(x => x.SaveChangesAsync())
            .Callback(() =>
            {
                saved = true;
            });

            var boulderEditModel = new BoulderInputModel()
            {
                Name        = newName,
                Description = newDescription,
                GymId       = newGymId,
                GradeId     = newGradeId,
            };

            var imageEditModel = new ImageInputModel()
            {
                Source = newImageSource,
            };

            if (imageNull)
            {
                imageEditModel = null;
            }

            var bouldersService = new BouldersService(repositoryMock.Object, AutoMapperConfig.MapperInstance);

            // Act
            await bouldersService.EditAsync(boulder.Id, boulderEditModel, imageEditModel);

            // Assert
            Assert.True(saved);

            Assert.Equal(newName, boulder.Name);
            Assert.Equal(newDescription, boulder.Description);
            Assert.Equal(newGradeId, boulder.GradeId);
            Assert.Equal(newGymId, boulder.GymId);

            var actualImage = boulder.Image;

            if (imageNull)
            {
                Assert.Equal(imageSource, actualImage.Source);
            }
            else
            {
                Assert.Equal(newImageSource, actualImage.Source);
            }
        }
Пример #28
0
        public async Task AddMapsTheInputModelsSetsUserIdAndAddsToTheRepository(
            string categoryId,
            string text,
            string title,
            bool nullImage,
            string imageSource,
            string userId)
        {
            // Arrange
            AutoMapperConfig.RegisterMappings(typeof(Test).Assembly, typeof(ErrorViewModel).Assembly);

            var saved = false;

            var postsList      = new List <Post>();
            var repositoryMock = new Mock <IDeletableEntityRepository <Post> >();

            repositoryMock.Setup(x => x.AddAsync(It.IsAny <Post>()))
            .Callback((Post post) =>
            {
                postsList.Add(post);
            });

            repositoryMock.Setup(x => x.SaveChangesAsync())
            .Callback(() =>
            {
                saved = true;
            });

            var postsService = new PostsService(repositoryMock.Object, AutoMapperConfig.MapperInstance);

            var postInputModel = new PostInputModel()
            {
                CategoryId = categoryId,
                Text       = text,
                Title      = title,
            };

            var imageInputModel = new ImageInputModel()
            {
                Source = imageSource,
            };

            if (nullImage)
            {
                imageInputModel = null;
            }

            // Act
            await postsService.AddAsync(postInputModel, imageInputModel, userId);

            // Assert
            var actualPost = postsList[0];

            Assert.True(saved);
            Assert.Equal(categoryId, actualPost.CategoryId);
            Assert.Equal(text, actualPost.Text);
            Assert.Equal(title, actualPost.Title);
            Assert.Equal(userId, actualPost.ApplicationUserId);

            var actualImage = actualPost.Image;

            if (nullImage)
            {
                Assert.Null(actualImage);
            }
            else
            {
                Assert.Equal(imageSource, actualImage.Source);
            }
        }
Пример #29
0
        public async Task EditAsyncEditsThePropertiesAndSavesTheChanges(
            string userId,
            string title,
            string text,
            string categoryId,
            string newTitle,
            string newText,
            string newCategoryId,
            bool imageNull,
            string imageSource,
            string newImageSource)
        {
            // Arrange
            AutoMapperConfig.RegisterMappings(typeof(Test).Assembly, typeof(ErrorViewModel).Assembly);
            var saved = false;

            var post = new Post()
            {
                ApplicationUserId = userId,
                Title             = title,
                Text       = text,
                CategoryId = categoryId,
                Image      = new Image()
                {
                    Source = imageSource,
                }
            };

            var postsList = new List <Post>()
            {
                new Post(),
                post,
                new Post(),
                new Post(),
                new Post(),
            };

            var repositoryMock = new Mock <IDeletableEntityRepository <Post> >();

            repositoryMock.Setup(x => x.All())
            .Returns(postsList.AsQueryable());

            repositoryMock.Setup(x => x.SaveChangesAsync())
            .Callback(() =>
            {
                saved = true;
            });

            var postsService = new PostsService(repositoryMock.Object, AutoMapperConfig.MapperInstance);

            var postEditModel = new PostInputModel()
            {
                Title      = newTitle,
                Text       = newText,
                CategoryId = newCategoryId,
            };

            var imageEditModel = new ImageInputModel()
            {
                Source = newImageSource,
            };

            if (imageNull)
            {
                imageEditModel = null;
            }

            // Act
            await postsService.EditAsync(post.Id, postEditModel, imageEditModel);

            // Assert
            Assert.True(saved);
            Assert.Equal(userId, post.ApplicationUserId);

            Assert.Equal(newTitle, post.Title);
            Assert.Equal(newText, post.Text);
            Assert.Equal(newCategoryId, post.CategoryId);

            var actualImage = post.Image;

            if (imageNull)
            {
                Assert.Equal(imageSource, actualImage.Source);
            }
            else
            {
                Assert.Equal(newImageSource, actualImage.Source);
            }
        }
Пример #30
0
        public async Task AddAsyncMapsTheInputModelAndAddsItToTheRepository(
            string name,
            string description,
            bool nullImage,
            string imageSource)
        {
            // Arrange
            AutoMapperConfig.RegisterMappings(typeof(Test).Assembly, typeof(ErrorViewModel).Assembly);

            var saved          = false;
            var categoriesList = new List <Category>();
            var repositoryMock = new Mock <IDeletableEntityRepository <Category> >();

            repositoryMock.Setup(x => x.AddAsync(It.IsAny <Category>()))
            .Callback((Category category) =>
            {
                categoriesList.Add(category);
            });

            repositoryMock.Setup(x => x.SaveChangesAsync())
            .Callback(() =>
            {
                saved = true;
            });

            var categoriesService = new CategoriesService(repositoryMock.Object, AutoMapperConfig.MapperInstance);

            var categoryInput = new CategoryInputModel()
            {
                Name        = name,
                Description = description,
            };

            var imageInput = new ImageInputModel()
            {
                Source = imageSource,
            };

            if (nullImage)
            {
                imageInput = null;
            }

            // Act
            await categoriesService.AddAsync(categoryInput, imageInput);

            // Assert
            var actualCategory = categoriesList[0];

            Assert.True(saved);
            Assert.Equal(name, actualCategory.Name);
            Assert.Equal(description, actualCategory.Description);

            var actualImage = actualCategory.Image;

            if (nullImage)
            {
                Assert.Null(actualCategory.Image);
            }
            else
            {
                Assert.Equal(imageSource, actualImage.Source);
            }
        }