public async Task <IActionResult> Create(GameCreateViewModel game)
{
try
{
if (ModelState.IsValid)
{
_dbContext.Add(game);
await _dbContext.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
catch (DbUpdateException)
{
ViewData["ErrorMessage"] =
"Create failed. Try again.";
}
var categories = _dbContext.Category.ToList();
ViewData["Categories"] = categories;
var publishers = _dbContext.Publisher.ToList();
ViewData["Publishers"] = publishers;
return(View(game));
}
public IActionResult Create()
{
GameCreateViewModel viewModel = new GameCreateViewModel();
viewModel.Game = new Game();
viewModel.Genres = genreService.GetAll().Select(x => new SelectListItem()
{
Text = x.Name,
Value = x.ID.ToString()
}).ToList();
viewModel.Developers = developerService.GetAll().Select(x => new SelectListItem()
{
Text = x.Name,
Value = x.ID.ToString()
}).ToList();
viewModel.Publishers = publisherService.GetAll().Select(x => new SelectListItem()
{
Text = x.Name,
Value = x.ID.ToString()
}).ToList();
viewModel.Platforms = platformService.GetAll().Select(x => new SelectListItem()
{
Text = x.Name,
Value = x.ID.ToString()
}).ToList();
return(View(viewModel));
}
// GET: Game/Create
public IActionResult Create()
{
var viewModel = new GameCreateViewModel();
viewModel.Teams = _context.TeamModel;
return(View(viewModel));
}
public async Task <GameCreateViewModel> FillSelectLists(GameCreateViewModel gvm)
{
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();
gvm.PlatformSelectList = new SelectList(platformList, nameof(Platform.ID), nameof(Platform.Name));
gvm.GenreSelectList = new SelectList(genreList, nameof(Genre.ID), nameof(Genre.Name));
gvm.LanguageSelectList = new SelectList(languageList, nameof(Language.ID), nameof(Language.Name));
gvm.MediaTypeSelectList = new SelectList(mediaTypeList, nameof(MediaType.ID), nameof(MediaType.Name));
gvm.SeriesSelectList = new SelectList(seriesList, nameof(Series.ID), nameof(Series.Name));
gvm.ModeSelectList = new SelectList(modeList, nameof(Mode.ID), nameof(Mode.Name));
gvm.DeveloperSelectList = new SelectList(developerList, nameof(Developer.ID), nameof(Developer.Name));
gvm.PublisherSelectList = new SelectList(publisherList, nameof(Publisher.ID), nameof(Publisher.Name));
return(gvm);
}
public ActionResult Create()
{
var model = new GameCreateViewModel();
model.BindData(UnitOfWork);
return(View(model));
}
public async Task <IActionResult> EditGame(string id)
{
if (string.IsNullOrEmpty(id))
{
_notification.AddErrorToastMessage("بازی پیدا نشد !");
return(RedirectToAction(nameof(Index)));
}
var game = await _db.GameRepository.GetByIdAsync(id);
if (game == null)
{
return(RedirectToAction(nameof(Index)));
}
var model = new GameCreateViewModel()
{
Id = game.Id,
Title = game.Title,
ImageName = game.ImageName,
ComingSoon = game.ComingSoon,
Count = game.Count,
Explanation = game.Explanation,
Summary = game.Summary,
Platforms = await _db.PlatformRepository.GetAllAsync(a => !a.IsDeleted),
Genres = await _db.GenreRepository.GetAllAsync(a => !a.IsDeleted)
};
await FillAllViewBags(game.Id);
return(View(model));
}
public ActionResult Create([Bind(Include = "GameId,Player1Id,Player2Id,GamemodeId,Moves,Winner")] GameCreateViewModel gameCreateViewModel)
{
if (ModelState.IsValid)
{
var player1 = db.Users.Find(gameCreateViewModel.Player1Id);
var player2 = db.Users.Find(gameCreateViewModel.Player2Id);
var gamemode = db.Gamemodes.Find(gameCreateViewModel.GamemodeId);
if (gamemode == null)
{
gamemode = new Gamemode(1, 0);
}
Game game = new Game(gamemode)
{
GameId = gameCreateViewModel.GameId,
Player1 = player1,
Player2 = player2,
Moves = gameCreateViewModel.Moves,
Winner = gameCreateViewModel.Winner,
//Timer1=gameCreateViewModel.Timer1,
//Timer2= gameCreateViewModel.Timer2,
};
db.Games.Add(game);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(gameCreateViewModel));
}
public IActionResult Create(GameCreateViewModel obj)
{
if (ModelState.IsValid)
{
string uniqueFileName = UploadedFile(obj);
Game game = new Game
{
Name = obj.Name,
ReleaseDate = obj.ReleaseDate,
Platform = obj.Platform,
Publisher = obj.Publisher,
Genre = obj.Genre,
Description = obj.Description,
Developer = obj.Developer,
MinimalRequirements = obj.MinimalRequirements,
MinimalRequirementsId = obj.MinimalRequirements.Id,
RecommendedRequirements = obj.RecommendedRequirements,
RecommendedRequirementsId = obj.RecommendedRequirements.Id,
Image = uniqueFileName,
};
_db.Game.Add(game);
_db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(obj));
}
public IActionResult Post([FromBody] GameCreateViewModel gameCreateViewModel)
{
gameCreateViewModel.UserId = Convert.ToInt32(User.Identity.Name);
_gameService.Add(gameCreateViewModel);
return(StatusCode(StatusCodes.Status200OK));
}
public IActionResult Create([Bind("Title,Description,Price,Date,Developer,Publisher,RecordId,File,IsDownloadable")] GameCreateViewModel vm)
{
if (ModelState.IsValid)
{
var game = new Game();
game.Title = vm.Title;
game.Description = vm.Description;
game.Price = vm.Price;
game.Date = vm.Date;
game.Developer = vm.Developer;
game.Publisher = vm.Publisher;
game.RecordId = vm.RecordId;
game.IsDownloadable = vm.IsDownloadable;
var file = vm.File;
var parsedContentDisposition =
ContentDispositionHeaderValue.Parse(file.ContentDisposition);
var filename = Path.Combine(_hostingEnvironment.WebRootPath, "images", "games", parsedContentDisposition.FileName.Trim('"'));
using (var stream = System.IO.File.OpenWrite(filename))
{
file.CopyTo(stream);
}
game.ImageFileName = parsedContentDisposition.FileName.Trim('"');
this.gameRepository.AddGame(game);
this.gameRepository.Save();
return(RedirectToAction(nameof(Index)));
}
return(View(vm));
}
public void Create_CreateAGame_OneGameIsCreated()
{
var mock = new Mock <IGameRepository>();
var game = new Game
{
Title = "Game6",
Description = "Description 6",
Price = 100,
Developer = "Developer 6",
Publisher = "Publisher 6",
ImageFileName = "",
Date = DateTime.Now
};
var game1 = new GameCreateViewModel
{
Title = "Game6",
Description = "Description 6",
Price = 100,
Developer = "Developer 6",
Publisher = "Publisher 6",
ImageFileName = "",
Date = DateTime.Now
};
mock.Setup(g => g.AddGame(game));
using (var controller = new GameController(mock.Object, null))
{
var result = controller.Create(game1) as ViewResult;
Assert.Null(result);
}
}
public IActionResult Create(GameCreateViewModel model, List <IFormFile> files)
{
if (ModelState.IsValid)
{
var gameIamgeMaxFileSize = Configuration.GetValue <long>("GameIamgeMaxFileSize", 60);
// validation for Image
var imageValid = true;
for (int i = 0; i < files.Count; i++)
{
if (files[i].Length > gameIamgeMaxFileSize)
{
imageValid = false;
break;
}
}
if (!imageValid)
{
ModelState.AddModelError("imageSize", $"یک یا چند تا از عکس های انتخاب شده حجمشان بیش از {gameIamgeMaxFileSize} کیلو بایت است");
}
else
{
// upload images
List <string> imgagesName = new List <string>();
files.ForEach(c =>
{
var imageName = $"{Guid.NewGuid()}{Path.GetExtension(c.FileName)}";
var path = Path.Combine(_env.WebRootPath, "Attachment", imageName);
var fileStream = new FileStream(path, FileMode.Create);
c.CopyTo(fileStream);
fileStream.Close();
imgagesName.Add(imageName);
});
// insert db
// insert in db
var result = _gameRepository.Create(new GameViewModel
{
CreatDate = DateTime.Now,
DisplayName = model.DisplayName,
Name = model.Name,
Images = imgagesName.Select(cu => new ImageGameViewModel
{
ImageName = cu
}).ToList()
});
TempData.AddResult(result);
return(RedirectToAction(nameof(Create)));
}
}
return(View(model));
}
public async Task <bool> CreateResultsInDuplicateEntryAsync(GameCreateViewModel vm)
{
var newGame = GameMapper.ToGame(vm);
bool resultsInDuplicateGame = await gameDbService.CommandResultsInDuplicateEntryAsync(newGame);
return(resultsInDuplicateGame);
}
public ActionResult Buy(GameCreateViewModel model)
{
var game = mapper.Map <Game>(model);
var userId = User.Identity.GetUserId();
_context.Usermanagers.FirstOrDefault(x => x.UserId == userId).Games.ToList().Add(game);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <IActionResult> AddGame()
{
var viewmodel = new GameCreateViewModel()
{
Platforms = await _db.PlatformRepository.GetAllAsync(a => !a.IsDeleted),
Genres = await _db.GenreRepository.GetAllAsync(a => !a.IsDeleted),
};
return(View(viewmodel));
}
public void ShouldReturnErrorWhenNameIsInvalid()
{
var game = new GameCreateViewModel(
"Wa",
EGameType.Tabuleiro,
"Descrição do jogo",
1
);
Assert.IsTrue(game.Invalid);
}
public void ShouldReturnErrorWhenDescriptionIsInvalid()
{
var game = new GameCreateViewModel(
"War",
EGameType.Tabuleiro,
"O melhor jogo de estratégia de todos os tempos! Com War, uma batalha nunca é igual a outra, e cada jogador precisa usar toda sua habilidade militar para conquistar territórios e continentes e derrotar seus adversários.",
1
);
Assert.IsTrue(game.Invalid);
}
public async Task <IActionResult> Create(GameCreateViewModel viewModel)
{
if (ModelState.IsValid)
{
_context.Add(viewModel.gameModel);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(viewModel));
}
public void ShouldReturnSuccessWhenGameCreateViewModelIsValid()
{
var game = new GameCreateViewModel(
"War",
EGameType.Tabuleiro,
"O melhor jogo de estratégia de todos os tempos!",
1
);
Assert.IsTrue(game.Valid);
}
public ActionResult Edit(GameCreateViewModel model)
{
if (ModelState.IsValid)
{
var game = mapper.Map <Game>(model);
gameService.Update(game);
return(RedirectToAction("Index"));
}
return(Edit(model.Id));
}
public async Task <ResultViewModel> Post(GameCreateViewModel game)
{
var entity = _mapper.Map <Game>(game);
var result = await _repository.InsertAsync(entity);
return(new ResultViewModel
{
Success = true,
Message = "Jogo criado.",
Data = _mapper.Map <GameViewModel>(result)
});
}
public async Task <IActionResult> AddGame(GameCreateViewModel model, IFormFile image)
{
if (!ModelState.IsValid || image == null || !model.Genres.Any() || !model.Platforms.Any())
{
_notification.AddWarningToastMessage("مقادیر را به درستی وارد نمایید");
return(View(model));
}
model.ImageName = await _fileManager.UploadImage(image, FileManagerType.FileType.GameImage);
var game = new Game()
{
ImageName = model.ImageName,
IsDeleted = false,
Count = model.Count,
Explanation = model.Explanation,
Summary = model.Summary,
Title = model.Title,
ComingSoon = model.ComingSoon,
CreatedTime = DateTime.Now,
LastModifiedTime = DateTime.Now,
};
foreach (var item in model.Genres)
{
var genre = (await _db.GenreRepository.GetAllAsync(a => a.Title == item.Title)).FirstOrDefault();
await _db.GameGenreRepository.InsertAsync(new GameGenre()
{
Game = game,
GameId = game.Id,
GenreId = genre.Id
});
}
foreach (var item in model.Platforms)
{
var platform = (await _db.PlatformRepository.GetAllAsync(a => a.Title == item.Title)).FirstOrDefault();
await _db.GamePlatformRepository.InsertAsync(new GamePlatform()
{
Game = game,
GameId = game.Id,
PlatformId = platform.Id
});
}
await _db.GameRepository.InsertAsync(game);
await _db.SaveChangeAsync();
_notification.AddSuccessToastMessage($"بازی {game.Title} با موفقیت ثبت شد");
TempData["GameId"] = game.Id;
return(RedirectToAction("AddGameEdition"));
}
public async Task game_service_add_should_succeed()
{
var createGameViewModel = new GameCreateViewModel
{
UserId = 1,
ReleaseDate = DateTime.UtcNow,
Name = "test",
Description = "test",
};
_gameService.Add(createGameViewModel);
_autoMapperMock.Verify(x => x.Map <CreateGameCommand>(createGameViewModel), Times.Once);
_mediatorBusMock.Verify(x => x.SendCommand(It.IsAny <CreateGameCommand>()), Times.Once);
}
public async Task <IActionResult> Create()
{
var currentUser = await GetCurrentUserAsync();
if (currentUser.RoleId == 3)
{
var Teams = _context.Team.ToList();
List <SelectListItem> TeamAOptions = new List <SelectListItem>();
TeamAOptions.Insert(0, new SelectListItem
{
Text = "Select Team A...",
Value = null,
Selected = true
});
List <SelectListItem> TeamBOptions = new List <SelectListItem>();
TeamBOptions.Insert(0, new SelectListItem
{
Text = "Select Team B...",
Value = null,
Selected = true
});
foreach (var t in Teams)
{
SelectListItem li = new SelectListItem
{
Value = t.Id.ToString(),
Text = t.Name
};
TeamAOptions.Add(li);
TeamBOptions.Add(li);
}
GameCreateViewModel viewModel = new GameCreateViewModel
{
TeamAOptions = TeamAOptions,
TeamBOptions = TeamBOptions
};
return(View(viewModel));
}
else
{
return(View());
}
}
internal static GameCreateViewModel ToCreateViewModel(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 GameCreateViewModel();
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);
}
public async Task <IActionResult> Create(GameCreateViewModel model)
{
if (ModelState.IsValid)
{
var photoUrl = await uploadImage.UploadImage(model.Photo);
var game = new Game
{
Name = model.Name,
Description = model.Description,
Genres = model.Genres,
PhotoUrl = photoUrl,
Rating = model.Rating,
RelaseDate = model.RelaseDate
};
gameRepository.AddNewGame(game);
return(RedirectToAction("details", new { id = game.Id }));
}
return(View());
}
public async Task <IActionResult> Create(GameCreateViewModel viewModel)
{
var currentUser = await GetCurrentUserAsync();
if (currentUser.RoleId == 3)
{
if (ModelState.IsValid)
{
_context.Add(viewModel.Game);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(viewModel));
}
else
{
return(View(viewModel));
}
}
public ActionResult Create(GameCreateViewModel model)
{
if (!ModelState.IsValid)
{
model.BindData(UnitOfWork);
return(View(model));
}
var game = new Game()
{
Name = model.Name,
Description = model.Description,
Price = model.Price,
Gender = model.GenderId.HasValue ? UnitOfWork.Gender.Get(model.GenderId) : null
};
UnitOfWork.Game.Save(game);
UnitOfWork.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Create(GameCreateViewModel viewModel, HttpPostedFileBase imageFile)
{
if (ModelState.IsValid)
{
string filename = Guid.NewGuid().ToString() + ".jpg";
string FullPathImage = Server.MapPath(Config.ProductImagePath) + "\\" + filename;
using (Bitmap bmp = new Bitmap(imageFile.InputStream))
{
var readyImage = ImageWorker.CreateImage(bmp, 450, 450);
if (readyImage != null)
{
readyImage.Save(FullPathImage, ImageFormat.Jpeg);
var game = mapper.Map <Game>(viewModel);
game.Image = filename;
gameService.AddGame(game);
return(RedirectToAction("Index"));
}
}
}
return(Create());
}
public async Task <IActionResult> Create([Bind("Title,AlternateTitle,PlatformID,LanguageID,MediaTypeID,GenreIDs,SeriesIDs,ModeIDs,DeveloperIDs,PublisherIDs,ReleaseDate,Description")]
GameCreateViewModel gameCreateViewModel)
{
if (ModelState.IsValid)
{
if (await gameViewService.CreateResultsInDuplicateEntryAsync(gameCreateViewModel))
{
ModelState.AddModelError(string.Empty, "A game with the same title, platform, release date and language already exists in the database.");
await gameViewService.FillSelectLists(gameCreateViewModel);
return(View(gameCreateViewModel));
}
await gameViewService.CreateGameAsync(gameCreateViewModel);
return(RedirectToAction(nameof(Index)));
}
await gameViewService.FillSelectLists(gameCreateViewModel);
return(View(gameCreateViewModel));
}
