public async override Task <ActionResult> Index(ContentModel contentModel)
{
if (contentModel is null)
{
throw new ArgumentNullException(nameof(contentModel));
}
var model = new DeleteTeamViewModel(contentModel.Content, Services?.UserService)
{
Team = await _teamDataSource.ReadTeamByRoute(Request.RawUrl, true).ConfigureAwait(false)
};
if (model.Team == null)
{
return(new HttpNotFoundResult());
}
else
{
var teamIds = new List <Guid> {
model.Team.TeamId.Value
};
model.TotalMatches = await _matchDataSource.ReadTotalMatches(new MatchFilter
{
TeamIds = teamIds,
IncludeTournamentMatches = true
}).ConfigureAwait(false);
model.Team.Players = (await _playerDataSource.ReadPlayerIdentities(new PlayerFilter
{
TeamIds = teamIds
}).ConfigureAwait(false))?.Select(x => new Player {
PlayerIdentities = new List <PlayerIdentity> {
x
}
}).ToList();
model.ConfirmDeleteRequest.RequiredText = model.Team.TeamName;
model.IsAuthorized = _authorizationPolicy.IsAuthorized(model.Team);
model.Metadata.PageTitle = "Delete " + model.Team.TeamName;
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)
});
}
model.Breadcrumbs.Add(new Breadcrumb {
Name = model.Team.TeamName, Url = new Uri(model.Team.TeamRoute, UriKind.Relative)
});
return(CurrentTemplate(model));
}
}
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 override Task <ActionResult> Index(ContentModel contentModel)
{
if (contentModel is null)
{
throw new ArgumentNullException(nameof(contentModel));
}
var model = new StatisticsSummaryViewModel <Team>(contentModel.Content, Services?.UserService)
{
Context = await _teamDataSource.ReadTeamByRoute(Request.RawUrl, true).ConfigureAwait(false),
};
if (model.Context == null)
{
return(new HttpNotFoundResult());
}
else
{
model.DefaultFilter = new StatisticsFilter {
Team = model.Context, MaxResultsAllowingExtraResultsIfValuesAreEqual = 10
};
model.AppliedFilter = _statisticsFilterQueryStringParser.ParseQueryString(model.DefaultFilter, HttpUtility.ParseQueryString(Request.Url.Query));
model.InningsStatistics = await _inningsStatisticsDataSource.ReadInningsStatistics(model.AppliedFilter).ConfigureAwait(false);
model.PlayerInnings = (await _bestPerformanceDataSource.ReadPlayerInnings(model.AppliedFilter, StatisticsSortOrder.BestFirst).ConfigureAwait(false)).ToList();
model.BowlingFigures = (await _bestPerformanceDataSource.ReadBowlingFigures(model.AppliedFilter, StatisticsSortOrder.BestFirst).ConfigureAwait(false)).ToList();
model.MostRuns = (await _bestPlayerTotalDataSource.ReadMostRunsScored(model.AppliedFilter).ConfigureAwait(false)).ToList();
model.MostWickets = (await _bestPlayerTotalDataSource.ReadMostWickets(model.AppliedFilter).ConfigureAwait(false)).ToList();
model.MostCatches = (await _bestPlayerTotalDataSource.ReadMostCatches(model.AppliedFilter).ConfigureAwait(false)).ToList();
model.Breadcrumbs.Add(new Breadcrumb {
Name = Constants.Pages.Teams, Url = new Uri(Constants.Pages.TeamsUrl, UriKind.Relative)
});
if (model.Context.Club != null)
{
model.Breadcrumbs.Add(new Breadcrumb {
Name = model.Context.Club.ClubName, Url = new Uri(model.Context.Club.ClubRoute, UriKind.Relative)
});
}
model.FilterDescription = _statisticsFilterHumanizer.EntitiesMatchingFilter("Statistics", _statisticsFilterHumanizer.MatchingUserFilter(model.AppliedFilter));
model.Metadata.PageTitle = $"Statistics for {model.Context.TeamName} stoolball team" + _statisticsFilterHumanizer.MatchingUserFilter(model.AppliedFilter);
model.Metadata.Description = $"Statistics for {model.Context.TeamName}, a {model.Context.Description().Substring(2)}";
return(CurrentTemplate(model));
}
}
public async override Task <ActionResult> Index(ContentModel contentModel)
{
if (contentModel is null)
{
throw new ArgumentNullException(nameof(contentModel));
}
var model = new TeamViewModel(contentModel.Content, Services?.UserService)
{
Team = await _teamDataSource.ReadTeamByRoute(Request.RawUrl, true).ConfigureAwait(false)
};
if (model.Team == null)
{
return(new HttpNotFoundResult());
}
model.IsAuthorized = _authorizationPolicy.IsAuthorized(model.Team);
model.Matches = new MatchListingViewModel(contentModel.Content, Services?.UserService)
{
Matches = await _matchDataSource.ReadMatchListings(new MatchFilter
{
TeamIds = new List <Guid> {
model.Team.TeamId.Value
},
IncludeMatches = false
}, MatchSortOrder.MatchDateEarliestFirst).ConfigureAwait(false),
HighlightNextMatch = false,
DateTimeFormatter = _dateFormatter
};
var match = model.Matches.Matches.First();
model.Metadata.PageTitle = model.Team.TeamNameAndPlayerType() + ", " + _dateFormatter.FormatDate(match.StartTime, false, false);
model.Team.Cost = _emailProtector.ProtectEmailAddresses(model.Team.Cost, User.Identity.IsAuthenticated);
model.Team.Introduction = _emailProtector.ProtectEmailAddresses(model.Team.Introduction, User.Identity.IsAuthenticated);
model.Team.PublicContactDetails = _emailProtector.ProtectEmailAddresses(model.Team.PublicContactDetails, User.Identity.IsAuthenticated);
model.Breadcrumbs.Add(new Breadcrumb {
Name = match.MatchName, Url = new Uri(match.MatchRoute, 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 TeamViewModel(contentModel.Content, Services?.UserService)
{
Team = await _teamDataSource.ReadTeamByRoute(Request.Url.AbsolutePath, true).ConfigureAwait(false)
};
if (model.Team == null)
{
return(new HttpNotFoundResult());
}
else
{
var identities = await _playerDataSource.ReadPlayerIdentities(new PlayerFilter { TeamIds = new List <Guid> {
model.Team.TeamId.Value
} }).ConfigureAwait(false);
model.Players = identities.Select(x => x.Player).Distinct(new PlayerEqualityComparer()).ToList();
foreach (var player in model.Players)
{
player.PlayerIdentities = identities.Where(x => x.Player.PlayerId == player.PlayerId).ToList();
}
model.Metadata.PageTitle = "Players for " + model.Team.TeamName + " stoolball team";
model.Metadata.Description = model.Team.Description();
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 TeamViewModel(contentModel.Content, Services?.UserService)
{
Team = await _teamDataSource.ReadTeamByRoute(Request.RawUrl, true).ConfigureAwait(false)
};
if (model.Team == null)
{
return(new HttpNotFoundResult());
}
else
{
model.IsAuthorized = _authorizationPolicy.IsAuthorized(model.Team);
model.Matches = new MatchListingViewModel(contentModel.Content, Services?.UserService)
{
Matches = await _matchDataSource.ReadMatchListings(new MatchFilter
{
TeamIds = new List <Guid> {
model.Team.TeamId.Value
},
IncludeMatches = false
}, MatchSortOrder.MatchDateEarliestFirst).ConfigureAwait(false),
DateTimeFormatter = _dateFormatter
};
var match = model.Matches.Matches.First();
model.Metadata.PageTitle = $"Edit {model.Team.TeamName}, {_dateFormatter.FormatDate(match.StartTime, false, false)}";
model.Breadcrumbs.Add(new Breadcrumb {
Name = match.MatchName, Url = new Uri(match.MatchRoute, UriKind.Relative)
});
return(CurrentTemplate(model));
}
}
public async Task <StatisticsFilter> FromRoute(string route)
{
if (string.IsNullOrWhiteSpace(route))
{
throw new ArgumentException($"'{nameof(route)}' cannot be null or whitespace.", nameof(route));
}
var entityType = _stoolballEntityRouteParser.ParseRoute(route);
var filter = new StatisticsFilter {
Paging = new Paging {
PageSize = Constants.Defaults.PageSize
}
};
if (entityType == StoolballEntityType.Player)
{
filter.Player = await _playerDataSource.ReadPlayerByRoute(_routeNormaliser.NormaliseRouteToEntity(route, "players")).ConfigureAwait(false);
}
else if (entityType == StoolballEntityType.Club)
{
filter.Club = await _clubDataSource.ReadClubByRoute(_routeNormaliser.NormaliseRouteToEntity(route, "clubs")).ConfigureAwait(false);
}
else if (entityType == StoolballEntityType.Team)
{
filter.Team = await _teamDataSource.ReadTeamByRoute(_routeNormaliser.NormaliseRouteToEntity(route, "teams"), true).ConfigureAwait(false); // true gets a lot of data but we only really want the club
}
else if (entityType == StoolballEntityType.MatchLocation)
{
filter.MatchLocation = await _matchLocationDataSource.ReadMatchLocationByRoute(_routeNormaliser.NormaliseRouteToEntity(route, "locations"), false).ConfigureAwait(false);
}
else if (entityType == StoolballEntityType.Season)
{
filter.Season = await _seasonDataSource.ReadSeasonByRoute(_routeNormaliser.NormaliseRouteToEntity(route, "competitions", Constants.Pages.SeasonUrlRegEx)).ConfigureAwait(false);
}
else if (entityType == StoolballEntityType.Competition)
{
filter.Competition = await _competitionDataSource.ReadCompetitionByRoute(_routeNormaliser.NormaliseRouteToEntity(route, "competitions")).ConfigureAwait(false);
}
return(filter);
}
public async override Task <ActionResult> Index(ContentModel contentModel)
{
if (contentModel is null)
{
throw new System.ArgumentNullException(nameof(contentModel));
}
var model = new TeamViewModel(contentModel.Content, Services?.UserService)
{
Team = await _teamDataSource.ReadTeamByRoute(Request.Url.AbsolutePath, true).ConfigureAwait(false)
};
if (model.Team == null)
{
return(new HttpNotFoundResult());
}
else
{
model.IsAuthorized = _authorizationPolicy.IsAuthorized(model.Team);
model.Metadata.PageTitle = model.Team.TeamName + " stoolball team";
model.Metadata.Description = model.Team.Description();
model.Team.Cost = _emailProtector.ProtectEmailAddresses(model.Team.Cost, User.Identity.IsAuthenticated);
model.Team.Introduction = _emailProtector.ProtectEmailAddresses(model.Team.Introduction, User.Identity.IsAuthenticated);
model.Team.PlayingTimes = _emailProtector.ProtectEmailAddresses(model.Team.PlayingTimes, User.Identity.IsAuthenticated);
model.Team.PublicContactDetails = _emailProtector.ProtectEmailAddresses(model.Team.PublicContactDetails, User.Identity.IsAuthenticated);
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 System.ArgumentNullException(nameof(contentModel));
}
var model = new TeamViewModel(contentModel.Content, Services?.UserService)
{
Team = await _teamDataSource.ReadTeamByRoute(Request.RawUrl, true).ConfigureAwait(false)
};
if (model.Team == null)
{
return(new HttpNotFoundResult());
}
else
{
model.IsAuthorized = _authorizationPolicy.IsAuthorized(model.Team);
model.Metadata.PageTitle = "Edit " + model.Team.TeamName;
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)
});
}
model.Breadcrumbs.Add(new Breadcrumb {
Name = model.Team.TeamName, Url = new Uri(model.Team.TeamRoute, UriKind.Relative)
});
return(CurrentTemplate(model));
}
}
public async Task <ActionResult> CreateTournament([Bind(Prefix = "Tournament", Include = "TournamentName,QualificationType,PlayerType,PlayersPerTeam,DefaultOverSets")] Tournament postedTournament)
{
if (postedTournament is null)
{
throw new ArgumentNullException(nameof(postedTournament));
}
postedTournament.DefaultOverSets.RemoveAll(x => !x.Overs.HasValue);
var model = new EditTournamentViewModel(CurrentPage, Services.UserService)
{
Tournament = postedTournament
};
// get this from the unvalidated form instead of via modelbinding so that HTML can be allowed
model.Tournament.TournamentNotes = Request.Unvalidated.Form["Tournament.TournamentNotes"];
if (!string.IsNullOrEmpty(Request.Form["TournamentDate"]) && DateTimeOffset.TryParse(Request.Form["TournamentDate"], out var parsedDate))
{
model.TournamentDate = parsedDate;
model.Tournament.StartTime = model.TournamentDate.Value;
if (!string.IsNullOrEmpty(Request.Form["StartTime"]))
{
if (DateTimeOffset.TryParse(Request.Form["StartTime"], out var parsedTime))
{
model.StartTime = parsedTime;
model.Tournament.StartTime = model.Tournament.StartTime.Add(model.StartTime.Value.TimeOfDay);
model.Tournament.StartTimeIsKnown = true;
}
else
{
// This may be seen in browsers that don't support <input type="time" />, mainly Safari.
// Each browser that supports <input type="time" /> may have a very different interface so don't advertise
// this format up-front as it could confuse the majority. Instead, only reveal it here.
ModelState.AddModelError("StartTime", "Enter a time in 24-hour HH:MM format.");
}
}
else
{
// If no start time specified, use a typical one but don't show it
model.Tournament.StartTime.AddHours(11);
model.Tournament.StartTimeIsKnown = false;
}
}
else
{
// This may be seen in browsers that don't support <input type="date" />, mainly Safari.
// This is the format <input type="date" /> expects and posts, so we have to repopulate the field in this format,
// so although this code _can_ parse other formats we don't advertise that. We also don't want YYYY-MM-DD in
// the field label as it could confuse the majority, so only reveal it here.
ModelState.AddModelError("TournamentDate", "Enter a date in YYYY-MM-DD format.");
}
_matchValidator.DateIsValidForSqlServer(() => model.TournamentDate, ModelState, "TournamentDate", "tournament");
if (Request.RawUrl.StartsWith("/teams/", StringComparison.OrdinalIgnoreCase))
{
model.Team = await _teamDataSource.ReadTeamByRoute(Request.RawUrl, true).ConfigureAwait(false);
model.Tournament.Teams.Add(new TeamInTournament {
Team = model.Team, TeamRole = TournamentTeamRole.Organiser
});
model.Metadata.PageTitle = $"Add a tournament for {model.Team.TeamName}";
}
else if (Request.RawUrl.StartsWith("/competitions/", StringComparison.OrdinalIgnoreCase))
{
model.Season = await _seasonDataSource.ReadSeasonByRoute(Request.RawUrl, false).ConfigureAwait(false);
model.Tournament.Seasons.Add(model.Season);
model.Metadata.PageTitle = $"Add a tournament in the {model.Season.SeasonFullName()}";
_matchValidator.DateIsWithinTheSeason(() => model.TournamentDate, model.Season, ModelState, "TournamentDate", "tournament");
}
if (!string.IsNullOrEmpty(Request.Form["TournamentLocationId"]))
{
model.TournamentLocationId = new Guid(Request.Form["TournamentLocationId"]);
model.TournamentLocationName = Request.Form["TournamentLocationName"];
model.Tournament.TournamentLocation = new MatchLocation
{
MatchLocationId = model.TournamentLocationId
};
}
model.IsAuthorized[AuthorizedAction.CreateTournament] = User.Identity.IsAuthenticated;
if (model.IsAuthorized[AuthorizedAction.CreateTournament] && ModelState.IsValid &&
(model.Team != null ||
(model.Season != null && model.Season.EnableTournaments)))
{
var currentMember = Members.GetCurrentMember();
var createdTournament = await _tournamentRepository.CreateTournament(model.Tournament, currentMember.Key, currentMember.Name).ConfigureAwait(false);
await _cacheClearer.ClearCacheFor(createdTournament).ConfigureAwait(false);
return(Redirect(createdTournament.TournamentRoute));
}
model.Breadcrumbs.Add(new Breadcrumb {
Name = Constants.Pages.Tournaments, Url = new Uri(Constants.Pages.TournamentsUrl, UriKind.Relative)
});
return(View("CreateTournament", model));
}
public async override Task <ActionResult> Index(ContentModel contentModel)
{
if (contentModel is null)
{
throw new ArgumentNullException(nameof(contentModel));
}
var model = new MatchListingViewModel(contentModel.Content, Services?.UserService)
{
DefaultMatchFilter = new MatchFilter
{
FromDate = DateTimeOffset.UtcNow.Date,
IncludeMatches = true,
IncludeTournaments = true,
IncludeTournamentMatches = false
},
DateTimeFormatter = _dateFormatter
};
model.AppliedMatchFilter = _matchFilterQueryStringParser.ParseQueryString(model.DefaultMatchFilter, HttpUtility.ParseQueryString(Request.Url.Query));
// Don't allow matches in the past - this is a calendar for planning future events
if (model.AppliedMatchFilter.FromDate < model.DefaultMatchFilter.FromDate)
{
model.AppliedMatchFilter.FromDate = model.DefaultMatchFilter.FromDate;
}
var pageTitle = "Stoolball matches and tournaments";
var legacyTournamentsCalendarUrl = Regex.Match(Request.RawUrl, "/tournaments/(all|mixed|ladies|junior)/calendar.ics", RegexOptions.IgnoreCase);
if (Request.RawUrl.StartsWith("/matches.ics", StringComparison.OrdinalIgnoreCase))
{
model.AppliedMatchFilter.IncludeTournaments = false;
pageTitle = "Stoolball matches";
}
else if (legacyTournamentsCalendarUrl.Success || Request.RawUrl.StartsWith("/tournaments.ics", StringComparison.OrdinalIgnoreCase))
{
model.AppliedMatchFilter.IncludeMatches = false;
pageTitle = "Stoolball tournaments";
if (legacyTournamentsCalendarUrl.Success)
{
switch (legacyTournamentsCalendarUrl.Groups[1].Value.ToUpperInvariant())
{
case "MIXED":
model.AppliedMatchFilter.PlayerTypes.Add(PlayerType.Mixed);
break;
case "LADIES":
model.AppliedMatchFilter.PlayerTypes.Add(PlayerType.Ladies);
break;
case "JUNIOR":
model.AppliedMatchFilter.PlayerTypes.Add(PlayerType.JuniorMixed);
model.AppliedMatchFilter.PlayerTypes.Add(PlayerType.JuniorGirls);
model.AppliedMatchFilter.PlayerTypes.Add(PlayerType.JuniorBoys);
break;
default:
break;
}
}
}
else if (Request.RawUrl.StartsWith("/tournaments/", StringComparison.OrdinalIgnoreCase))
{
var tournament = await _tournamentDataSource.ReadTournamentByRoute(Request.RawUrl).ConfigureAwait(false);
if (tournament == null)
{
return(new HttpNotFoundResult());
}
pageTitle = tournament.TournamentFullName(x => tournament.StartTimeIsKnown ? _dateFormatter.FormatDateTime(tournament.StartTime, true, false) : _dateFormatter.FormatDate(tournament.StartTime, true, false));
model.Matches.Add(tournament.ToMatchListing());
}
else if (Request.RawUrl.StartsWith("/matches/", StringComparison.OrdinalIgnoreCase))
{
var match = await _matchDataSource.ReadMatchByRoute(Request.RawUrl).ConfigureAwait(false);
if (match == null)
{
return(new HttpNotFoundResult());
}
pageTitle = match.MatchFullName(x => match.StartTimeIsKnown ? _dateFormatter.FormatDateTime(match.StartTime, true, false) : _dateFormatter.FormatDate(match.StartTime, true, false));
model.Matches.Add(match.ToMatchListing());
}
else if (Request.RawUrl.StartsWith("/clubs/", StringComparison.OrdinalIgnoreCase))
{
var club = await _clubDataSource.ReadClubByRoute(Request.RawUrl).ConfigureAwait(false);
if (club == null)
{
return(new HttpNotFoundResult());
}
pageTitle += " for " + club.ClubName;
model.AppliedMatchFilter.TeamIds.AddRange(club.Teams.Select(x => x.TeamId.Value));
}
else if (Request.RawUrl.StartsWith("/teams/", StringComparison.OrdinalIgnoreCase))
{
var team = await _teamDataSource.ReadTeamByRoute(Request.RawUrl).ConfigureAwait(false);
if (team == null)
{
return(new HttpNotFoundResult());
}
pageTitle += " for " + team.TeamName;
model.AppliedMatchFilter.TeamIds.Add(team.TeamId.Value);
}
else if (Request.RawUrl.StartsWith("/competitions/", StringComparison.OrdinalIgnoreCase))
{
var competition = await _competitionDataSource.ReadCompetitionByRoute(Request.RawUrl).ConfigureAwait(false);
if (competition == null)
{
return(new HttpNotFoundResult());
}
pageTitle += " in the " + competition.CompetitionName;
model.AppliedMatchFilter.CompetitionIds.Add(competition.CompetitionId.Value);
}
else if (Request.RawUrl.StartsWith("/locations/", StringComparison.OrdinalIgnoreCase))
{
var location = await _matchLocationDataSource.ReadMatchLocationByRoute(Request.RawUrl).ConfigureAwait(false);
if (location == null)
{
return(new HttpNotFoundResult());
}
pageTitle += " at " + location.NameAndLocalityOrTown();
model.AppliedMatchFilter.MatchLocationIds.Add(location.MatchLocationId.Value);
}
// Remove from date from filter if it's the default, and describe the remainder in the feed title.
var clonedFilter = model.AppliedMatchFilter.Clone();
if (clonedFilter.FromDate == model.DefaultMatchFilter.FromDate)
{
clonedFilter.FromDate = null;
}
model.Metadata.PageTitle = pageTitle + _matchFilterHumanizer.MatchingFilter(clonedFilter);
if (model.AppliedMatchFilter.PlayerTypes.Any())
{
model.Metadata.PageTitle = $"{model.AppliedMatchFilter.PlayerTypes.First().Humanize(LetterCasing.Sentence).Replace("Junior mixed", "Junior")} {model.Metadata.PageTitle.ToLower(CultureInfo.CurrentCulture)}";
}
if (!model.Matches.Any())
{
model.Matches = await _matchListingDataSource.ReadMatchListings(model.AppliedMatchFilter, MatchSortOrder.LatestUpdateFirst).ConfigureAwait(false);
}
return(CurrentTemplate(model));
}
public async Task <ActionResult> UpdateTeam([Bind(Prefix = "Team", Include = "TeamName,TeamType,AgeRangeLower,AgeRangeUpper,UntilYear,PlayerType,MatchLocations,Facebook,Twitter,Instagram,YouTube,Website")] Team team)
{
if (team is null)
{
throw new System.ArgumentNullException(nameof(team));
}
var beforeUpdate = await _teamDataSource.ReadTeamByRoute(Request.RawUrl).ConfigureAwait(false);
team.TeamId = beforeUpdate.TeamId;
team.TeamRoute = beforeUpdate.TeamRoute;
// get this from the unvalidated form instead of via modelbinding so that HTML can be allowed
team.Introduction = Request.Unvalidated.Form["Team.Introduction"];
team.PlayingTimes = Request.Unvalidated.Form["Team.PlayingTimes"];
team.Cost = Request.Unvalidated.Form["Team.Cost"];
team.PublicContactDetails = Request.Unvalidated.Form["Team.PublicContactDetails"];
team.PrivateContactDetails = Request.Unvalidated.Form["Team.PrivateContactDetails"];
if (team.AgeRangeLower < 11 && !team.AgeRangeUpper.HasValue)
{
ModelState.AddModelError("Team.AgeRangeUpper", "School teams and junior teams must specify a maximum age for players");
}
if (team.AgeRangeUpper.HasValue && team.AgeRangeUpper < team.AgeRangeLower)
{
ModelState.AddModelError("Team.AgeRangeUpper", "The maximum age for players cannot be lower than the minimum age");
}
// We're not interested in validating the details of the selected locations
foreach (var key in ModelState.Keys.Where(x => x.StartsWith("Team.MatchLocations", StringComparison.OrdinalIgnoreCase)))
{
ModelState[key].Errors.Clear();
}
var isAuthorized = _authorizationPolicy.IsAuthorized(beforeUpdate);
if (isAuthorized[AuthorizedAction.EditTeam] && ModelState.IsValid)
{
var currentMember = Members.GetCurrentMember();
var updatedTeam = await _teamRepository.UpdateTeam(team, currentMember.Key, currentMember.Name).ConfigureAwait(false);
_cacheOverride.OverrideCacheForCurrentMember(CacheConstants.TeamListingsCacheKeyPrefix);
// redirect back to the team actions
return(Redirect(updatedTeam.TeamRoute + "/edit"));
}
var model = new TeamViewModel(CurrentPage, Services.UserService)
{
Team = team,
};
model.IsAuthorized = isAuthorized;
model.Metadata.PageTitle = $"Edit {team.TeamName}";
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)
});
}
model.Breadcrumbs.Add(new Breadcrumb {
Name = model.Team.TeamName, Url = new Uri(model.Team.TeamRoute, UriKind.Relative)
});
return(View("EditTeam", model));
}
public async override Task <ActionResult> Index(ContentModel contentModel)
{
if (contentModel is null)
{
throw new ArgumentNullException(nameof(contentModel));
}
var model = new MatchListingViewModel(contentModel.Content, Services?.UserService)
{
AppliedMatchFilter = _queryStringParser.ParseFilterFromQueryString(Request.QueryString),
DateTimeFormatter = _dateFormatter
};
string pageTitle = "Stoolball matches";
if (Request.RawUrl.StartsWith("/clubs/", StringComparison.OrdinalIgnoreCase))
{
var club = await _clubDataSource.ReadClubByRoute(Request.RawUrl).ConfigureAwait(false);
if (club == null)
{
return(new HttpNotFoundResult());
}
pageTitle += " for " + club.ClubName;
model.AppliedMatchFilter.TeamIds.AddRange(club.Teams.Select(x => x.TeamId.Value));
}
else if (Request.RawUrl.StartsWith("/teams/", StringComparison.OrdinalIgnoreCase))
{
var team = await _teamDataSource.ReadTeamByRoute(Request.RawUrl).ConfigureAwait(false);
if (team == null)
{
return(new HttpNotFoundResult());
}
pageTitle += " for " + team.TeamName;
model.AppliedMatchFilter.TeamIds.Add(team.TeamId.Value);
}
else if (Request.RawUrl.StartsWith("/competitions/", StringComparison.OrdinalIgnoreCase))
{
var competition = await _competitionDataSource.ReadCompetitionByRoute(Request.RawUrl).ConfigureAwait(false);
if (competition == null)
{
return(new HttpNotFoundResult());
}
pageTitle += " in the " + competition.CompetitionName;
model.AppliedMatchFilter.CompetitionIds.Add(competition.CompetitionId.Value);
}
else if (Request.RawUrl.StartsWith("/locations/", StringComparison.OrdinalIgnoreCase))
{
var location = await _matchLocationDataSource.ReadMatchLocationByRoute(Request.RawUrl).ConfigureAwait(false);
if (location == null)
{
return(new HttpNotFoundResult());
}
pageTitle += " at " + location.NameAndLocalityOrTown();
model.AppliedMatchFilter.MatchLocationIds.Add(location.MatchLocationId.Value);
}
// Remove from date from filter if it's the default, and describe the remainder in the feed title.
var clonedFilter = model.AppliedMatchFilter.Clone();
if (clonedFilter.FromDate == DateTimeOffset.UtcNow.Date)
{
clonedFilter.FromDate = null;
}
// Remove to date filter if it's a rolling date
// (if user has set a specific end date a exactly year in the future unfortunately we'll miss it, but this is only for the description)
if (clonedFilter.UntilDate == DateTimeOffset.UtcNow.Date.AddDays(365).AddDays(1).AddSeconds(-1))
{
clonedFilter.UntilDate = null;
}
model.Metadata.PageTitle = pageTitle + _matchFilterHumanizer.MatchingFilter(clonedFilter);
model.Metadata.Description = $"New or updated stoolball matches on the Stoolball England website";
if (model.AppliedMatchFilter.PlayerTypes.Any())
{
model.Metadata.PageTitle = $"{model.AppliedMatchFilter.PlayerTypes.First().Humanize(LetterCasing.Sentence)} {model.Metadata.PageTitle.ToLower(CultureInfo.CurrentCulture)}";
model.Metadata.Description = $"New or updated {model.AppliedMatchFilter.PlayerTypes.First()} stoolball matches on the Stoolball England website";
}
model.Matches = await _matchDataSource.ReadMatchListings(model.AppliedMatchFilter, MatchSortOrder.LatestUpdateFirst).ConfigureAwait(false);
return(View(Request.QueryString["format"] == "tweet" ? "MatchTweets" : "MatchesRss", model));
}
public async Task <ActionResult> UpdateTransientTeam([Bind(Prefix = "Team", Include = "TeamName,AgeRangeLower,AgeRangeUpper,PlayerType,Facebook,Twitter,Instagram,YouTube,Website")] Team team)
{
if (team is null)
{
throw new ArgumentNullException(nameof(team));
}
var beforeUpdate = await _teamDataSource.ReadTeamByRoute(Request.RawUrl).ConfigureAwait(false);
team.TeamId = beforeUpdate.TeamId;
team.TeamRoute = beforeUpdate.TeamRoute;
// get this from the unvalidated form instead of via modelbinding so that HTML can be allowed
team.Introduction = Request.Unvalidated.Form["Team.Introduction"];
team.Cost = Request.Unvalidated.Form["Team.Cost"];
team.PublicContactDetails = Request.Unvalidated.Form["Team.PublicContactDetails"];
team.PrivateContactDetails = Request.Unvalidated.Form["Team.PrivateContactDetails"];
if (team.AgeRangeLower < 11 && !team.AgeRangeUpper.HasValue)
{
ModelState.AddModelError("Team.AgeRangeUpper", "School teams and junior teams must specify a maximum age for players");
}
if (team.AgeRangeUpper.HasValue && team.AgeRangeUpper < team.AgeRangeLower)
{
ModelState.AddModelError("Team.AgeRangeUpper", "The maximum age for players cannot be lower than the minimum age");
}
var isAuthorized = _authorizationPolicy.IsAuthorized(beforeUpdate);
if (isAuthorized[AuthorizedAction.EditTeam] && ModelState.IsValid)
{
var currentMember = Members.GetCurrentMember();
var updatedTeam = await _teamRepository.UpdateTransientTeam(team, currentMember.Key, currentMember.Name).ConfigureAwait(false);
// redirect back to the team, as there is no actions page for a transient team
return(Redirect(updatedTeam.TeamRoute));
}
var model = new TeamViewModel(CurrentPage, Services.UserService)
{
Team = team,
};
model.IsAuthorized = isAuthorized;
model.Matches = new MatchListingViewModel(CurrentPage, Services?.UserService)
{
Matches = await _matchDataSource.ReadMatchListings(new MatchFilter
{
TeamIds = new List <Guid> {
model.Team.TeamId.Value
},
IncludeMatches = false
}, MatchSortOrder.MatchDateEarliestFirst).ConfigureAwait(false),
DateTimeFormatter = _dateFormatter
};
var match = model.Matches.Matches.First();
model.Metadata.PageTitle = $"Edit {model.Team.TeamName}, {_dateFormatter.FormatDate(match.StartTime, false, false)}";
model.Breadcrumbs.Add(new Breadcrumb {
Name = match.MatchName, Url = new Uri(match.MatchRoute, UriKind.Relative)
});
return(View("EditTransientTeam", 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));
}
public async Task <ActionResult> DeleteTeam([Bind(Prefix = "ConfirmDeleteRequest", Include = "RequiredText,ConfirmationText")] MatchingTextConfirmation postedModel)
{
if (postedModel is null)
{
throw new ArgumentNullException(nameof(postedModel));
}
var model = new DeleteTeamViewModel(CurrentPage, Services.UserService)
{
Team = await _teamDataSource.ReadTeamByRoute(Request.RawUrl, true).ConfigureAwait(false),
};
model.IsAuthorized = _authorizationPolicy.IsAuthorized(model.Team);
if (model.IsAuthorized[AuthorizedAction.DeleteTeam] && ModelState.IsValid)
{
var memberGroup = Services.MemberGroupService.GetById(model.Team.MemberGroupKey.Value);
if (memberGroup != null)
{
Services.MemberGroupService.Delete(memberGroup);
}
var currentMember = Members.GetCurrentMember();
await _teamRepository.DeleteTeam(model.Team, currentMember.Key, currentMember.Name).ConfigureAwait(false);
_cacheOverride.OverrideCacheForCurrentMember(CacheConstants.TeamListingsCacheKeyPrefix);
model.Deleted = true;
}
else
{
var teamIds = new List <Guid> {
model.Team.TeamId.Value
};
model.TotalMatches = await _matchDataSource.ReadTotalMatches(new MatchFilter
{
TeamIds = teamIds,
IncludeTournamentMatches = true
}).ConfigureAwait(false);
model.Team.Players = (await _playerDataSource.ReadPlayerIdentities(new PlayerFilter
{
TeamIds = teamIds
}).ConfigureAwait(false))?.Select(x => new Player {
PlayerIdentities = new List <PlayerIdentity> {
x
}
}).ToList();
}
model.Metadata.PageTitle = $"Delete {model.Team.TeamName}";
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)
});
}
if (!model.Deleted)
{
model.Breadcrumbs.Add(new Breadcrumb {
Name = model.Team.TeamName, Url = new Uri(model.Team.TeamRoute, UriKind.Relative)
});
}
return(View("DeleteTeam", model));
}
public async override Task <ActionResult> Index(ContentModel contentModel)
{
if (contentModel is null)
{
throw new ArgumentNullException(nameof(contentModel));
}
var model = new EditTournamentViewModel(contentModel.Content, Services?.UserService)
{
Tournament = new Tournament
{
QualificationType = TournamentQualificationType.OpenTournament,
PlayerType = PlayerType.Mixed,
PlayersPerTeam = 8,
DefaultOverSets = new List <OverSet> {
new OverSet {
Overs = 4, BallsPerOver = 8
}
},
TournamentLocation = 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());
}
model.Tournament.TournamentName = model.Team.TeamName;
if (model.Tournament.TournamentName.IndexOf("tournament", StringComparison.OrdinalIgnoreCase) == -1)
{
model.Tournament.TournamentName += " tournament";
}
model.TournamentLocationId = model.Team.MatchLocations.FirstOrDefault()?.MatchLocationId;
model.TournamentLocationName = model.Team.MatchLocations.FirstOrDefault()?.NameAndLocalityOrTownIfDifferent();
model.Tournament.PlayerType = model.Team.PlayerType;
model.Metadata.PageTitle = $"Add a tournament for {model.Team.TeamName}";
}
else if (Request.RawUrl.StartsWith("/competitions/", StringComparison.OrdinalIgnoreCase))
{
model.Season = await _seasonDataSource.ReadSeasonByRoute(Request.RawUrl, false).ConfigureAwait(false);
if (model.Season == null || !model.Season.EnableTournaments)
{
return(new HttpNotFoundResult());
}
model.Tournament.TournamentName = model.Season.Competition.CompetitionName;
if (model.Tournament.TournamentName.IndexOf("tournament", StringComparison.OrdinalIgnoreCase) == -1)
{
model.Tournament.TournamentName += " tournament";
}
model.Tournament.PlayerType = model.Season.Competition.PlayerType;
model.Metadata.PageTitle = $"Add a tournament in the {model.Season.SeasonFullName()}";
}
model.IsAuthorized[AuthorizedAction.CreateTournament] = User.Identity.IsAuthenticated;
model.Breadcrumbs.Add(new Breadcrumb {
Name = Constants.Pages.Tournaments, Url = new Uri(Constants.Pages.TournamentsUrl, UriKind.Relative)
});
return(CurrentTemplate(model));
}
