public void CommandButtonCreateExecuteTest002_RankedFieldsNullForNonRankedGame()
{
Mock <ISettings> settingsMock = new Mock <ISettings>();
EditGameViewModel model = new EditGameViewModel();
string param = "Victory";
PopulateObject(model.Game, StartProp);
Assert.IsNotNull(model.Game.PlayerLegendRank);
Assert.IsNotNull(model.Game.PlayerRank);
Assert.IsNotNull(model.Game.OpponentLegendRank);
Assert.IsNotNull(model.Game.OpponentRank);
Assert.IsNotNull(model.Game.BonusRound);
//set type to other than ranked value
model.Game.Type = GameType.SoloArena;
model.CommandButtonCreateExecute(param);
Assert.IsNull(model.Game.PlayerLegendRank);
Assert.IsNull(model.Game.PlayerRank);
Assert.IsNull(model.Game.OpponentLegendRank);
Assert.IsNull(model.Game.OpponentRank);
Assert.IsNull(model.Game.BonusRound);
}
public void CommandButtonCreateExecuteTest004_CheckIfESLFileVersionAdded()
{
Mock <ITrackerFactory> trackerFactory = new Mock <ITrackerFactory>();
Mock <IMessenger> messanger = new Mock <IMessenger>();
trackerFactory.Setup(tf => tf.GetService <IMessenger>()).Returns(messanger.Object);
Mock <ISettings> settings = new Mock <ISettings>();
trackerFactory.Setup(tf => tf.GetService <ISettings>()).Returns(settings.Object);
Mock <ITracker> tracker = new Mock <ITracker>();
tracker.Setup(t => t.Games).Returns(new ObservableCollection <DataModel.Game>());
tracker.Setup(t => t.ActiveDeck).Returns(new Deck(trackerFactory.Object));
trackerFactory.Setup(tf => tf.GetTracker()).Returns(tracker.Object);
FileVersionInfo expected = FileVersionInfo.GetVersionInfo(Assembly.GetAssembly(this.GetType()).Location);
Mock <IWinAPI> winApi = new Mock <IWinAPI>();
winApi.Setup(w => w.GetEslFileVersionInfo()).Returns(expected);
trackerFactory.Setup(tf => tf.GetService <IWinAPI>()).Returns(winApi.Object);
EditGameViewModel model = new EditGameViewModel(trackerFactory.Object);
GameOutcome param = GameOutcome.Victory;
model.UpdateGameData(param);
Assert.IsNotNull(model.Game.ESLVersion);
Assert.AreEqual(expected.ProductVersion, model.Game.ESLVersion.ToString());
}
public void UpdateGameData001_DateTimeWhenGameConcluded()
{
Mock <ISettings> settingsMock = new Mock <ISettings>();
DateTime timeConcluded = new DateTime(2016, 12, 12, 23, 45, 5);
Mock <ITrackerFactory> trackerFactory = new Mock <ITrackerFactory>();
trackerFactory.Setup(tf => tf.GetDateTimeNow()).Returns(timeConcluded);
trackerFactory.Setup(tf => tf.GetService <IMessenger>()).Returns(new Mock <IMessenger>().Object);
trackerFactory.Setup(tf => tf.GetService <IDeckService>()).Returns(new DeckService(trackerFactory.Object));
Mock <ITracker> tracker = new Mock <ITracker>();
tracker.Setup(t => t.Games).Returns(new ObservableCollection <DataModel.Game>());
tracker.Setup(t => t.ActiveDeck).Returns(Deck.CreateNewDeck(trackerFactory.Object));
trackerFactory.Setup(tf => tf.GetTracker()).Returns(tracker.Object);
Mock <IWinAPI> winApi = new Mock <IWinAPI>();
winApi.Setup(w => w.GetEslFileVersionInfo()).Returns <FileVersionInfo>(null);
trackerFactory.Setup(tf => tf.GetService <IWinAPI>()).Returns(winApi.Object);
EditGameViewModel model = new EditGameViewModel(trackerFactory.Object);
PopulateObject(model.Game, StartProp);
Assert.AreNotEqual(timeConcluded, model.Game.Date);
model.UpdateGameData(GameOutcome.Victory);
Assert.AreEqual(timeConcluded, model.Game.Date);
}
public void CommandButtonCreateExecuteTest003_ValidateRequiredFeilds()
{
Mock <ITrackerFactory> trackerFactory = new Mock <ITrackerFactory>();
Mock <IMessenger> messanger = new Mock <IMessenger>();
trackerFactory.Setup(tf => tf.GetService <IMessenger>()).Returns(messanger.Object);
Mock <ISettings> settings = new Mock <ISettings>();
trackerFactory.Setup(tf => tf.GetService <ISettings>()).Returns(settings.Object);
Mock <ITracker> tracker = new Mock <ITracker>();
tracker.Setup(t => t.Games).Returns(new ObservableCollection <DataModel.Game>());
tracker.Setup(t => t.ActiveDeck).Returns <Deck>(null);
trackerFactory.Setup(tf => tf.GetTracker()).Returns(tracker.Object);
EditGameViewModel model = new EditGameViewModel();
string param = "Victory";
model.CommandButtonCreateExecute(param);
Assert.IsNotNull(model.ErrorMessage);
messanger.Verify(m => m.Send(It.IsAny <object>()), Times.Never);
}
public IActionResult Edit(int ID)
{
Game gameToEdit = context.Games.Single(c => c.GameId == ID);
EditGameViewModel editGameViewModel = new EditGameViewModel(gameToEdit);
return(View(editGameViewModel));
}
public void ChangeActiveDeck001_AvailableGameTypesUpdated()
{
Mock <ITrackerFactory> trackerFactory = new Mock <ITrackerFactory>();
Deck activeDeck = Deck.CreateNewDeck(trackerFactory.Object);
activeDeck.Type = DeckType.SoloArena;
Mock <ITracker> tracker = new Mock <ITracker>();
tracker.Setup(t => t.ActiveDeck).Returns(activeDeck);
trackerFactory.Setup(tf => tf.GetTracker()).Returns(tracker.Object);
IMessenger messagnger = Messenger.Default;
trackerFactory.Setup(tf => tf.GetService <IMessenger>()).Returns(messagnger);
EditGameViewModel model = new EditGameViewModel(trackerFactory.Object);
model.ActiveDeckChanged(new ActiveDeckChanged(activeDeck));
Assert.AreEqual(1, model.AllowedGameTypes.Count());
Assert.AreEqual(GameType.SoloArena, model.AllowedGameTypes.First());
Assert.AreEqual(false, model.IsDirty());
}
public EditGameViewModel GetEditGame(int id)
{
Game game = this.Context.Games.Find(id);
EditGameViewModel model = Mapper.Map <EditGameViewModel>(game);
return(model);
}
public EditGameDialog(int?gameCopyId = null)
{
InitializeComponent();
var database = Application.Current.Database();
ViewModel = new EditGameViewModel(this, gameCopyId.HasValue ? GamesRepository.LoadGame(database, gameCopyId.Value) : new GameCopy());
Title = ViewModel.IsNew ? "Add Game" : $"Edit Game: {ViewModel.Title}";
}
public void Edit(EditGameViewModel viewModel)
{
Title = viewModel.Title;
PlatformId = viewModel.PlatformId;
Value = viewModel.Value;
Year = viewModel.Year;
Description = viewModel.Description;
ConditionId = viewModel.ConditionId;
DesignationId = viewModel.DesignationId;
}
public void SummaryText001_ChangeEventRaisedWhenNameChanges()
{
EditGameViewModel model = new EditGameViewModel();
bool raised = false;
model.PropertyChanged += delegate { raised = true; };
model.Game.OpponentName = "some name";
Assert.AreEqual(true, raised);
}
public async Task <IActionResult> Edit(EditGameViewModel editInput)
{
if (!this.ModelState.IsValid)
{
return(this.View(editInput));
}
await this.gamesService.EditGameAsync(editInput);
return(this.RedirectToAction(nameof(this.Index)));
}
public void SummaryText002_ChangeEventRaisedWhenOpponentClassChanges()
{
EditGameViewModel model = new EditGameViewModel();
bool raised = false;
model.PropertyChanged += delegate { raised = true; };
model.Game.OpponentClass = DeckClass.Endurance;
Assert.AreEqual(true, raised);
}
public IActionResult <EditGameViewModel> Edit(int gameId, HttpResponse response, HttpSession session)
{
if (!IsAuthenticatedAsAdmin(session))
{
Redirect(response, "/home/homepage");
return(null);
}
EditGameViewModel viewModel = service.GetEditViewModel(gameId);
return(View(viewModel));
}
public void CommandButtonCreateExecuteTest005_CheckIfESLFileVersionAddedWhenESLNOtRunning()
{
Mock <ITrackerFactory> trackerFactory = new Mock <ITrackerFactory>();
Mock <IMessenger> messanger = new Mock <IMessenger>();
trackerFactory.Setup(tf => tf.GetService <IMessenger>()).Returns(messanger.Object);
Mock <ISettings> settings = new Mock <ISettings>();
trackerFactory.Setup(tf => tf.GetService <ISettings>()).Returns(settings.Object);
FileVersionInfo expected = FileVersionInfo.GetVersionInfo(Assembly.GetAssembly(this.GetType()).Location);
Mock <ITracker> tracker = new Mock <ITracker>();
//add two games wit hdiff version - ensure correct is copied
tracker.Setup(t => t.Games).Returns(new ObservableCollection <DataModel.Game>()
{
new DataModel.Game()
{
Date = DateTime.Now, ESLVersion = new SerializableVersion(new Version(expected.ProductVersion.ToString()))
},
new DataModel.Game()
{
Date = DateTime.Now.AddDays(-7), ESLVersion = new SerializableVersion(2, 3)
},
new DataModel.Game()
{
Date = DateTime.Now, ESLVersion = null
},
});
tracker.Setup(t => t.ActiveDeck).Returns(new Deck(trackerFactory.Object));
trackerFactory.Setup(tf => tf.GetTracker()).Returns(tracker.Object);
Mock <IWinAPI> winApi = new Mock <IWinAPI>();
//ensure not running
winApi.Setup(w => w.GetEslFileVersionInfo()).Returns <FileVersionInfo>(null);
trackerFactory.Setup(tf => tf.GetService <IWinAPI>()).Returns(winApi.Object);
EditGameViewModel model = new EditGameViewModel(trackerFactory.Object);
GameOutcome param = GameOutcome.Victory;
model.UpdateGameData(param);
Assert.IsNotNull(model.Game.ESLVersion);
Assert.AreEqual(expected.ProductVersion, model.Game.ESLVersion.ToString());
}
public IActionResult Edit(Guid Id)
{
EditGameViewModel EditGameViewModel = new EditGameViewModel
{
Spots = SpotService.GetAllSpots(),
Rewards = RewardService.GetAllRewards(),
IntersectionGameSpots = IntersectionGameSpotService.GetAllIntersections(),
IntersectionGameRewards = IntersectionGameRewardService.GetAllIntersections(),
GameModel = GameService.GetGameFromGameId(Id)
};
return(View(EditGameViewModel));
}
public IActionResult Edit(EditGameViewModel editGameViewModel)
{
Game gameToEdit = context.Games.Single(g => g.GameId == editGameViewModel.GameID);
if (ModelState.IsValid)
{
gameToEdit.Edit(editGameViewModel);
context.SaveChanges();
return(Redirect("/List"));
}
return(View(editGameViewModel));
}
// HttpPost Edit Method
public async Task <int> EditGameAsync(EditGameViewModel editInputModel)
{
var game = await GetGameByIdAsync(editInputModel.Id);
game.DateAndStartTime = editInputModel.DateAndStartTime;
game.StadiumLocationUrl = editInputModel.StadiumLocationUrl;
game.Format = editInputModel.Format;
game.HomeTeamScore = editInputModel.HomeTeamScore;
game.AwayTeamScore = editInputModel.AwayTeamScore;
this.database.Games.Update(game);
await this.database.SaveChangesAsync();
return(game.Id);
}
public IActionResult EditGame(int id)
{
Game game = _db.Games.Find(id);
if (game == null)
{
return(NotFound());
}
EditGameViewModel model = new EditGameViewModel {
Name = game.Name, Genre = game.Genre, Publisher = game.Publisher, Price = game.Price
};
return(View(model));
}
// HttpGet Edit Method
public async Task <EditGameViewModel> EditGameViewAsync(int id)
{
var gameToEdit = await GetGameByIdAsync(id);
var editGameInput = new EditGameViewModel
{
Id = gameToEdit.Id,
DateAndStartTime = gameToEdit.DateAndStartTime,
StadiumLocationUrl = gameToEdit.StadiumLocationUrl,
Format = gameToEdit.Format,
HomeTeamScore = gameToEdit.HomeTeamScore,
AwayTeamScore = gameToEdit.AwayTeamScore,
};
return(editGameInput);
}
public EditGameViewModel GetGameById(int gameId)
{
var game = this.games.GetById(gameId);
var gameVm = new EditGameViewModel()
{
Size = game.Size,
Price = game.Price,
Description = game.Description,
Title = game.Title,
Trailer = game.Trailer,
ReleaseDate = game.ReleaseDate,
Id = game.Id,
ImageThumbnail = game.ImageThumbnail
};
return(gameVm);
}
public ActionResult EditWithCustomImage(EditGameViewModel model, HttpPostedFileBase imageFile)
{
if (!ModelState.IsValid)
{
return(Edit(model.Id));
}
var game = mapper.Map <EditGameViewModel, Game>(model);
DeleteImage(game.Id);
game.Image = ImageHelper.SaveImage(Server, imageFile);
gameService.UpdateGame(game);
return(RedirectToAction(nameof(Index)));
}
public IActionResult EditGame(EditGameViewModel model)
{
Game game = _db.Games.Find(model.Id);
if (ModelState.IsValid)
{
if (game != null)
{
game.Name = model.Name;
game.Genre = model.Genre;
game.Publisher = model.Publisher;
game.Price = model.Price;
_db.SaveChanges();
}
}
return(RedirectToAction("Index", "Home"));
}
public async Task <ActionResult> EditGame(EditGameViewModel model, HttpPostedFileBase image = null)
{
if (ModelState.IsValid)
{
var game = _gameService.GetGame(model.Id);
if (game != null)
{
game.Name = model.Name;
game.Value = model.Value;
game.Rank = model.Rank;
if (image != null && (image.ContentType == "image/jpeg" || image.ContentType == "image/png"))
{
string extName = System.IO.Path.GetExtension(image.FileName);
string fileName = $@"{Guid.NewGuid()}{extName}";
// сохраняем файл в папку Files в проекте
string fullPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory + "\\Content\\Images\\GameIcons", fileName);
string urlPath = Url.Content("~/Content/Images/GameIcons/" + fileName);
image.SaveAs(fullPath);
Tinify.Key = ConfigurationManager.AppSettings["TINYPNG_APIKEY"];
try
{
using (var s = Tinify.FromFile(fullPath))
{
var resized = s.Resize(new
{
method = "fit",
width = 40,
height = 40
});
await resized.ToFile(fullPath);
}
}
catch (System.Exception)
{
// ignored
}
game.ImagePath = urlPath;
}
_gameService.SaveGame();
return(RedirectToAction("GameList"));
}
}
return(HttpNotFound());
}
public void CommandButtonCreateExecuteTest001_SaveSettingForCurrentPlayerRank()
{
Mock <ITrackerFactory> trackerFactory = new Mock <ITrackerFactory>();
Mock <IMessenger> messanger = new Mock <IMessenger>();
trackerFactory.Setup(tf => tf.GetService <IMessenger>()).Returns(messanger.Object);
trackerFactory.Setup(tf => tf.GetService <IDeckService>()).Returns(new DeckService(trackerFactory.Object));
Mock <ISettings> settings = new Mock <ISettings>();
trackerFactory.Setup(tf => tf.GetService <ISettings>()).Returns(settings.Object);
Mock <ITracker> tracker = new Mock <ITracker>();
tracker.Setup(t => t.Games).Returns(new ObservableCollection <DataModel.Game>());
tracker.Setup(t => t.ActiveDeck).Returns(new Deck(trackerFactory.Object));
trackerFactory.Setup(tf => tf.GetTracker()).Returns(tracker.Object);
Mock <IWinAPI> winApi = new Mock <IWinAPI>();
winApi.Setup(w => w.GetEslFileVersionInfo()).Returns <FileVersionInfo>(null);
trackerFactory.Setup(tf => tf.GetService <IWinAPI>()).Returns(winApi.Object);
Mock <IFileManager> fileManager = new Mock <IFileManager>();
trackerFactory.Setup(tf => tf.GetFileManager()).Returns(fileManager.Object);
EditGameViewModel model = new EditGameViewModel(trackerFactory.Object);
PlayerRank selectedPlayerRank = PlayerRank.TheLord;
model.Game.Type = GameType.PlayRanked;
model.Game.OpponentClass = DeckClass.Crusader;
model.Game.PlayerRank = selectedPlayerRank;
object param = "Victory";
model.CommandButtonCreateExecute(param);
settings.VerifySet(s => s.PlayerRank = selectedPlayerRank, Times.Once);
}
public IActionResult <EditGameViewModel> Edit(HttpSession session, HttpResponse response, int id)
{
if (!AuthenticationManager.IsAuthenticated(session.Id))
{
this.Redirect(response, "/users/register");
return(null);
}
User activeUser = AuthenticationManager.GetAuthenticatedUser(session.Id);
if (!activeUser.IsAdmin)
{
this.Redirect(response, "/home/index");
return(null);
}
EditGameViewModel viewModel = this.service.GetEditGameViewModel(id);
return(this.View(viewModel));
}
public ActionResult EditGame(int id)
{
//Get current users email
string email = User.Identity.GetUserName();
//Find user by their email
Contact currContact = _contactService.GetContactByEmail(email);
//Find Game
Game game = _gameService.GetGameById(id);
//Populate dropdown using the current values of the existing game
PopulateEditDropDownMethod(game);
//check if the user is the creator of the game
if (!_gameService.IsCreatorOfGame(currContact.ContactId, game))
{
return(RedirectToAction("GameDetails", new { id = id }));
}
Debug.Write(game);
//Convert the strings so it matches
string dateRange = game.StartTime.ToString("MM/dd/yyyy hh:mm tt") + " - " + game.EndTime.ToString("MM/dd/yyyy hh:mm tt");
////Create own View Model
EditGameViewModel model = new EditGameViewModel()
{
GameId = id,
ContactId = (int)game.ContactId,
VenueId = game.VenueId,
SportId = game.SportId,
Sport = _gameService.GetSportNameById(game.SportId),
Venue = _venueService.GetVenueNameById(game.VenueId),
Status = Enum.GetName(typeof(GameStatusEnum), game.GameStatusId),
DateRange = dateRange,
};
//pass it back
return(View(model));
}
public async Task <IActionResult> Edit(EditGameViewModel model)
{
if (!ModelState.IsValid)
{
model.Genres = _context.Genres;
model.Developers = _context.Developers;
return(View(model));
}
try
{
var game = await _context.Games
.SingleOrDefaultAsync(m => m.GameId == model.GameId);
game.Genre = await _context.Genres
.SingleOrDefaultAsync(c => c.GenreId == model.GenreId);
game.Developer = await _context.Developers
.SingleOrDefaultAsync(c => c.DeveloperId == model.DeveloperId);
game.PEGI = model.PEGI;
game.Title = model.Title;
game.Description = model.Description;
game.Price = model.Price;
_context.Update(game);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!GameExists(model.GameId))
{
return(View("NotFound"));
}
throw;
}
return(RedirectToAction(nameof(Index)));
}
public void IEditableObjectImplementation001_CancelEdit()
{
Mock <IDeckClassSelectorViewModel> deckClassSelector = new Mock <IDeckClassSelectorViewModel>();
EditGameViewModel model = new EditGameViewModel();
DataModel.Game game = new DataModel.Game();
model.Game = game;
model.Game.ClearEventInvocations("PropertyChanged");
PopulateObject(game, StartProp);
TestContext.WriteLine("Begin Edit");
model.BeginEdit();
PopulateObject(game, EditProp);
TestContext.WriteLine("Cancel Edit");
model.CancelEdit();
foreach (PropertyInfo p in game.GetType().GetProperties())
{
if (p.CanWrite)
{
if (p.Name == "DeckId")
{
//deck id is handled different way, depends on Deck
DataModel.Deck staringDeck = (DataModel.Deck)StartProp[typeof(DataModel.Deck)];
Assert.AreEqual(staringDeck.DeckId, p.GetValue(game), "Failed validation of prop {0} of type {1}", p.Name, p.PropertyType);
}
else
{
Assert.AreEqual(StartProp[p.PropertyType], p.GetValue(game), "Failed validation of prop {0} of type {1}", p.Name, p.PropertyType);
}
}
}
}
private static void UpdateGame(GameCopy game, EditGameViewModel editGameViewModel)
{
game.Title = editGameViewModel.Title ?? "";
game.Sealed = editGameViewModel.GameSealed;
game.MobyGamesSlug = editGameViewModel.GameMobyGamesSlug ?? "";
game.Platforms = editGameViewModel.GamePlatforms.Distinct().ToList();
if (editGameViewModel.GamePublisher.IsNew ||
editGameViewModel.GamePublisher.PublisherId != game.PublisherId)
{
game.Publisher = editGameViewModel.GamePublisher;
}
game.Links = editGameViewModel.GameLinks.Distinct().ToList();
game.Notes = editGameViewModel.GameNotes;
game.TwoLetterIsoLanguageName =
editGameViewModel.GameLanguages.Select(ci => ci.TwoLetterISOLanguageName).Distinct().ToList();
game.ReleaseDate = editGameViewModel.GameReleaseDate;
UpdateGameCopyDevelopers(game.GameCopyDevelopers, editGameViewModel.GameDevelopers);
UpdateGameItems(game.Items, editGameViewModel.GameItems);
}
private void OnPropertyChanged(object sender, PropertyChangedEventArgs args)
{
var not = IsNotifying;
if (!PauseNotify.IsPaused(this))
{
switch (args.PropertyName)
{
case "SelectedGame":
if (SelectedGame != null)
{
EditGameViewModel.Load(SelectedGame);
}
break;
case "SelectedArenaSession":
if (SelectedArenaSession != null)
{
ArenaViewModel.Load(SelectedArenaSession);
EditGameViewModel.IsOpen = false;
}
else
{
ArenaViewModel.IsOpen = false;
}
break;
case "FilterServer":
case "FilterHero":
case "FilterFromDate":
case "FilterToDate":
RefreshData();
break;
}
}
}
