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