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));
}
