public RoyaleYearQuarter(SupportedYear year, YearQuarter yearQuarter, bool openForPlay, bool finished)
{
Year = year;
YearQuarter = yearQuarter;
OpenForPlay = openForPlay;
Finished = finished;
}
public SupportedYearViewModel(SupportedYear domain)
{
Year = domain.Year;
OpenForCreation = domain.OpenForCreation;
OpenForPlay = domain.OpenForPlay;
StartDate = domain.StartDate.ToDateTimeUnspecified();
Finished = domain.Finished;
}
public PlayerWithPublisherViewModel(LeagueYear leagueYear, FantasyCriticUser user, Publisher publisher, IClock clock,
LeagueOptions options, SystemWideValues systemWideValues, bool userIsInLeague, bool userIsInvitedToLeague,
SupportedYear supportedYear, bool removable)
{
User = new PlayerViewModel(leagueYear.League, user, removable);
Publisher = new PublisherViewModel(publisher, clock, userIsInLeague, userIsInvitedToLeague, systemWideValues, supportedYear.Finished);
TotalFantasyPoints = publisher.TotalFantasyPoints;
SimpleProjectedFantasyPoints = publisher.GetProjectedFantasyPoints(options, systemWideValues, supportedYear.Finished, true, clock);
AdvancedProjectedFantasyPoints = publisher.GetProjectedFantasyPoints(options, systemWideValues, supportedYear.Finished, false, clock);
}
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 decimal GetTotalFantasyPoints(SupportedYear year, LeagueOptions leagueOptions)
{
var emptyCounterPickSlotPoints = GetEmptyCounterPickSlotPoints(year, leagueOptions) ?? 0m;
var score = PublisherGames.Sum(x => x.FantasyPoints);
if (!score.HasValue)
{
return(emptyCounterPickSlotPoints);
}
return(score.Value + emptyCounterPickSlotPoints);
}
public bool LeagueIsReadyToPlay(SupportedYear supportedYear, IEnumerable <Publisher> publishersInLeague, IEnumerable <FantasyCriticUser> activeUsers)
{
if (!LeagueIsReadyToSetDraftOrder(publishersInLeague, activeUsers))
{
return(false);
}
if (!supportedYear.OpenForPlay)
{
return(false);
}
return(true);
}
public LeagueYear ToDomain(League league, SupportedYear year, IEnumerable <EligibilityOverride> eligibilityOverrides,
IEnumerable <TagOverride> tagOverrides, IEnumerable <LeagueTagStatus> leagueTags, IEnumerable <SpecialGameSlot> specialGameSlots,
FantasyCriticUser?winningUser, IEnumerable <Publisher> publishersInLeague)
{
DraftSystem draftSystem = Lib.Enums.DraftSystem.FromValue(DraftSystem);
PickupSystem pickupSystem = Lib.Enums.PickupSystem.FromValue(PickupSystem);
TradingSystem tradingSystem = Lib.Enums.TradingSystem.FromValue(TradingSystem);
TiebreakSystem tiebreakSystem = Lib.Enums.TiebreakSystem.FromValue(TiebreakSystem);
ScoringSystem scoringSystem = Lib.Domain.ScoringSystems.ScoringSystem.GetScoringSystem(ScoringSystem);
AnnualDate counterPickDeadline = new AnnualDate(CounterPickDeadlineMonth, CounterPickDeadlineDay);
LeagueOptions options = new LeagueOptions(StandardGames, GamesToDraft, CounterPicks, CounterPicksToDraft, FreeDroppableGames, WillNotReleaseDroppableGames, WillReleaseDroppableGames,
DropOnlyDraftGames, CounterPicksBlockDrops, MinimumBidAmount, leagueTags, specialGameSlots, draftSystem, pickupSystem, scoringSystem, tradingSystem, tiebreakSystem, counterPickDeadline);
return(new LeagueYear(league, year, options, Lib.Enums.PlayStatus.FromValue(PlayStatus), eligibilityOverrides, tagOverrides, DraftStartedTimestamp, winningUser, publishersInLeague));
}
public LeagueYear(League league, SupportedYear year, LeagueOptions options, PlayStatus playStatus,
IEnumerable <EligibilityOverride> eligibilityOverrides, IEnumerable <TagOverride> tagOverrides,
Instant?draftStartedTimestamp, FantasyCriticUser?winningUser, IEnumerable <Publisher> publishers)
{
League = league;
SupportedYear = year;
Options = options;
PlayStatus = playStatus;
EligibilityOverrides = eligibilityOverrides.ToList();
_eligibilityOverridesDictionary = EligibilityOverrides.ToDictionary(x => x.MasterGame);
TagOverrides = tagOverrides.ToList();
_tagOverridesDictionary = TagOverrides.ToDictionary(x => x.MasterGame);
DraftStartedTimestamp = draftStartedTimestamp;
WinningUser = winningUser;
_publisherDictionary = publishers.ToDictionary(x => x.PublisherID);
_managerPublisher = Publishers.SingleOrDefault(x => x.User.Id == league.LeagueManager.Id);
StandardGamesTaken = _publisherDictionary.Values.SelectMany(x => x.PublisherGames).Count(x => !x.CounterPick);
}
public bool IsRelevantInYear(SupportedYear year)
{
if (MasterGame.AddedTimestamp.InUtc().Year > year.Year)
{
return(false);
}
if (MasterGame.ReleaseDate.HasValue && MasterGame.ReleaseDate.Value.Year < year.Year)
{
return(false);
}
if (DateAdjustedHypeFactor == 0)
{
return(false);
}
return(true);
}
private decimal?GetEmptyCounterPickSlotPoints(SupportedYear year, LeagueOptions leagueOptions)
{
if (!SupportedYear.Year2022FeatureSupported(year.Year))
{
return(0m);
}
if (!year.Finished)
{
return(null);
}
var expectedNumberOfCounterPicks = leagueOptions.CounterPicks;
var numberCounterPicks = PublisherGames.Count(x => x.CounterPick);
var emptySlots = expectedNumberOfCounterPicks - numberCounterPicks;
var points = emptySlots * -15m;
return(points);
}
public Task FinishYear(SupportedYear supportedYear)
{
return(_fantasyCriticRepo.FinishYear(supportedYear));
}
public Task <IReadOnlyDictionary <LeagueYear, IReadOnlyList <DropRequest> > > GetActiveDropRequests(SupportedYear supportedYear)
{
return(_fantasyCriticRepo.GetActiveDropRequests(supportedYear.Year));
}
public Task <IReadOnlyDictionary <LeagueYear, IReadOnlyList <PickupBid> > > GetActiveAcquistitionBids(SupportedYear supportedYear)
{
return(_fantasyCriticRepo.GetActivePickupBids(supportedYear.Year));
}
public RoyaleYearQuarter ToDomain(SupportedYear supportedYear)
{
return(new RoyaleYearQuarter(supportedYear, new YearQuarter(Year, Quarter), OpenForPlay, Finished));
}
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();
}
