public void CallCreateServiceMethodCreateGenreOnce_WhenInvoked()
{
// Arrange
var createService = new Mock <ICreationService>();
var artistService = new Mock <IArtistService>();
var albumService = new Mock <IAlbumService>();
var genreService = new Mock <IGenreService>();
createService.Setup(x => x.CreateGenre(It.IsAny <string>()));
var sut = new CreateController(
createService.Object,
artistService.Object,
albumService.Object,
genreService.Object);
var model = new CreateGenreViewModel()
{
Name = "Genre Name"
};
// Act
sut.CreateGenre(model);
// Assert
createService.Verify(x => x.CreateGenre(It.IsAny <string>()), Times.Once);
}
public async Task Redirect_ToViewResult_IfModelInvalid_OnPost()
{
// Arrange
var movieServiceMock = new Mock <IMovieService>();
var genreServiceMock = new Mock <IGenreService>();
var sut = new GenreManagementController(movieServiceMock.Object, genreServiceMock.Object);
sut.ModelState.AddModelError("error", "error");
string genreName = "Comedy";
var createGenreModel = new CreateGenreViewModel()
{
Name = genreName
};
genreServiceMock.Setup(g => g.CreateGenreAsync(genreName))
.ReturnsAsync(new GenreViewModel());
// Act
var result = await sut.Create(createGenreModel);
// Assert
Assert.IsInstanceOfType(result, typeof(ViewResult));
var viewResultRedirect = (ViewResult)result;
Assert.IsInstanceOfType(viewResultRedirect.Model, typeof(CreateGenreViewModel));
}
public async Task RedirectToCorrectAction_OnPost()
{
// Arrange
var movieServiceMock = new Mock <IMovieService>();
var genreServiceMock = new Mock <IGenreService>();
var sut = new GenreManagementController(movieServiceMock.Object, genreServiceMock.Object);
string genreName = "Comedy";
var createGenreModel = new CreateGenreViewModel()
{
Name = genreName
};
genreServiceMock.Setup(g => g.CreateGenreAsync(genreName))
.ReturnsAsync(new GenreViewModel());
// Act
var result = await sut.Create(createGenreModel);
// Assert
Assert.IsInstanceOfType(result, typeof(RedirectToActionResult));
var redirect = (RedirectToActionResult)result;
// They are redirecting to the basic Movie Controller, not the MovieManagement one.
Assert.IsTrue(redirect.ControllerName == "Admin");
Assert.IsTrue(redirect.ActionName == "Index");
}
public IActionResult Create(CreateGenreViewModel vm)
{
if (!ModelState.IsValid)
{
return(View());
}
var selectedGenre = genreRepository.getAll()
.Where(x => x.Title == vm.Title)
.FirstOrDefault();
if (selectedGenre != null)
{
ModelState.AddModelError("errors", "ასეთი კატეგორია უკვე არსებობს");
return(View(selectedGenre));
}
Genre genre = new Genre
{
Title = vm.Title,
};
genreRepository.Add(genre);
return(RedirectToAction("Index", "Genre"));
}
public async Task <IActionResult> Add(CreateGenreViewModel model)
{
if (ModelState.IsValid)
{
GenreDetail existingGenre = await _genreRepo.GetAsync(model.Name);
if (existingGenre == null)
{
try
{
await _genreRepo.AddAsync(model.Name);
this.SetBootstrapPageAlert("Success", "New genre added", BootstrapAlertType.success);
return(RedirectToAction(nameof(Index)));
}catch (Exception e)
{
_logger.LogError(e, "Error creating genre");
ModelState.AddModelError(nameof(model.Name), "Error adding genre to the database");
return(View(model));
}
}
else
{
ModelState.AddModelError(nameof(model.Name), "A genre with this name already exists");
return(View(model));
}
}
else
{
return(View(model));
}
}
public ActionResult Create(CreateGenreViewModel model)
{
var genre = new Genre();
genre.Name = model.Name;
genreRepository.Create(genre);
return(RedirectToAction("Index"));
}
public int Create(CreateGenreViewModel createGenreViewModel)
{
Validate(createGenreViewModel);
return(genreService.Create(new CreateGenreRequest()
{
Description = createGenreViewModel.Description,
}));
}
public void AddGenre(CreateGenreViewModel genreModel)
{
Genre genre = Mapper.Map <CreateGenreViewModel, Genre>(genreModel);
genre.GenreImage.ImageData = GetArray(genreModel.GenreImage);
genreDomainService.Entry(genre).State = EntityState.Added;
genreDomainService.SaveChanges();
}
public void Create(CreateGenreViewModel genre)
{
FilmHausDbContext.Genres.Add(new Genre
{
DetailId = Guid.NewGuid(),
Name = genre.Name,
CreatedOn = DateTime.Now
});
FilmHausDbContext.SaveChanges();
}
public async Task <IActionResult> CreateGenreAsync([FromBody] CreateGenreViewModel createGenreViewModel)
{
var createGenreDTO = _mapper.Map <CreateGenreDTO>(createGenreViewModel);
var genreDTO = await _genreService.CreateGenreAsync(createGenreDTO);
var genreViewModel = _mapper.Map <GenreViewModel>(genreDTO);
return(Ok(genreViewModel));
}
public ActionResult Update(CreateGenreViewModel createGenre)
{
if (ModelState.IsValid)
{
var genreDto = Mapper.Map <GenreDTO>(createGenre);
_genreService.EditEntity(genreDto);
return(RedirectToAction("Index"));
}
createGenre.AllGenres = Mapper.Map <IEnumerable <GenreViewModel> >(_genreService.GetAll(false));
return(View("Update", createGenre));
}
public IActionResult Create(CreateGenreViewModel model)
{
if (!ModelState.IsValid)
{
return(this.View(model));
}
this._genreService.Create(model.Name);
return(this.RedirectToAction(nameof(All)));
}
public virtual ActionResult CreateGenre(CreateGenreViewModel genreModel)
{
if (ModelState.IsValid)
{
adminGenre.AddGenre(genreModel);
return(Redirect(Url.Action(MVC.Admin.AdminGenre.FormGenreSuccess())));
}
return(PartialView("FormCreateGenre", genreModel));
}
public async Task <IActionResult> Create(CreateGenreViewModel input)
{
if (!this.ModelState.IsValid)
{
return(this.View(input));
}
await this.genresService.CreateGenreAsync(input.Name);
return(this.RedirectToAction(nameof(this.All)));
}
public async Task <IActionResult> Create(CreateGenreViewModel model)
{
if (this.ModelState.IsValid)
{
await this.genreService.CreateGenreAsync(model.Name);
return(this.RedirectToAction("Index", "Admin"));
}
return(this.View(model));
}
public ActionResult Create(CreateGenreViewModel model)
{
if (!ModelState.IsValid)
{
return(Create());
}
var genre = mapper.Map <CreateGenreViewModel, Genre>(model);
genreService.CreateGenre(genre);
return(RedirectToAction(nameof(Index)));
}
public HttpResponseMessage Put(string name, [FromBody] CreateGenreViewModel model)
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
var genreDto = Mapper.Map <GenreDTO>(model);
_genreService.EditEntity(genreDto);
return(Request.CreateResponse(HttpStatusCode.OK));
}
public ActionResult Create(CreateGenreViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var request = new CreateGenreRequest {
Name = model.Name, Description = model.Description
};
_genreService.CreateGenre(request);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Create(CreateGenreViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var genre = new Genre {
Name = model.Name
};
_context.Add(genre);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public ActionResult New(CreateGenreViewModel createGenre)
{
if (ModelState.IsValid)
{
var genreDto = Mapper.Map <GenreDTO>(createGenre);
_genreService.AddEntity(genreDto);
return(RedirectToAction("Index"));
}
createGenre.Translates = new List <TranslateViewModel>
{
new TranslateViewModel
{
Id = Guid.NewGuid().ToString(),
Language = Language.ru
}
};
createGenre.AllGenres = Mapper.Map <IEnumerable <GenreViewModel> >(_genreService.GetAll(false));
return(View("New", createGenre));
}
public ActionResult New()
{
var genre = new CreateGenreViewModel
{
Id = Guid.NewGuid().ToString(),
Translates = new List <TranslateViewModel>
{
new TranslateViewModel
{
Id = Guid.NewGuid().ToString(),
Language = Language.ru
}
}
};
genre.AllGenres = Mapper.Map <IEnumerable <GenreViewModel> >(_genreService.GetAll(false));
return(View(genre));
}
public async Task <IActionResult> Create(CreateGenreViewModel viewModel)
{
if (ModelState.IsValid)
{
if (await _context.Genres.FirstOrDefaultAsync(x => x.Name == viewModel.Name) != null)
{
this.ModelState.AddModelError(string.Empty, $"Genre with name '{viewModel.Name}' already exists");
return(View(viewModel));
}
var genre = this._mapper.Map <CreateGenreViewModel, Genre>(viewModel);
_context.Add(genre);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(viewModel));
}
public ActionResult New(CreateGenreViewModel model)
{
if (!ModelState.IsValid)
{
List <GenreDto> genres = _genreService.GetAllGenres().ToList();
genres.Insert(0, new GenreDto {
Id = 0, Name = Resource.Default
});
model.Genres = new SelectList(genres, "Id", "Name", genres.First().Id);
return(View(model));
}
if (model.ParentGenreId != null && model.ParentGenreId == default(int))
{
model.ParentGenreId = null;
}
_genreService.Create(model.Name, model.ParentGenreId);
return(RedirectToAction("GetAll"));
}
public async Task Call_GenreServiceWithCorrectParams_OnPost()
{
// Arrange
var movieServiceMock = new Mock <IMovieService>();
var genreServiceMock = new Mock <IGenreService>();
var sut = new GenreManagementController(movieServiceMock.Object, genreServiceMock.Object);
string genreName = "Comedy";
var createGenreModel = new CreateGenreViewModel()
{
Name = genreName
};
genreServiceMock.Setup(g => g.CreateGenreAsync(genreName))
.ReturnsAsync(new GenreViewModel());
// Act
var result = await sut.Create(createGenreModel);
// Assert
genreServiceMock.Verify(g => g.CreateGenreAsync(genreName), Times.Once);
}
public ActionResult CreateGenre()
{
var model = new CreateGenreViewModel();
return(View(model));
}
public IActionResult Create()
{
CreateGenreViewModel model = new CreateGenreViewModel();
return(View(model));
}
public void Update(CreateGenreViewModel updateGameViewModel)
{
throw new NotImplementedException();
}
public IActionResult Create(CreateGenreViewModel model)
{
Boolean success = _genreService.AddGenre(_mapper.Map <MusicCore.Genre>(model.genre));
return(RedirectToAction("Genres"));
}
public Task <int?> CreateAsync(CreateGenreViewModel genreViewModel)
{
throw new System.NotImplementedException();
}
public ActionResult CreateGenre(CreateGenreViewModel genre)
{
this.createService.CreateGenre(genre.Name);
return(RedirectToAction(CreationChoiceAction));
}
