public async Task <GameUpdateViewModel> GetGameUpdateDataAsync(int id)
{
var game = await gameDbService.GetUpdateDataAsync(id);
if (game == null)
{
return(null);
}
//var platformList = await platformDbService.GetAllAsync();
//var genreList = await genreDbService.GetAllAsync();
//var languageList = await languageDbService.GetAllAsync();
//var mediaTypeList = await mediaTypeDbService.GetAllAsync();
//var seriesList = await seriesDbService.GetAllAsync();
//var modeList = await modeDbService.GetAllAsync();
//var developerList = await developerDbService.GetAllAsync();
//var publisherList = await publisherDbService.GetAllAsync();
//return GameMapper.ToUpdateViewModel(game, platformList, genreList, languageList, mediaTypeList, seriesList, modeList, developerList, publisherList);
GameUpdateViewModel vm = GameMapper.ToUpdateViewModel(game);
await FillSelectLists(vm);
return(vm);
}
public async Task <IActionResult> Edit(int id, [Bind("ID,Title,AlternateTitle,PlatformID,LanguageID,MediaTypeID,GenreIDs,SeriesIDs,ModeIDs,DeveloperIDs,PublisherIDs,ReleaseDate,Description")]
GameUpdateViewModel gameUpdateViewModel)
{
if (id != gameUpdateViewModel.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
if (await gameViewService.UpdateResultsInDuplicateEntryAsync(gameUpdateViewModel))
{
ModelState.AddModelError(string.Empty, "A game with the same title, platform, release date and language already exists in the database.");
await gameViewService.FillSelectLists(gameUpdateViewModel);
return(View(gameUpdateViewModel));
}
await gameViewService.UpdateGameAsync(gameUpdateViewModel);
return(RedirectToAction(nameof(Details), new { id = id }));
}
await gameViewService.FillSelectLists(gameUpdateViewModel);
return(View(gameUpdateViewModel));
}
public async Task <bool> UpdateResultsInDuplicateEntryAsync(GameUpdateViewModel vm)
{
var updatedGame = GameMapper.ToGame(vm);
bool resultsInDuplicateGame = await gameDbService.CommandResultsInDuplicateEntryAsync(updatedGame);
return(resultsInDuplicateGame);
}
public IActionResult Put([FromBody] GameUpdateViewModel gameUpdateViewModel, int id)
{
gameUpdateViewModel.Id = id;
gameUpdateViewModel.UserId = Convert.ToInt32(User.Identity.Name);
_gameService.Update(gameUpdateViewModel);
return(StatusCode(StatusCodes.Status200OK));
}
internal static Game ToGame(GameUpdateViewModel vm)
{
var game = ToGame((GameCreateViewModel)vm);
game.ID = vm.ID;
return(game);
}
public async Task <ResultViewModel> Put(GameUpdateViewModel game)
{
var entity = _mapper.Map <Game>(game);
var result = await _repository.UpdateAsync(entity);
return(new ResultViewModel
{
Success = true,
Message = "Jogo modificado.",
Data = _mapper.Map <GameViewModel>(result)
});
}
public async Task game_service_update_should_succeed()
{
var gameUpdateViewModel = new GameUpdateViewModel
{
Id = 1,
UserId = 1,
ReleaseDate = DateTime.UtcNow,
Name = "test1",
Description = "test",
};
_gameService.Update(gameUpdateViewModel);
_autoMapperMock.Verify(x => x.Map <UpdateGameCommand>(gameUpdateViewModel), Times.Once);
_mediatorBusMock.Verify(x => x.SendCommand(It.IsAny <UpdateGameCommand>()), Times.Once);
}
public IActionResult <AdminGameUpdateViewModel> Edit(HttpSession session, HttpResponse response, int id)
{
if (!this.securityService.IsAuthenticated(session))
{
this.Redirect(response, "/user/login");
return(null);
}
if (!this.securityService.IsAdmin(session))
{
this.Redirect(response, "/home/index");
return(null);
}
Game game = this.gameService.Find(id);
GameUpdateViewModel model = new GameUpdateViewModel
{
Id = game.Id,
Title = game.Title,
ImageThumbnail = game.ImageThumbnail,
Price = game.Price,
ReleaseDate =
game.ReleaseDate.ToString("yyyy-MM-dd"),
Size = game.Size,
Description = game.Description,
VideoUrl = game.VideoUrl
};
return
(this.View(
new AdminGameUpdateViewModel
{
GameUpdateViewModel = model,
EmailViewModel =
new EmailViewModel
{
Email =
this.securityService
.GetCurrentlyLoggedUser(session)
.Email
}
}));
}
public async Task <ActionResult> Put([FromBody] GameUpdateViewModel model)
{
if (model.IdOwner == 0)
{
string authenticatedUserName = _accessor.HttpContext.User.Identity.Name;
var user = await _serviceUser.GetByName(authenticatedUserName);
model.IdOwner = user.Id;
}
if (model.Invalid)
{
return(BadRequest(new ResultViewModel
{
Success = false,
Message = "Não foi possível atualizar o jogo",
Data = model.Notifications
}));
}
var result = await _service.Put(model);
return(Ok(result));
}
public void Update(GameUpdateViewModel gameUpdateViewModel)
{
var updateGameCommand = _mapper.Map <UpdateGameCommand>(gameUpdateViewModel);
_bus.SendCommand(updateGameCommand);
}
public IActionResult Put(int id, [FromBody] GameUpdateViewModel game)
{
GamesUpdateResponseDTO gamesUpdateResponseDTO = _gamesService.GamesUpdate(id, _mapper.Map <GameUpdateViewModel, GamesUpdateRequestDTO>(game));
return(StatusCode(StatusCodes.Status201Created, gamesUpdateResponseDTO));
}
public async Task UpdateGameAsync(GameUpdateViewModel guVM)
{
var game = GameMapper.ToGame(guVM);
await gameDbService.UpdateAsync(game);
}
internal static GameUpdateViewModel ToUpdateViewModel(Game game, IEnumerable <Platform> platformList, IEnumerable <Genre> genreList, IEnumerable <Language> languageList,
IEnumerable <MediaType> mediaTypeList, IEnumerable <Series> seriesList, IEnumerable <Mode> modeList, IEnumerable <Developer> developerList, IEnumerable <Publisher> publisherList)
{
var vm = new GameUpdateViewModel
{
ID = game.ID,
Title = game.Title,
AlternateTitle = game.AlternateTitle,
ReleaseDate = game.ReleaseDate,
Description = game.Description,
PlatformID = game.PlatformID,
LanguageID = game.LanguageID,
MediaTypeID = game.MediaTypeID
};
if (game.Genres != null && game.Genres.Count > 0)
{
var selectedGenres = new List <int>();
foreach (var genre in game.Genres)
{
selectedGenres.Add(genre.GenreID);
}
vm.GenreIDs = selectedGenres.ToArray();
}
if (game.Series != null && game.Series.Count > 0)
{
var selectedSeries = new List <int>();
foreach (var series in game.Series)
{
selectedSeries.Add(series.SeriesID);
}
vm.SeriesIDs = selectedSeries.ToArray();
}
if (game.Modes != null && game.Modes.Count > 0)
{
var selectedModes = new List <int>();
foreach (var mode in game.Modes)
{
selectedModes.Add(mode.ModeID);
}
vm.ModeIDs = selectedModes.ToArray();
}
if (game.Developers != null && game.Developers.Count > 0)
{
var selectedDevelopers = new List <int>();
foreach (var developer in game.Developers)
{
selectedDevelopers.Add(developer.DeveloperID);
}
vm.DeveloperIDs = selectedDevelopers.ToArray();
}
if (game.Publishers != null && game.Publishers.Count > 0)
{
var selectedPublishers = new List <int>();
foreach (var publisher in game.Publishers)
{
selectedPublishers.Add(publisher.PublisherID);
}
vm.PublisherIDs = selectedPublishers.ToArray();
}
vm.PlatformSelectList = new SelectList(platformList, nameof(Platform.ID), nameof(Platform.Name));
vm.GenreSelectList = new SelectList(genreList, nameof(Genre.ID), nameof(Genre.Name));
vm.LanguageSelectList = new SelectList(languageList, nameof(Language.ID), nameof(Language.Name));
vm.MediaTypeSelectList = new SelectList(mediaTypeList, nameof(MediaType.ID), nameof(MediaType.Name));
vm.SeriesSelectList = new SelectList(seriesList, nameof(Series.ID), nameof(Series.Name));
vm.ModeSelectList = new SelectList(modeList, nameof(Mode.ID), nameof(Mode.Name));
vm.DeveloperSelectList = new SelectList(developerList, nameof(Developer.ID), nameof(Developer.Name));
vm.PublisherSelectList = new SelectList(publisherList, nameof(Publisher.ID), nameof(Publisher.Name));
return(vm);
}
internal static GameUpdateViewModel ToUpdateViewModel(Game game)
{
var vm = new GameUpdateViewModel
{
ID = game.ID,
Title = game.Title,
AlternateTitle = game.AlternateTitle,
ReleaseDate = game.ReleaseDate,
Description = game.Description,
PlatformID = game.PlatformID,
LanguageID = game.LanguageID,
MediaTypeID = game.MediaTypeID
};
if (game.Genres != null && game.Genres.Count > 0)
{
var selectedGenres = new List <int>();
foreach (var genre in game.Genres)
{
selectedGenres.Add(genre.GenreID);
}
vm.GenreIDs = selectedGenres.ToArray();
}
if (game.Series != null && game.Series.Count > 0)
{
var selectedSeries = new List <int>();
foreach (var series in game.Series)
{
selectedSeries.Add(series.SeriesID);
}
vm.SeriesIDs = selectedSeries.ToArray();
}
if (game.Modes != null && game.Modes.Count > 0)
{
var selectedModes = new List <int>();
foreach (var mode in game.Modes)
{
selectedModes.Add(mode.ModeID);
}
vm.ModeIDs = selectedModes.ToArray();
}
if (game.Developers != null && game.Developers.Count > 0)
{
var selectedDevelopers = new List <int>();
foreach (var developer in game.Developers)
{
selectedDevelopers.Add(developer.DeveloperID);
}
vm.DeveloperIDs = selectedDevelopers.ToArray();
}
if (game.Publishers != null && game.Publishers.Count > 0)
{
var selectedPublishers = new List <int>();
foreach (var publisher in game.Publishers)
{
selectedPublishers.Add(publisher.PublisherID);
}
vm.PublisherIDs = selectedPublishers.ToArray();
}
return(vm);
}
