public Scores()
{
this.InitializeComponent();
_viewModel = new ScoresViewModel();
this.DataContext = _viewModel;
}
public async Task ViewModel_ScoresViewModel_UpdateData_Bogus_Should_Skip()
{
MockForms.Init();
// Get State of the DataStore, and set to run on the Mock
var myDataStoreEnum = MasterDataStore.GetDataStoreMockFlag();
MasterDataStore.ToggleDataStore(DataStoreEnum.Mock);
var myViewModel = new ScoresViewModel();
myViewModel.ForceDataRefresh();
var myData = DefaultModels.ScoreDefault();
// Make the ID bogus...
var value = "new";
myData.Id = value;
var myReturn = await myViewModel.UpdateAsync(myData);
var Actual = myReturn;
bool Expected = false;
// Return state
MasterDataStore.ToggleDataStore(myDataStoreEnum);
myViewModel.ForceDataRefresh();
// Validate the controller can stand up and has a Title
Assert.AreEqual(Expected, Actual, TestContext.CurrentContext.Test.Name);
}
public void UpdateScore(ScoresViewModel model)
{
Scores score = _mapper.Map <Scores>(model);
_universityUnitOfWork._scoreRepository.Update(score);
_universityUnitOfWork.Save();
}
public async Task ViewModel_MessageCenter_ScoresViewModel_MessageCenter_DeleteData_Should_Pass()
{
MockForms.Init();
// Get State of the DataStore, and set to run on the Mock
var myDataStoreEnum = MasterDataStore.GetDataStoreMockFlag();
MasterDataStore.ToggleDataStore(DataStoreEnum.Mock);
var myViewModel = new ScoresViewModel();
var myData = DefaultModels.ScoreDefault();
await myViewModel.AddAsync(myData);
var myPage = new ScoreDeletePage(new ScoreDetailViewModel(new Score()));
MessagingCenter.Send(myPage, "DeleteData", myData);
var Actual = await myViewModel.GetAsync(myData.Id);
Object Expected = null;
// Return state
MasterDataStore.ToggleDataStore(myDataStoreEnum);
// Validate the controller can stand up and has a Title
Assert.AreEqual(Expected, Actual, TestContext.CurrentContext.Test.Name);
}
public IActionResult Edit(int Id, ScoresViewModel model)
{
if (Id != model.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_universityService.UpdateScore(model);
}
catch (DbUpdateConcurrencyException)
{
if (!_universityService.ScoreExists(model.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewBag.LstStudent = _universityService.GetUsersBy_Role("ALUMNO");
ViewBag.LstCourses = _universityService.GetCourses();
return(View(model));
}
public void ViewModel_ScoresViewModel_LoadDataCommand_With_IsBusy_Should_Skip()
{
MockForms.Init();
var myData = new ScoresViewModel();
var myIsBusy = myData.IsBusy;
myData.ForceDataRefresh();
myData.Dataset.Clear();
myData.IsBusy = true;
var canExecute = myData.LoadDataCommand.CanExecute(null);
myData.LoadDataCommand.Execute(null);
var Actual = myData.Dataset.Count();
var Expected = 0;
// set it back...
myData.IsBusy = myIsBusy;
//Reset
myData.ForceDataRefresh();
// Validate the controller can stand up and has a Title
Assert.AreEqual(Expected, Actual, TestContext.CurrentContext.Test.Name);
}
public ActionResult <object> Post([FromBody] ScoresViewModel user)
{
if (user == null)
{
var toSerialize = new MessageHelpers <ScoresViewModel>()
{
Status = 404,
Data = null
};
return(JsonConvert.SerializeObject(toSerialize));
}
else
{
try
{
var id = _scoresServiceAsync.Add(user);
var toSerialize = new MessageHelpers <ScoresViewModel>()
{
Status = 200,
Data = null
};
return(JsonConvert.SerializeObject(toSerialize));
}
catch
{
var toSerialize = new MessageHelpers <ScoresViewModel>()
{
Status = 502,
Data = null
};
return(JsonConvert.SerializeObject(toSerialize));
}
}
}
public async Task ViewModel_ScoresViewModel_UpdateData_Should_Pass()
{
MockForms.Init();
// Get State of the DataStore, and set to run on the Mock
var myDataStoreEnum = MasterDataStore.GetDataStoreMockFlag();
MasterDataStore.ToggleDataStore(DataStoreEnum.Mock);
var myViewModel = new ScoresViewModel();
var myData = DefaultModels.ScoreDefault();
await myViewModel.AddAsync(myData);
var value = "new";
myData.Name = value;
var myReturn = myViewModel.UpdateAsync(myData);
var Actual = await myViewModel.GetAsync(myData.Id);
string Expected = value;
// Return state
MasterDataStore.ToggleDataStore(myDataStoreEnum);
// Validate the controller can stand up and has a Title
Assert.AreEqual(Expected, Actual.Name, TestContext.CurrentContext.Test.Name);
}
public IActionResult ScoreTable()
{
var Model = new ScoresViewModel {
Players = _playerData.GetTopPlayersScore()
};
return(View(Model));
}
public void Constructor_ShouldLoadEnabledTeams()
{
//Act
var sut = new ScoresViewModel(_teamServiceMock.Object, _navigationServiceExMock.Object);
//Assert
Assert.Equal(_enabledTeams, sut.Teams);
_teamServiceMock.Verify(tS => tS.GetAllTeams(), Times.Once);
}
private void openScoresWindow()
{
scoresViewModel = new ScoresViewModel();
ScoresWindow scoresWindow = new ScoresWindow()
{
DataContext = scoresViewModel
};
scoresWindow.Show();
}
public void ViewModel_ScoresViewModel_Instantiate_Should_Pass()
{
MockForms.Init();
var Actual = new ScoresViewModel();
// Validate the controller can stand up and has a Title
Assert.AreEqual("Score List", Actual.Title, TestContext.CurrentContext.Test.Name);
}
public ActionResult ScoresUpdate([DataSourceRequest]DataSourceRequest request, ScoresViewModel score)
{
if (this.ModelState.IsValid)
{
var entity = this.Mapper.Map<ScoreReport>(score);
this.scores.Update(entity);
}
return this.Json(new[] { score }.ToDataSourceResult(request, this.ModelState));
}
public IActionResult Index()
{
var viewModel = new ScoresViewModel
{
UserScores = _db.UserScores.ToList(),
Quizzes = _db.Quiz.ToList(),
Students = _db.Students.ToList()
};
return(View(viewModel));
}
public void ViewModel_ScoresViewModel_DataSet_Should_Be_Valid()
{
MockForms.Init();
var myData = new ScoresViewModel();
var myLoad = myData.LoadDataCommand;
var Actual = myData.Dataset;
var Expected = myData.Dataset;
// Validate the controller can stand up and has a Title
Assert.AreEqual(Expected, Actual, TestContext.CurrentContext.Test.Name);
}
public void ViewModel_ScoresViewModel_SetNeedsRefresh_True_Should_Be_True()
{
MockForms.Init();
var myData = new ScoresViewModel();
myData.SetNeedsRefresh(true);
var Actual = myData.NeedsRefresh();
var Expected = true;
// Validate the controller can stand up and has a Title
Assert.AreEqual(Expected, Actual, TestContext.CurrentContext.Test.Name);
}
public ActionResult Edit(ScoresViewModel model)
{
if (this.ModelState.IsValid)
{
var studentId = this.User.Identity.GetUserId();
var scoresReport = this.Mapper.Map<ScoreReport>(model);
scoresReport.StudentInfoId = studentId;
this.scores.Update(scoresReport);
return this.RedirectToAction(nameof(this.Review));
}
return this.View(model);
}
public async Task <ActionResult <object> > PutAsync(int id, [FromBody] ScoresViewModel user)
{
if (user == null || user.Id != id)
{
var toSerialize = new MessageHelpers <ScoresViewModel>()
{
Status = 404,
Data = null
};
return(JsonConvert.SerializeObject(toSerialize));
}
else
{
try
{
int retVal = await _scoresServiceAsync.Update(user);
if (retVal == 0 && retVal > 0)
{
var toSerialize = new MessageHelpers <ScoresViewModel>()
{
Status = 200,
Data = null
};
return(JsonConvert.SerializeObject(toSerialize));
}
else
{
var toSerialize = new MessageHelpers <ScoresViewModel>()
{
Status = 404,
Data = null
};
return(JsonConvert.SerializeObject(toSerialize));
}
}
catch
{
var toSerialize = new MessageHelpers <ScoresViewModel>()
{
Status = 502,
Data = null
};
return(JsonConvert.SerializeObject(toSerialize));
}
}
}
public void ViewModel_ScoresViewModel_LoadDataCommand_Should_Pass()
{
MockForms.Init();
var myData = new ScoresViewModel();
myData.ForceDataRefresh();
var Actual = myData.Dataset.Count();
var Expected = myData.DataStore.GetAllAsync_Score().GetAwaiter().GetResult().Count();
//Reset
myData.ForceDataRefresh();
// Validate the controller can stand up and has a Title
Assert.AreEqual(Expected, Actual, TestContext.CurrentContext.Test.Name);
}
public ActionResult PostScore(ScoresViewModel vm)
{
if (ModelState.IsValid)
{
vm.Scorekey = 9;
scoresRepository.Add(vm.Score.Where(m => m.ScoreID.Equals(2)).ToList());
return(View("Scores", new ScoresViewModel
{
Score = scoresRepository.GetAllScores()
}));
//ViewBag.ErrorMessage = string.Empty;
}
else
{
ViewBag.ErrorMessage = "Could not store Score into database";
}
return(RedirectToAction("Scores"));//attempts to return to message index view
}
public IActionResult Edit(int?Id)
{
if (Id == null)
{
return(NotFound());
}
ScoresViewModel model = _universityService.GetScore(Id.Value);
if (model == null)
{
return(NotFound());
}
ViewBag.LstStudent = _universityService.GetUsersBy_Role("ALUMNO");
ViewBag.LstCourses = _universityService.GetCourses();
return(View(model));
}
public void ViewModel_ScoresViewModel_LoadCommand_With_Bogus_DataSource_Should_Throw_Skip()
{
MockForms.Init();
var myData = new ScoresViewModel();
var myIsBusy = myData.IsBusy;
// Make the data store null, this will fire the Exception, which then skips...
myData.DataStore = null;
var Actual = myData.Dataset.Count();
var Expected = 0;
//Reset
myData.ForceDataRefresh();
// Validate the controller can stand up and has a Title
Assert.AreEqual(Expected, Actual, TestContext.CurrentContext.Test.Name);
}
public IActionResult Create(ScoresViewModel model)
{
try
{
if (ModelState.IsValid)
{
_universityService.InsertScore(model);
return(RedirectToAction(nameof(Index)));
}
ViewBag.LstStudent = _universityService.GetUsersBy_Role("ALUMNO");
ViewBag.LstCourses = _universityService.GetCourses();
return(View(model));
}
catch (Exception ex)
{
throw;
}
}
public ActionResult HistoryScores(int tournamentId)
{
var viewModel = new ScoresViewModel();
var historyScoresViewModel = new List <PhaseScoresViewModel>();
var dbHistoryScores = _scoreManager.HistoryScores
.Where(x => x.TournamentId == tournamentId)
.OrderByDescending(x => x.TotalScore)
.GroupBy(x => x.PhaseId)
.ToList();
foreach (var phase in dbHistoryScores)
{
var historyPhase = new PhaseScoresViewModel();
var personalScoresList = new List <PersonScoreViewModel>();
foreach (var personalScore in phase)
{
var person = new PersonScoreViewModel
{
FirstName = personalScore.User.FirstName,
LastName = personalScore.User.LastName,
Score = personalScore.TotalScore
};
personalScoresList.Add(person);
}
historyPhase.Scores = personalScoresList;
historyScoresViewModel.Add(historyPhase);
}
viewModel.HistoryPhases = historyScoresViewModel;
return(View(viewModel));
}
public ScoresPage()
{
InitializeComponent();
BindingContext = _viewModel = ScoresViewModel.Instance;
}
public ActionResult ScoresDestroy([DataSourceRequest]DataSourceRequest request, ScoresViewModel score)
{
this.scores.Delete(score.StudentInfoId);
return this.Json(new[] { score }.ToDataSourceResult(request, this.ModelState));
}
public ScorePage()
{
InitializeComponent();
// Set the data binding for the page
BindingContext = _viewModel = ScoresViewModel.Instance;
}
