public async Task Unique(string teamName, long teamId, bool expected) { var team = new TeamEntity { Name = teamName, Id = teamId }; _tenantContext.TournamentContext.TeamRuleSet = new TeamRules { HomeMatchTime = new HomeMatchTime { } }; var tv = new TeamValidator(team, _tenantContext); var factResult = await tv.CheckAsync(TeamValidator.FactId.TeamNameIsUnique, CancellationToken.None); Assert.Multiple(() => { Assert.AreEqual(factResult.Enabled, teamName != null); Assert.AreEqual(expected, factResult.Success); if (factResult.Enabled && !factResult.Success) { Assert.IsTrue(factResult.Message.Contains(teamName ?? string.Empty)); } Assert.IsNull(factResult.Exception); }); }
public async Task DayOfWeek_Must_Be_In_Range(DayOfWeek?dayOfWeek, bool errorIfNotInRange, bool expected) { var team = new TeamEntity { MatchDayOfWeek = dayOfWeek.HasValue ? (int)dayOfWeek : default(int?) }; _tenantContext.TournamentContext.TeamRuleSet = new TeamRules { HomeMatchTime = new HomeMatchTime { IsEditable = true, MustBeSet = true, ErrorIfNotInDaysOfWeekRange = errorIfNotInRange, DaysOfWeekRange = new List <DayOfWeek> { DayOfWeek.Monday, DayOfWeek.Tuesday } } }; var tv = new TeamValidator(team, _tenantContext); var factResult = await tv.CheckAsync(TeamValidator.FactId.DayOfWeekWithinRange, CancellationToken.None); Assert.Multiple(() => { Assert.AreEqual(factResult.Enabled, _tenantContext.TournamentContext.TeamRuleSet.HomeMatchTime.IsEditable && _tenantContext.TournamentContext.TeamRuleSet.HomeMatchTime.MustBeSet); if (factResult.Enabled) { Assert.IsTrue(errorIfNotInRange ? factResult.Type == FactType.Error : factResult.Type == FactType.Warning); Assert.AreEqual(expected, factResult.Success); } Assert.IsNull(factResult.Exception); }); }
public async Task MatchTime_Within_Fixture_TimeLimit(TimeSpan startTime, bool startTimeMustBeSet, bool expected) { // Note: all times are set and compared to local time var team = new TeamEntity(); _tenantContext.TournamentContext.TeamRuleSet = new TeamRules { HomeMatchTime = new HomeMatchTime { IsEditable = true, MustBeSet = startTimeMustBeSet } }; _tenantContext.TournamentContext.FixtureRuleSet = new FixtureRuleSet { RegularMatchStartTime = new RegularMatchStartTime { MinDayTime = new TimeSpan(19, 0, 0), MaxDayTime = new TimeSpan(21, 0, 0) } }; var tv = new TeamValidator(team, _tenantContext); team.MatchTime = startTime; var factResult = await tv.CheckAsync(TeamValidator.FactId.MatchTimeWithinRange, CancellationToken.None); Assert.Multiple(() => { Assert.AreEqual(expected, factResult.IsChecked == startTimeMustBeSet && factResult.Success && factResult.Message.Contains(_tenantContext.TournamentContext.FixtureRuleSet .RegularMatchStartTime.MinDayTime.ToShortTimeString())); Assert.IsNull(factResult.Exception); }); }
public async Task DayOfWeek_Must_Be_Set(DayOfWeek?dayOfWeek, bool isEditable, bool mustBeSet, bool expected) { var team = new TeamEntity { MatchDayOfWeek = dayOfWeek.HasValue ? (int)dayOfWeek : default(int?), MatchTime = new TimeSpan(18, 0, 0) }; _tenantContext.TournamentContext.TeamRuleSet = new TeamRules { HomeMatchTime = new HomeMatchTime { IsEditable = isEditable, MustBeSet = mustBeSet, } }; var tv = new TeamValidator(team, _tenantContext); var factResult = await tv.CheckAsync(TeamValidator.FactId.DayOfWeekWithinRange, CancellationToken.None); Assert.Multiple(() => { Assert.AreEqual(factResult.Enabled, isEditable && mustBeSet); if (factResult.Enabled) { Assert.AreEqual(expected, factResult.Success); } Assert.IsNull(factResult.Exception); }); }
public async Task MatchTime_Must_Be_Set(TimeSpan?matchTime, bool isEditable, bool mustBeSet, bool expected) { var team = new TeamEntity { MatchTime = matchTime, MatchDayOfWeek = 1 }; _tenantContext.TournamentContext.TeamRuleSet = new TeamRules { HomeMatchTime = new HomeMatchTime { IsEditable = isEditable, MustBeSet = mustBeSet } }; var tv = new TeamValidator(team, _tenantContext); var factResult = await tv.CheckAsync(TeamValidator.FactId.MatchDayOfWeekAndTimeIsSet, CancellationToken.None); Assert.Multiple(() => { Assert.AreEqual(factResult.Enabled, isEditable && mustBeSet); if (factResult.Enabled) { Assert.AreEqual(matchTime.HasValue, factResult.Success); } Assert.IsNull(factResult.Exception); }); }
private void CreateTeamButton_Click(object sender, EventArgs e) { TeamModel T = new TeamModel(); T.TeamName = TeameNameTextBox.Text; T.TeamMembers = selectedTeamMembers; TeamValidator TeamValidator = new TeamValidator(); var result = TeamValidator.Validate(T); string message = ""; if (!result.IsValid) { foreach (ValidationFailure res in result.Errors) { message += $"{res}\n"; } MessageBox.Show(message, "error", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } GlobalConfig.Connaction.CreateTeam(T); callingForm.TeamComplete(T); this.Close(); }
private void setTeam(object sender, AdapterView.ItemSelectedEventArgs e) { DisableCreateMatchButtonIf(); if (e.Position != 1) { return; } var inputDialog = new AlertDialog.Builder(this.Activity); EditText userInput = new EditText(Activity); userInput.InputType = InputTypes.ClassText; inputDialog.SetTitle("Add New Team:"); inputDialog.SetView(userInput); inputDialog.SetPositiveButton( "Ok", (senderAlert, args) => { var teamValid = new TeamValidator(Access.TeamService.GetTeams()).Validate(userInput.Text); if (teamValid.Any()) { Toast.MakeText(this.Activity, string.Join(System.Environment.NewLine, teamValid.ToArray()), ToastLength.Long).Show(); return; } else { var teamId = Access.TeamService.AddTeam(userInput.Text); mTeams.Add(Access.TeamService.GetTeam(teamId).Name); var adapter = new SpinnerAdapter(this.Activity, Resource.Layout.Row, mTeams.ToArray()); if (Resource.Id.homeTeam == e.Parent.Id) { mHomeTeamName.Adapter = adapter; mHomeTeamName.SetSelection(mTeams.Count - 1); } else { mAwayTeamName.Adapter = adapter; mAwayTeamName.SetSelection(mTeams.Count - 1); } } }); inputDialog.SetNegativeButton("Dismiss", (senderAlert, args) => { if (Resource.Id.homeTeam == e.Parent.Id) { mHomeTeamName.SetSelection(0); } else { mAwayTeamName.SetSelection(0); } }); inputDialog.Show(); }
public static void ValidateTeam(Team team) { var validator = new TeamValidator(); var result = validator.Validate(team); if (result.IsValid) { return; } throw new ValidationException(result.Errors); }
public Response <TeamDTO> Update(TeamDTO teamDTO) { try { TeamValidator validator = new TeamValidator(); ValidationResult results = validator.Validate(teamDTO); if (results.IsValid) { var team = TeamMapper.MapTeamDTOToTeamModel(teamDTO); var teamEntity = _repository.Update(team); _repository.SaveChanges(); var teamEntityDTO = TeamMapper.MapTeamModelToTeamDTO(teamEntity); var response = new Response <TeamDTO> { DTO = teamEntityDTO }; return(response); } else { return(new Response <TeamDTO> { Errors = results.Errors.Select(x => new Error { Type = ErrorType.ValidationError, Message = x.ErrorMessage }).ToList() }); } } catch (Exception ex) { return(new Response <TeamDTO> { Errors = new List <Error>() { new Error { Type = ErrorType.Exception, Message = ex.Message } } }); } }
public async Task TeamName_Must_Not_Be_Empty(string teamName, bool expected) { var team = new TeamEntity { Name = teamName }; _tenantContext.TournamentContext.TeamRuleSet = new TeamRules { HomeMatchTime = new HomeMatchTime { } }; var tv = new TeamValidator(team, _tenantContext); var factResult = await tv.CheckAsync(TeamValidator.FactId.TeamNameIsSet, CancellationToken.None); Assert.Multiple(() => { Assert.IsTrue(factResult.Enabled); Assert.AreEqual(expected, factResult.Success); Assert.IsNull(factResult.Exception); }); }
public async Task <bool> ValidateAsync(TeamValidator teamValidator, long tournamentId, ModelStateDictionary modelState, CancellationToken cancellationToken) { if (Round.ShowSelector && Round.SelectedRoundId.HasValue) { var tirValidator = new TeamInRoundValidator( new TeamInRoundEntity { RoundId = Round.SelectedRoundId.Value, TeamId = teamValidator.Model.Id }, (teamValidator.Data, tournamentId)); await tirValidator.CheckAsync(cancellationToken); foreach (var fact in tirValidator.GetFailedFacts()) { // validator currently only has one rule if (fact.Id == TeamInRoundValidator.FactId.RoundBelongsToTournament) { modelState.AddModelError(string.Join('.', Round.HtmlFieldPrefix, nameof(Round.SelectedRoundId)), fact.Message); } } } await teamValidator.CheckAsync(cancellationToken); foreach (var fact in teamValidator.GetFailedFacts()) { if (fact.Exception != null) { throw new Exception(null, fact.Exception); } if (fact.Type == FactType.Critical || fact.Type == FactType.Error) { foreach (var fieldName in fact.FieldNames) { modelState.AddModelError(string.Join('.', Team.HtmlFieldPrefix, fieldName), fact.Message); } } else { modelState.AddModelError(string.Empty, fact.Message); // Validator generates FactType.Warning only, if no errors exist IsWarning = true; } } // The Hash is re-calculated with the new submitted values. // We have to compare to the original hidden Hash field value, // because to override warnings, form fields must be unchanged since last post var newHash = ComputeInputHash(); if (IsWarning && OverrideWarnings && newHash == Hash) { modelState.Clear(); IsWarning = false; } if (!modelState.IsValid) { // Show checkbox unchecked OverrideWarnings = false; // Set hash field value to latest form fields content Hash = newHash; } return(modelState.IsValid); }
public TeamTests() { _teamValidator = new TeamValidator(); }
public TeamService(TeamValidator v, TeamRepository repository) { this.repository = repository; this.validator = v; }
public static IDictionary <string, IEnumerable <string> > ValidateTeam(Team team) { var validator = new TeamValidator(); return(validator.ValidateEntity(team)); }