public void CallAddNewImage_WhenParamsAreValid()
{
// Arrange
var galleryServiceMock = new Mock <IGalleryImageService>();
var userServiceMock = new Mock <IUserService>();
var mappingServiceMock = new Mock <IMappingService>();
var utilsMock = new Mock <IUtilitiesService>();
var controller = new GalleryController(galleryServiceMock.Object, mappingServiceMock.Object, userServiceMock.Object, utilsMock.Object);
var controllerContext = new Mock <ControllerContext>();
var user = new Mock <IPrincipal>();
user.Setup(p => p.IsInRole("admin")).Returns(true);
user.SetupGet(x => x.Identity.Name).Returns("username");
controllerContext.SetupGet(x => x.HttpContext.User).Returns(user.Object);
controller.ControllerContext = controllerContext.Object;
var model = new CreateImageViewModel();
// Act
controller.Create(model);
// Assert
galleryServiceMock.Verify(x => x.AddNewImage(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()), Times.Once);
}
public ImageViewModel CreateImage(CreateImageViewModel model)
{
var page = _context.Pages.Find(model.PageId);
if (page == null)
{
return(null);
}
var image = new Image(model.Image)
{
ContentId = page.ContentId
};
_context.Images.Add(image);
_context.SaveChanges();
var response = new ImageViewModel
{
Base64 = image.Base64,
Id = image.Id
};
return(response);
}
public async Task <IActionResult> Create(CreateImageViewModel image)
{
if (this.ModelState.IsValid)
{
var user = await this.userManager.GetUserAsync(this.User);
List <string> lstImageTag = JsonSerializer.Deserialize <List <string> >(image.ImageTags);
string newId = await this.imagesService.CreateAsync(
new CreateImageModelData()
{
Id = image.ImageId,
Title = image.Title,
Description = image.Description,
CategoryId = image.CategoryId,
ImageUrl = image.ImageUrl,
AuthorId = user.Id,
Tags = lstImageTag,
});
if (string.IsNullOrEmpty(newId))
{
image.Categories = this.categoriesService.GetAll <CategoryDropDownViewModel>();
return(this.View(image));
}
else
{
return(this.RedirectToAction(nameof(this.Index)));
}
}
image.Categories = this.categoriesService.GetAll <CategoryDropDownViewModel>();
return(this.View(image));
}
public async Task <ActionResult> Create(CreateImageViewModel vm)
{
var api = CreateTrainingApi();
if (vm.ImageFiles == null || !vm.ImageFiles.Any())
{
ModelState.AddModelError("ImageFiles", "Please select one or more image files.");
}
if (ModelState.IsValid)
{
var selectedTag = await api.GetTagAsync(ProjectId, vm.TagId);
var imageFiles = vm.ImageFiles
?.Select(x => new ImageFileCreateEntry(x.FileName, GetPostedFileBytes(x)))
.ToList();
await api.CreateImagesFromFilesAsync(ProjectId,
new ImageFileCreateBatch(imageFiles, new List <Guid> {
selectedTag.Id
}));
TempData["Message"] = $"Image added with tag {selectedTag.Name}";
return(RedirectToAction("Index", new { selectedTag = selectedTag.Id }));
}
vm.Tags = await GetTagSelectList(api);
return(View(vm));
}
// GET: Images/Create
public IActionResult Create()
{
CreateImageViewModel model = new CreateImageViewModel
{
Categories = this.categoriesService.GetAll <CategoryDropDownViewModel>(),
};
return(this.View(model));
}
public async Task <ActionResult> Create()
{
var vm = new CreateImageViewModel();
var api = CreateTrainingApi();
vm.Tags = await GetTagSelectList(api);
return(View(vm));
}
public IActionResult UploadImage(CreateImageViewModel model)
{
var response = _pageService.CreateImage(model);
if (response == null)
{
return(BadRequest());
}
return(Ok(response));
}
private void SaveFile(CreateImageViewModel image)
{
var fileName = image.HttpPostedFileBase.FileName.Split('\\').Last();
image.Url = UploadFolder + fileName;
image.MIME = image.HttpPostedFileBase.ContentType;
var filePath = Server.MapPath(image.Url);
using (var fileStream = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
image.HttpPostedFileBase.InputStream.CopyTo(fileStream);
}
}
public ActionResult Create(CreateImageViewModel model)
{
if (!this.ModelState.IsValid)
{
return(this.View(model));
}
var userId = this.User.Identity.GetUserId();
this.galleryService.AddNewImage(userId, model.Title, model.ImageUrl);
return(this.RedirectToAction("Index"));
}
public async Task <ActionResult> Create([FromForm] CreateImageViewModel imageViewModel)
{
if (imageViewModel.Files.Length > 0 && imageViewModel.Files.FileName.Length > 0)
{
try
{
if (!Directory.Exists(_environment.WebRootPath + "uploads/"))
{
Directory.CreateDirectory(_environment.WebRootPath + "uploads/");
}
using (var reader = new BinaryReader(imageViewModel.Files.OpenReadStream()))
{
var signatures = _fileSignature[Path.GetExtension(imageViewModel.Files.FileName).ToLowerInvariant()];
var headerBytes = reader.ReadBytes(signatures.Max(m => m.Length));
validFile = signatures.Any(signature =>
headerBytes.Take(signature.Length).SequenceEqual(signature));
}
if (validFile)
{
if (!System.IO.File.Exists(_environment.WebRootPath + "uploads/" + imageViewModel.Files.FileName))
{
using (FileStream filestream = System.IO.File.Create(_environment.WebRootPath + "uploads/" + imageViewModel.Files.FileName))
{
await imageViewModel.Files.CopyToAsync(filestream);
var image = new Image(Guid.NewGuid(), imageViewModel.Files.FileName, imageViewModel.ResponseCode, DateTime.Now, _environment.WebRootPath + "uploads/" + imageViewModel.Files.FileName);
filestream.Flush();
await _imageRepository.CreateImage(image);
return(Ok());
}
}
return(Redirect("https://localhost:5001/api/response/302"));
}
return(BadRequest());
}
//TODO: Implement authentication schema
catch (KeyNotFoundException)
{
return(BadRequest());
}
}
return(Ok());
}
// GET: Images/Create
public ActionResult Create()
{
var suspects = db.Suspects.Select(s => new SelectListItem()
{
Text = s.Name,
Value = s.Id.ToString()
}).ToList();
var createViewModel = new CreateImageViewModel
{
Suspects = suspects,
};
// ViewBag.Id = new SelectList(db.Suspects, "Id", "Name");
return(View(createViewModel));
}
public ActionResult Create(CreateImageViewModel image)
{
if (ModelState.IsValid)
{
SaveFile(image);
var imageToSave = new Image()
{
MIME = image.MIME, Id = image.Id, Title = image.Title, Url = image.Url
};
db.Images.Add(imageToSave);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(image));
}
public void ReturnDefaultViewWithViewModel_WhenModelStateIsInvalid()
{
// Arrange
var galleryServiceMock = new Mock <IGalleryImageService>();
var userServiceMock = new Mock <IUserService>();
var mappingServiceMock = new Mock <IMappingService>();
var utilsMock = new Mock <IUtilitiesService>();
var controller = new GalleryController(galleryServiceMock.Object, mappingServiceMock.Object, userServiceMock.Object, utilsMock.Object);
controller.ViewData.ModelState.AddModelError("asdasd", "asdklaskd");
var model = new CreateImageViewModel();
// Act & Assert
controller.WithCallTo(x => x.Create(model))
.ShouldRenderDefaultView()
.WithModel <CreateImageViewModel>(x => x == model);
}
public async Task <IActionResult> Create([Bind("Image")] CreateImageViewModel viewModel, IFormFile file)
{
if (file.Length > 0 && ModelState.IsValid)
{
var filePath = Path.Combine(IMAGE_FOLDER, file.FileName);
using (var fileStream = new FileStream(Path.Combine(this.environment.WebRootPath, filePath), FileMode.Create)) {
await file.CopyToAsync(fileStream);
}
var image = viewModel.Image;
image.FilePath = filePath;
this.imageRepository.Add(image);
return(RedirectToAction("List"));
}
else
{
return(View());
}
}
public void RedirectToIndexAction_WhenParamsAreValid()
{
// Arrange
var galleryServiceMock = new Mock <IGalleryImageService>();
var userServiceMock = new Mock <IUserService>();
var mappingServiceMock = new Mock <IMappingService>();
var utilsMock = new Mock <IUtilitiesService>();
var controller = new GalleryController(galleryServiceMock.Object, mappingServiceMock.Object, userServiceMock.Object, utilsMock.Object);
var controllerContext = new Mock <ControllerContext>();
var user = new Mock <IPrincipal>();
user.Setup(p => p.IsInRole("admin")).Returns(true);
user.SetupGet(x => x.Identity.Name).Returns("username");
controllerContext.SetupGet(x => x.HttpContext.User).Returns(user.Object);
controller.ControllerContext = controllerContext.Object;
var model = new CreateImageViewModel();
// Act & Assert
controller.WithCallTo(x => x.Create(model))
.ShouldRedirectTo(x => x.Index(null, null));
}
