public async Task UpdateAsync(int id, EditGameInputModel input)
{
var game = this.gamesRepository.All().FirstOrDefault(x => x.Id == id);
game.Title = input.Title;
game.Price = input.Price;
game.Description = input.Description;
game.Drm = input.Drm;
game.MininumRequirements = input.MininumRequirements;
game.RecommendedRequirements = input.RecommendedRequirements;
game.GenreId = input.GenreId;
game.PublisherId = input.PublisherId;
game.IsOnSale = input.IsOnSale;
game.SalePercentage = input.SalePercentage;
if (game.IsOnSale)
{
game.CurrentPrice = game.Price - (game.Price * input.SalePercentage / 100);
if (game.CurrentPrice.ToString("f2").EndsWith("0"))
{
game.CurrentPrice -= 0.01m;
}
}
else
{
game.SalePercentage = 0;
game.CurrentPrice = game.Price;
}
await this.gamesRepository.SaveChangesAsync();
}
public async Task <IActionResult> Edit(string id, EditGameInputModel model)
{
var rootPath = this.environment.WebRootPath;
await this.gameService.EditGameAsync(id, model, rootPath);
return(this.Redirect($"/Games/Details?id={id}"));
}
public IActionResult Edit(string id)
{
var game = this.gameService.GetGameById(id);
var model = new EditGameInputModel
{
Name = game.Name,
Id = game.Id,
};
return(this.View(model));
}
public async Task <IActionResult> Edit(int id, EditGameInputModel input)
{
if (!this.ModelState.IsValid)
{
input.GenresItems = this.genresService.GetAllAsKeyValuePairs();
input.PublisherItems = this.publishersService.GetAllAsKeyValuePairs();
return(this.View(input));
}
await this.gamesService.UpdateAsync(id, input);
return(this.RedirectToAction(nameof(this.ById), new { id }));
}
public async Task EditAsync(EditGameInputModel input, int id)
{
var game = this.gamesRepository
.All()
.FirstOrDefault(g => g.Id == id);
game.ImageUrl = input.ImageUrl;
game.Price = input.Price;
game.Description = input.Description;
game.ReleaseDate = input.ReleaseDate;
game.Title = input.Title;
this.gamesRepository.Update(game);
await this.gamesRepository.SaveChangesAsync();
}
public async Task <IActionResult> Edit(EditGameInputModel inputModel)
{
if (!ModelState.IsValid)
{
return(this.View());
}
this.gameService.EditGame(inputModel.Id, inputModel.Name);
if (inputModel.MainImage != null)
{
var imageUrl = await this.pictureService.UploadImage(inputModel.MainImage, GlobalConstants.GAME_PATH_TEMPLATE, inputModel.Name, inputModel.Id);
this.gameService.AddImageUrl(inputModel.Id, imageUrl);
}
return(this.RedirectToAction("GameList"));
}
private async Task UpdateGamePlatforms(EditGameInputModel model, Game game)
{
foreach (var platformId in model.Platforms)
{
var gamePlatform = new GamePlatform {
GameId = game.Id, PlatformId = platformId
};
await this.gamePlatformRepository.AddAsync(gamePlatform);
game.GamePlatforms.Add(gamePlatform);
}
await this.gamePlatformRepository.SaveChangesAsync();
await this.gameRepository.SaveChangesAsync();
}
private async Task UpdateGameLanguages(EditGameInputModel model, Game game)
{
foreach (var languageId in model.Languages)
{
var gameLanguage = new GameLanguage {
GameId = game.Id, LanguageId = languageId
};
await this.gameLanguageRepository.AddAsync(gameLanguage);
game.GameLanguages.Add(gameLanguage);
}
await this.gameLanguageRepository.SaveChangesAsync();
await this.gameRepository.SaveChangesAsync();
}
private async Task UpdateGameGenres(EditGameInputModel model, Game game)
{
foreach (var genreId in model.Genres)
{
var gameGenre = new GameGenre {
GameId = game.Id, GenreId = genreId
};
await this.gameGenreRepository.AddAsync(gameGenre);
game.GameGenres.Add(gameGenre);
}
await this.gameGenreRepository.SaveChangesAsync();
await this.gameRepository.SaveChangesAsync();
}
public async Task EditGameAsync(string id, EditGameInputModel model, string rootPath)
{
await this.CheckIfGameExistsByIdAsync(id);
var game = await this.gameRepository.All()
.Include(x => x.GameGenres)
.Include(x => x.GameLanguages)
.Include(x => x.GameGenres)
.FirstOrDefaultAsync(x => x.Id == id);
var imagePath = await GlobalMethods.UploadedFile(model.Image, model.Name, rootPath, MainFileName);
var developer = await this.developerRepository.All()
.FirstOrDefaultAsync(x => x.Name == model.Developer);
if (developer == null)
{
developer = new Developer()
{
Name = model.Developer
};
}
game.Name = model.Name;
game.Image = imagePath;
game.Price = model.Price;
game.ReleaseDate = model.ReleaseDate;
game.Summary = model.Summary;
game.Website = model.Website;
game.TrailerUrl = model.Trailer;
game.Developer = developer;
await this.gameRepository.SaveChangesAsync();
var gameGenres = await this.gameGenreRepository.All().Where(x => x.GameId == game.Id).ToListAsync();
var gameLanguages = await this.gameLanguageRepository.All().Where(x => x.GameId == game.Id).ToListAsync();
var gamePlatforms = await this.gamePlatformRepository.All().Where(x => x.GameId == game.Id).ToListAsync();
if (gameGenres.Count != 0)
{
foreach (var genre in gameGenres)
{
this.gameGenreRepository.HardDelete(genre);
await this.gameGenreRepository.SaveChangesAsync();
}
}
await this.UpdateGameGenres(model, game);
if (gameLanguages.Count != 0)
{
foreach (var language in gameLanguages)
{
this.gameLanguageRepository.HardDelete(language);
await this.gameLanguageRepository.SaveChangesAsync();
}
}
await this.UpdateGameLanguages(model, game);
if (gamePlatforms.Count != 0)
{
foreach (var platform in gamePlatforms)
{
this.gamePlatformRepository.HardDelete(platform);
await this.gamePlatformRepository.SaveChangesAsync();
}
}
await this.UpdateGamePlatforms(model, game);
}
public async Task <IActionResult> Edit(EditGameInputModel input, int id)
{
await this.gamesService.EditAsync(input, id);
return(this.RedirectToAction(nameof(this.All)));
}
