public async override Task <ActionResult> Index(ContentModel contentModel)
{
if (contentModel is null)
{
throw new ArgumentNullException(nameof(contentModel));
}
var team = await _teamDataSource.ReadTeamByRoute(Request.RawUrl, true).ConfigureAwait(false);
if (team == null)
{
return(new HttpNotFoundResult());
}
else
{
var filter = _matchFilterFactory.MatchesForTeams(new List <Guid> {
team.TeamId.Value
});
var model = new TeamViewModel(contentModel.Content, Services?.UserService)
{
Team = team,
DefaultMatchFilter = filter.filter,
Matches = new MatchListingViewModel(contentModel.Content, Services?.UserService)
{
DateTimeFormatter = _dateFormatter
},
};
model.AppliedMatchFilter = _matchFilterQueryStringParser.ParseQueryString(model.DefaultMatchFilter, HttpUtility.ParseQueryString(Request.Url.Query));
model.Matches.Matches = await _matchDataSource.ReadMatchListings(model.AppliedMatchFilter, filter.sortOrder).ConfigureAwait(false);
model.IsAuthorized = _authorizationPolicy.IsAuthorized(model.Team);
model.IsInACurrentLeague = _createMatchSeasonSelector.SelectPossibleSeasons(model.Team.Seasons, MatchType.LeagueMatch).Any();
model.IsInACurrentKnockoutCompetition = _createMatchSeasonSelector.SelectPossibleSeasons(model.Team.Seasons, MatchType.KnockoutMatch).Any();
var userFilter = _matchFilterHumanizer.MatchingFilter(model.AppliedMatchFilter);
if (!string.IsNullOrWhiteSpace(userFilter))
{
model.FilterDescription = _matchFilterHumanizer.MatchesAndTournaments(model.AppliedMatchFilter) + userFilter;
}
model.Metadata.PageTitle = $"{_matchFilterHumanizer.MatchesAndTournaments(model.AppliedMatchFilter)} for {model.Team.TeamName} stoolball team{userFilter}";
model.Breadcrumbs.Add(new Breadcrumb {
Name = Constants.Pages.Teams, Url = new Uri(Constants.Pages.TeamsUrl, UriKind.Relative)
});
if (model.Team.Club != null)
{
model.Breadcrumbs.Add(new Breadcrumb {
Name = model.Team.Club.ClubName, Url = new Uri(model.Team.Club.ClubRoute, UriKind.Relative)
});
}
return(CurrentTemplate(model));
}
}
public async override Task <ActionResult> Index(ContentModel contentModel)
{
if (contentModel is null)
{
throw new ArgumentNullException(nameof(contentModel));
}
var model = new EditTrainingSessionViewModel(contentModel.Content, Services?.UserService)
{
Match = new Match
{
MatchType = MatchType.TrainingSession,
MatchLocation = new MatchLocation()
}
};
if (Request.RawUrl.StartsWith("/teams/", StringComparison.OrdinalIgnoreCase))
{
model.Team = await _teamDataSource.ReadTeamByRoute(Request.RawUrl, true).ConfigureAwait(false);
if (model.Team == null)
{
return(new HttpNotFoundResult());
}
var possibleSeasons = _createMatchSeasonSelector.SelectPossibleSeasons(model.Team.Seasons, model.Match.MatchType);
model.PossibleSeasons = _editMatchHelper.PossibleSeasonsAsListItems(possibleSeasons);
model.Match.Teams.Add(new TeamInMatch {
Team = model.Team
});
model.MatchLocationId = model.Team.MatchLocations.FirstOrDefault()?.MatchLocationId;
model.MatchLocationName = model.Team.MatchLocations.FirstOrDefault()?.NameAndLocalityOrTownIfDifferent();
}
else if (Request.RawUrl.StartsWith("/competitions/", StringComparison.OrdinalIgnoreCase))
{
model.Match.Season = model.Season = await _seasonDataSource.ReadSeasonByRoute(Request.RawUrl, false).ConfigureAwait(false);
if (model.Season == null || !model.Season.MatchTypes.Contains(MatchType.TrainingSession))
{
return(new HttpNotFoundResult());
}
}
model.IsAuthorized[AuthorizedAction.CreateMatch] = User.Identity.IsAuthenticated;
_editMatchHelper.ConfigureAddMatchModelMetadata(model);
model.Breadcrumbs.Add(new Breadcrumb {
Name = Constants.Pages.Matches, Url = new Uri(Constants.Pages.MatchesUrl, UriKind.Relative)
});
return(CurrentTemplate(model));
}
public async Task <ActionResult> CreateMatch([Bind(Prefix = "Match", Include = "Season")] Match postedMatch)
{
if (postedMatch is null)
{
throw new ArgumentNullException(nameof(postedMatch));
}
var model = new EditLeagueMatchViewModel(CurrentPage, Services.UserService)
{
Match = postedMatch
};
model.Match.MatchType = MatchType.LeagueMatch;
_editMatchHelper.ConfigureModelFromRequestData(model, Request.Unvalidated.Form, Request.Form, ModelState);
if (Request.RawUrl.StartsWith("/competitions/", StringComparison.OrdinalIgnoreCase))
{
model.Match.Season = model.Season = await _seasonDataSource.ReadSeasonByRoute(Request.RawUrl, true).ConfigureAwait(false);
}
else if (model.Match.Season != null && model.Match.Season.SeasonId.HasValue)
{
// Get the season, to support validation against season dates
model.Match.Season = await _seasonDataSource.ReadSeasonById(model.Match.Season.SeasonId.Value).ConfigureAwait(false);
}
_matchValidator.DateIsValidForSqlServer(() => model.MatchDate, ModelState, "MatchDate", "match");
_matchValidator.DateIsWithinTheSeason(() => model.MatchDate, model.Match.Season, ModelState, "MatchDate", "match");
_matchValidator.TeamsMustBeDifferent(model, ModelState);
model.IsAuthorized[AuthorizedAction.CreateMatch] = User.Identity.IsAuthenticated;
if (model.IsAuthorized[AuthorizedAction.CreateMatch] && ModelState.IsValid &&
(model.Team == null || (model.PossibleSeasons != null && model.PossibleSeasons.Any())) &&
(model.Season == null || model.Season.MatchTypes.Contains(MatchType.LeagueMatch)))
{
var currentMember = Members.GetCurrentMember();
var createdMatch = await _matchRepository.CreateMatch(model.Match, currentMember.Key, currentMember.Name).ConfigureAwait(false);
await _cacheClearer.ClearCacheFor(createdMatch).ConfigureAwait(false);
return(Redirect(createdMatch.MatchRoute));
}
if (Request.RawUrl.StartsWith("/teams/", StringComparison.OrdinalIgnoreCase))
{
model.Team = await _teamDataSource.ReadTeamByRoute(Request.RawUrl, true).ConfigureAwait(false);
var possibleSeasons = _createMatchSeasonSelector.SelectPossibleSeasons(model.Team.Seasons, model.Match.MatchType).ToList();
if (possibleSeasons.Count == 1)
{
model.Match.Season = possibleSeasons.First();
}
model.PossibleSeasons = _editMatchHelper.PossibleSeasonsAsListItems(possibleSeasons);
await _editMatchHelper.ConfigureModelPossibleTeams(model, possibleSeasons).ConfigureAwait(false);
model.Metadata.PageTitle = $"Add a {MatchType.LeagueMatch.Humanize(LetterCasing.LowerCase)} for {model.Team.TeamName}";
}
else
{
model.PossibleSeasons = _editMatchHelper.PossibleSeasonsAsListItems(new[] { model.Match.Season });
model.PossibleHomeTeams = _editMatchHelper.PossibleTeamsAsListItems(model.Season?.Teams);
model.PossibleAwayTeams = _editMatchHelper.PossibleTeamsAsListItems(model.Season?.Teams);
model.Metadata.PageTitle = $"Add a {MatchType.LeagueMatch.Humanize(LetterCasing.LowerCase)} in the {model.Season.SeasonFullName()}";
}
model.Breadcrumbs.Add(new Breadcrumb {
Name = Constants.Pages.Matches, Url = new Uri(Constants.Pages.MatchesUrl, UriKind.Relative)
});
return(View("CreateLeagueMatch", model));
}
public async override Task <ActionResult> Index(ContentModel contentModel)
{
if (contentModel is null)
{
throw new ArgumentNullException(nameof(contentModel));
}
var model = new EditLeagueMatchViewModel(contentModel.Content, Services?.UserService)
{
Match = new Match
{
MatchType = MatchType.LeagueMatch,
MatchLocation = new MatchLocation()
}
};
if (Request.RawUrl.StartsWith("/teams/", StringComparison.OrdinalIgnoreCase))
{
model.Team = await _teamDataSource.ReadTeamByRoute(Request.RawUrl, true).ConfigureAwait(false);
if (model.Team == null)
{
return(new HttpNotFoundResult());
}
var possibleSeasons = _createMatchSeasonSelector.SelectPossibleSeasons(model.Team.Seasons, model.Match.MatchType).ToList();
if (possibleSeasons.Count == 0)
{
return(new HttpNotFoundResult());
}
if (possibleSeasons.Count == 1)
{
model.Match.Season = possibleSeasons.First();
}
model.PossibleSeasons = _editMatchHelper.PossibleSeasonsAsListItems(possibleSeasons);
await _editMatchHelper.ConfigureModelPossibleTeams(model, possibleSeasons).ConfigureAwait(false);
model.HomeTeamId = model.Team.TeamId;
model.MatchLocationId = model.Team.MatchLocations.FirstOrDefault()?.MatchLocationId;
model.MatchLocationName = model.Team.MatchLocations.FirstOrDefault()?.NameAndLocalityOrTownIfDifferent();
if (model.PossibleAwayTeams.Count > 1)
{
model.AwayTeamId = new Guid(model.PossibleAwayTeams[1].Value);
}
}
else if (Request.RawUrl.StartsWith("/competitions/", StringComparison.OrdinalIgnoreCase))
{
model.Match.Season = model.Season = await _seasonDataSource.ReadSeasonByRoute(Request.RawUrl, true).ConfigureAwait(false);
if (model.Season == null || !model.Season.MatchTypes.Contains(MatchType.LeagueMatch))
{
return(new HttpNotFoundResult());
}
model.PossibleSeasons = _editMatchHelper.PossibleSeasonsAsListItems(new[] { model.Match.Season });
model.PossibleHomeTeams = _editMatchHelper.PossibleTeamsAsListItems(model.Season.Teams);
if (model.PossibleHomeTeams.Count > 0)
{
model.HomeTeamId = new Guid(model.PossibleHomeTeams[0].Value);
}
model.PossibleAwayTeams = _editMatchHelper.PossibleTeamsAsListItems(model.Season.Teams);
if (model.PossibleAwayTeams.Count > 1)
{
model.AwayTeamId = new Guid(model.PossibleAwayTeams[1].Value);
}
}
model.IsAuthorized[AuthorizedAction.CreateMatch] = User.Identity.IsAuthenticated;
if (model.Season != null && model.Season.Teams.Count <= 1 && model.Season.Competition != null)
{
_competitionAuthorizationPolicy.IsAuthorized(model.Season.Competition).TryGetValue(AuthorizedAction.EditCompetition, out var canEditCompetition);
model.IsAuthorized[AuthorizedAction.EditCompetition] = canEditCompetition;
}
_editMatchHelper.ConfigureAddMatchModelMetadata(model);
model.Breadcrumbs.Add(new Breadcrumb {
Name = Constants.Pages.Matches, Url = new Uri(Constants.Pages.MatchesUrl, UriKind.Relative)
});
return(CurrentTemplate(model));
}