public async Task <IActionResult> GetLeagueYear(Guid leagueID, int year)
{
Maybe <LeagueYear> leagueYear = await _fantasyCriticService.GetLeagueYear(leagueID, year);
if (leagueYear.HasNoValue)
{
throw new Exception("Something went really wrong, no options are set up for this league.");
}
var currentUser = await _userManager.FindByNameAsync(User.Identity.Name);
var usersInLeague = await _fantasyCriticService.GetUsersInLeague(leagueYear.Value.League);
bool userIsInLeague = usersInLeague.Any(x => x.UserID == currentUser.UserID);
var inviteesToLeague = await _fantasyCriticService.GetOutstandingInvitees(leagueYear.Value.League);
bool userIsInvitedToLeague = inviteesToLeague.Any(x => x == currentUser.EmailAddress);
if (!userIsInLeague && !userIsInvitedToLeague)
{
return(Unauthorized());
}
var publishersInLeague = await _fantasyCriticService.GetPublishersInLeagueForYear(leagueYear.Value.League, leagueYear.Value.Year);
var supportedYear = (await _fantasyCriticService.GetSupportedYears()).SingleOrDefault(x => x.Year == year);
if (supportedYear is null)
{
return(BadRequest());
}
StartDraftResult startDraftResult = await _fantasyCriticService.GetStartDraftResult(leagueYear.Value, publishersInLeague, usersInLeague);
Maybe <Publisher> nextDraftPublisher = await _fantasyCriticService.GetNextDraftPublisher(leagueYear.Value);
DraftPhase draftPhase = await _fantasyCriticService.GetDraftPhase(leagueYear.Value);
var userPublisher = publishersInLeague.SingleOrDefault(x => x.User.UserID == currentUser.UserID);
IReadOnlyList <PublisherGame> availableCounterPicks = new List <PublisherGame>();
if (nextDraftPublisher.HasValue)
{
availableCounterPicks = await _fantasyCriticService.GetAvailableCounterPicks(leagueYear.Value, nextDraftPublisher.Value);
}
LeagueWideValues leagueWideValues = await _fantasyCriticService.GetLeagueWideValues();
var leagueViewModel = new LeagueYearViewModel(leagueYear.Value, supportedYear, publishersInLeague, currentUser, userPublisher, _clock,
leagueYear.Value.PlayStatus, startDraftResult, usersInLeague, nextDraftPublisher, draftPhase, availableCounterPicks, leagueWideValues);
return(Ok(leagueViewModel));
}
public (int?DraftPosition, int?OverallDraftPosition) GetDraftStatus(DraftPhase draftPhase, LeagueYear leagueYear)
{
var nextPublisher = GetNextDraftPublisher(leagueYear);
if (nextPublisher is null)
{
return(null, null);
}
if (draftPhase.Equals(DraftPhase.StandardGames))
{
var publisherPosition = nextPublisher.PublisherGames.Count(x => !x.CounterPick) + 1;
var overallPosition = leagueYear.Publishers.SelectMany(x => x.PublisherGames).Count(x => !x.CounterPick) + 1;
return(publisherPosition, overallPosition);
}
if (draftPhase.Equals(DraftPhase.CounterPicks))
{
var publisherPosition = nextPublisher.PublisherGames.Count(x => x.CounterPick) + 1;
var overallPosition = leagueYear.Publishers.SelectMany(x => x.PublisherGames).Count(x => x.CounterPick) + 1;
return(publisherPosition, overallPosition);
}
return(null, null);
}
public PlayStatusViewModel(PlayStatus domain, bool readyToSetDraftOrder, bool readyToDraft, IEnumerable <string> startDraftErrors, DraftPhase draftPhase)
{
PlayStatus = domain.Value;
ReadyToSetDraftOrder = readyToSetDraftOrder;
ReadyToDraft = readyToDraft;
PlayStarted = domain.PlayStarted;
DraftIsActive = domain.DraftIsActive;
DraftIsPaused = domain.DraftIsPaused;
DraftFinished = domain.DraftFinished;
StartDraftErrors = startDraftErrors.ToList();
if (draftPhase.Equals(DraftPhase.CounterPicks))
{
DraftingCounterPicks = true;
}
}
public LeagueYearViewModel(LeagueYear leagueYear, SupportedYear supportedYear, IEnumerable <Publisher> publishers, Maybe <Publisher> userPublisher,
IClock clock, PlayStatus playStatus, StartDraftResult startDraftResult, IEnumerable <FantasyCriticUser> activeUsers, Maybe <Publisher> nextDraftPublisher, DraftPhase draftPhase,
IEnumerable <PublisherGame> availableCounterPicks, LeagueOptions options, SystemWideValues systemWideValues, IEnumerable <LeagueInvite> invitedPlayers,
bool userIsInLeague, bool userIsInvitedToLeague, bool userIsManager, Maybe <FantasyCriticUser> accessingUser)
{
LeagueID = leagueYear.League.LeagueID;
Year = leagueYear.Year;
SupportedYear = new SupportedYearViewModel(supportedYear);
StandardGames = leagueYear.Options.StandardGames;
GamesToDraft = leagueYear.Options.GamesToDraft;
CounterPicks = leagueYear.Options.CounterPicks;
EligibilitySettings = new EligibilitySettingsViewModel(leagueYear.Options.AllowedEligibilitySettings, false);
DraftSystem = leagueYear.Options.DraftSystem.Value;
PickupSystem = leagueYear.Options.PickupSystem.Value;
ScoringSystem = leagueYear.Options.ScoringSystem.Name;
UnlinkedGameExists = publishers.SelectMany(x => x.PublisherGames).Any(x => x.MasterGame.HasNoValue);
UserIsActive = activeUsers.Any(x => x.UserID == accessingUser.Unwrap(y => y.UserID));
Publishers = publishers
.OrderBy(x => x.DraftPosition)
.Select(x => new PublisherViewModel(x, clock, nextDraftPublisher, userIsInLeague, userIsInvitedToLeague, systemWideValues, supportedYear.Finished))
.ToList();
if (userPublisher.HasValue)
{
UserPublisher = new PublisherViewModel(userPublisher.Value, clock, userIsInLeague, userIsInvitedToLeague, systemWideValues, supportedYear.Finished);
}
List <PlayerWithPublisherViewModel> playerVMs = new List <PlayerWithPublisherViewModel>();
bool allPublishersMade = true;
foreach (var user in activeUsers)
{
var publisher = publishers.SingleOrDefault(x => x.User.UserID == user.UserID);
if (publisher is null)
{
playerVMs.Add(new PlayerWithPublisherViewModel(leagueYear, user, false));
allPublishersMade = false;
}
else
{
playerVMs.Add(new PlayerWithPublisherViewModel(leagueYear, user, publisher, clock, options, systemWideValues,
userIsInLeague, userIsInvitedToLeague, supportedYear, false));
}
}
foreach (var invitedPlayer in invitedPlayers)
{
allPublishersMade = false;
if (invitedPlayer.User.HasValue)
{
playerVMs.Add(new PlayerWithPublisherViewModel(invitedPlayer.InviteID, invitedPlayer.User.Value.DisplayName));
}
else
{
if (accessingUser.HasValue)
{
if (userIsManager || string.Equals(invitedPlayer.EmailAddress, accessingUser.Value.EmailAddress, StringComparison.OrdinalIgnoreCase))
{
playerVMs.Add(new PlayerWithPublisherViewModel(invitedPlayer.InviteID, invitedPlayer.EmailAddress));
}
else
{
playerVMs.Add(new PlayerWithPublisherViewModel(invitedPlayer.InviteID, "<Email Address Hidden>"));
}
}
else
{
playerVMs.Add(new PlayerWithPublisherViewModel(invitedPlayer.InviteID, "<Email Address Hidden>"));
}
}
}
bool readyToSetDraftOrder = false;
if (allPublishersMade)
{
Players = playerVMs.OrderBy(x => x.Publisher.DraftPosition).ToList();
readyToSetDraftOrder = true;
}
else
{
Players = playerVMs;
}
PlayStatus = new PlayStatusViewModel(playStatus, readyToSetDraftOrder, startDraftResult.Ready, startDraftResult.Errors, draftPhase);
AvailableCounterPicks = availableCounterPicks
.Select(x => new PublisherGameViewModel(x, clock, leagueYear.Options.ScoringSystem, systemWideValues))
.OrderBy(x => x.GameName).ToList();
EligibilityOverrides = leagueYear.EligibilityOverrides.Select(x => new EligibilityOverrideViewModel(x, clock)).ToList();
}
public LeagueYearViewModel(LeagueYear leagueYear, SupportedYear supportedYear, IEnumerable <Publisher> publishers, FantasyCriticUser currentUser, Publisher userPublisher,
IClock clock, PlayStatus playStatus, StartDraftResult startDraftResult, IEnumerable <FantasyCriticUser> users, Maybe <Publisher> nextDraftPublisher, DraftPhase draftPhase,
IEnumerable <PublisherGame> availableCounterPicks, LeagueWideValues leagueWideValues)
{
LeagueID = leagueYear.League.LeagueID;
Year = leagueYear.Year;
SupportedYear = new SupportedYearViewModel(supportedYear);
StandardGames = leagueYear.Options.StandardGames;
GamesToDraft = leagueYear.Options.GamesToDraft;
CounterPicks = leagueYear.Options.CounterPicks;
MaximumEligibilityLevel = new EligibilityLevelViewModel(leagueYear.Options.MaximumEligibilityLevel, false);
DraftSystem = leagueYear.Options.DraftSystem.Value;
PickupSystem = leagueYear.Options.PickupSystem.Value;
ScoringSystem = leagueYear.Options.ScoringSystem.Name;
UnlinkedGameExists = publishers.SelectMany(x => x.PublisherGames).Any(x => x.MasterGame.HasNoValue);
Publishers = publishers.OrderBy(x => x.DraftPosition).Select(x => new PublisherViewModel(x, clock, nextDraftPublisher)).ToList();
Standings = publishers.OrderByDescending(x => x.TotalFantasyPoints).Select(x => new StandingViewModel(x, leagueYear.Options.ScoringSystem, leagueWideValues)).ToList();
if (!(userPublisher is null))
{
UserPublisher = new PublisherViewModel(userPublisher, clock);
}
List <PlayerWithPublisherViewModel> playerVMs = new List <PlayerWithPublisherViewModel>();
bool allPublishersMade = true;
foreach (var user in users)
{
var publisher = publishers.SingleOrDefault(x => x.User.UserID == user.UserID);
if (publisher is null)
{
playerVMs.Add(new PlayerWithPublisherViewModel(leagueYear, user));
allPublishersMade = false;
}
else
{
playerVMs.Add(new PlayerWithPublisherViewModel(leagueYear, user, publisher, clock));
}
}
bool readyToSetDraftOrder = false;
if (allPublishersMade)
{
Players = playerVMs.OrderBy(x => x.Publisher.DraftPosition).ToList();
readyToSetDraftOrder = true;
}
else
{
Players = playerVMs;
}
PlayStatus = new PlayStatusViewModel(playStatus, readyToSetDraftOrder, startDraftResult.Ready, startDraftResult.Errors, draftPhase);
AvailableCounterPicks = availableCounterPicks.Select(x => new PublisherGameViewModel(x, clock)).ToList();
}
public async Task <Maybe <Publisher> > GetNextDraftPublisher(LeagueYear leagueYear)
{
if (!leagueYear.PlayStatus.DraftIsActive)
{
return(Maybe <Publisher> .None);
}
IReadOnlyList <Publisher> publishers = await GetPublishersInLeagueForYear(leagueYear.League, leagueYear.Year);
DraftPhase phase = GetDraftPhase(leagueYear, publishers);
if (phase.Equals(DraftPhase.StandardGames))
{
var publishersWithLowestNumberOfGames = publishers.MinBy(x => x.PublisherGames.Count(y => !y.CounterPick));
var allPlayersHaveSameNumberOfGames = publishers.Select(x => x.PublisherGames.Count(y => !y.CounterPick)).Distinct().Count() == 1;
var maxNumberOfGames = publishers.Max(x => x.PublisherGames.Count(y => !y.CounterPick));
var roundNumber = maxNumberOfGames;
if (allPlayersHaveSameNumberOfGames)
{
roundNumber++;
}
bool roundNumberIsOdd = (roundNumber % 2 != 0);
if (roundNumberIsOdd)
{
var sortedPublishersOdd = publishersWithLowestNumberOfGames.OrderBy(x => x.DraftPosition);
var firstPublisherOdd = sortedPublishersOdd.First();
return(firstPublisherOdd);
}
//Else round is even
var sortedPublishersEven = publishersWithLowestNumberOfGames.OrderByDescending(x => x.DraftPosition);
var firstPublisherEven = sortedPublishersEven.First();
return(firstPublisherEven);
}
if (phase.Equals(DraftPhase.CounterPicks))
{
var publishersWithLowestNumberOfGames = publishers.MinBy(x => x.PublisherGames.Count(y => y.CounterPick));
var allPlayersHaveSameNumberOfGames = publishers.Select(x => x.PublisherGames.Count(y => y.CounterPick)).Distinct().Count() == 1;
var maxNumberOfGames = publishers.Max(x => x.PublisherGames.Count(y => y.CounterPick));
var roundNumber = maxNumberOfGames;
if (allPlayersHaveSameNumberOfGames)
{
roundNumber++;
}
bool roundNumberIsOdd = (roundNumber % 2 != 0);
if (roundNumberIsOdd)
{
var sortedPublishersOdd = publishersWithLowestNumberOfGames.OrderByDescending(x => x.DraftPosition);
var firstPublisherOdd = sortedPublishersOdd.First();
return(firstPublisherOdd);
}
//Else round is even
var sortedPublishersEven = publishersWithLowestNumberOfGames.OrderBy(x => x.DraftPosition);
var firstPublisherEven = sortedPublishersEven.First();
return(firstPublisherEven);
}
return(Maybe <Publisher> .None);
}
public LeagueYearViewModel(LeagueViewModel leagueViewModel, LeagueYear leagueYear,
LocalDate currentDate, StartDraftResult startDraftResult, IEnumerable <FantasyCriticUser> activeUsers, Publisher?nextDraftPublisher,
DraftPhase draftPhase, SystemWideValues systemWideValues,
IEnumerable <LeagueInvite> invitedPlayers, bool userIsInLeague, bool userIsInvitedToLeague, bool userIsManager,
FantasyCriticUser?accessingUser, IEnumerable <ManagerMessage> managerMessages, FantasyCriticUser?previousYearWinner,
IReadOnlyList <PublicBiddingMasterGame>?publicBiddingGames, IReadOnlySet <Guid> counterPickedPublisherGameIDs,
IEnumerable <Trade> activeTrades, PrivatePublisherDataViewModel?privatePublisherData, GameNewsViewModel gameNews)
{
League = leagueViewModel;
LeagueID = leagueYear.League.LeagueID;
Year = leagueYear.Year;
SupportedYear = new SupportedYearViewModel(leagueYear.SupportedYear);
StandardGames = leagueYear.Options.StandardGames;
CounterPicks = leagueYear.Options.CounterPicks;
DraftSystem = leagueYear.Options.DraftSystem.Value;
PickupSystem = leagueYear.Options.PickupSystem.Value;
TiebreakSystem = leagueYear.Options.TiebreakSystem.Value;
ScoringSystem = leagueYear.Options.ScoringSystem.Name;
TradingSystem = leagueYear.Options.TradingSystem.Value;
UnlinkedGameExists = leagueYear.Publishers.SelectMany(x => x.PublisherGames).Any(x => x.MasterGame is null);
if (accessingUser is not null)
{
UserIsActive = activeUsers.Any(x => x.Id == accessingUser.Id);
}
HasSpecialSlots = leagueYear.Options.HasSpecialSlots;
OneShotMode = leagueYear.Options.OneShotMode;
CounterPickDeadline = leagueYear.CounterPickDeadline;
Publishers = leagueYear.Publishers
.OrderBy(x => x.DraftPosition)
.Select(x => new PublisherViewModel(leagueYear, x, currentDate, nextDraftPublisher, userIsInLeague, userIsInvitedToLeague, systemWideValues, counterPickedPublisherGameIDs))
.ToList();
List <PlayerWithPublisherViewModel> playerVMs = new List <PlayerWithPublisherViewModel>();
bool allPublishersMade = true;
foreach (var user in activeUsers)
{
var publisher = leagueYear.GetUserPublisher(user);
if (publisher is null)
{
playerVMs.Add(new PlayerWithPublisherViewModel(leagueYear, user, false));
allPublishersMade = false;
}
else
{
bool isPreviousYearWinner = previousYearWinner is not null && previousYearWinner.Id == user.Id;
playerVMs.Add(new PlayerWithPublisherViewModel(leagueYear, user, publisher, currentDate, systemWideValues,
userIsInLeague, userIsInvitedToLeague, false, isPreviousYearWinner));
}
}
foreach (var invitedPlayer in invitedPlayers)
{
allPublishersMade = false;
if (invitedPlayer.User is not null)
{
playerVMs.Add(new PlayerWithPublisherViewModel(invitedPlayer.InviteID, invitedPlayer.User.UserName));
}
else
{
if (accessingUser is not null)
{
if (userIsManager || string.Equals(invitedPlayer.EmailAddress, accessingUser.Email, StringComparison.OrdinalIgnoreCase))
{
playerVMs.Add(new PlayerWithPublisherViewModel(invitedPlayer.InviteID, invitedPlayer.EmailAddress));
}
else
{
playerVMs.Add(new PlayerWithPublisherViewModel(invitedPlayer.InviteID, "<Email Address Hidden>"));
}
}
else
{
playerVMs.Add(new PlayerWithPublisherViewModel(invitedPlayer.InviteID, "<Email Address Hidden>"));
}
}
}
bool readyToSetDraftOrder = false;
if (allPublishersMade)
{
Players = playerVMs.OrderBy(x => x.Publisher !.DraftPosition).ToList();
readyToSetDraftOrder = true;
}
else
{
Players = playerVMs;
}
PlayStatus = new PlayStatusViewModel(leagueYear.PlayStatus, readyToSetDraftOrder, startDraftResult.Ready, startDraftResult.Errors, draftPhase);
EligibilityOverrides = leagueYear.EligibilityOverrides.Select(x => new EligibilityOverrideViewModel(x, currentDate)).ToList();
TagOverrides = leagueYear.TagOverrides.Select(x => new TagOverrideViewModel(x, currentDate)).ToList();
SlotInfo = new PublisherSlotRequirementsViewModel(leagueYear.Options);
ManagerMessages = managerMessages.Select(x => new ManagerMessageViewModel(x, x.IsDismissed(accessingUser))).OrderBy(x => x.Timestamp).ToList();
if (!userIsInLeague)
{
ManagerMessages = ManagerMessages.Where(x => x.IsPublic).ToList();
}
if (publicBiddingGames is not null)
{
PublicBiddingGames = publicBiddingGames.Select(x => new PublicBiddingMasterGameViewModel(x, currentDate)).ToList();
}
ActiveTrades = activeTrades.Select(x => new TradeViewModel(x, currentDate)).ToList();
PrivatePublisherData = privatePublisherData;
GameNews = gameNews;
}
