public LeagueYearEntity(League league, int year, LeagueOptions options, PlayStatus playStatus)
{
LeagueID = league.LeagueID;
Year = year;
StandardGames = options.StandardGames;
GamesToDraft = options.GamesToDraft;
CounterPicks = options.CounterPicks;
CounterPicksToDraft = options.CounterPicksToDraft;
FreeDroppableGames = options.FreeDroppableGames;
WillNotReleaseDroppableGames = options.WillNotReleaseDroppableGames;
WillReleaseDroppableGames = options.WillReleaseDroppableGames;
DropOnlyDraftGames = options.DropOnlyDraftGames;
CounterPicksBlockDrops = options.CounterPicksBlockDrops;
MinimumBidAmount = options.MinimumBidAmount;
CounterPickDeadlineMonth = options.CounterPickDeadline.Month;
CounterPickDeadlineDay = options.CounterPickDeadline.Day;
DraftSystem = options.DraftSystem.Value;
PickupSystem = options.PickupSystem.Value;
TiebreakSystem = options.TiebreakSystem.Value;
ScoringSystem = options.ScoringSystem.Name;
TradingSystem = options.TradingSystem.Value;
PlayStatus = playStatus.Value;
}
public LeagueYearEntity(League league, int year, LeagueOptions options, PlayStatus playStatus)
{
LeagueID = league.LeagueID;
Year = year;
StandardGames = options.StandardGames;
GamesToDraft = options.GamesToDraft;
CounterPicks = options.CounterPicks;
FreeDroppableGames = options.FreeDroppableGames;
WillNotReleaseDroppableGames = options.WillNotReleaseDroppableGames;
WillReleaseDroppableGames = options.WillReleaseDroppableGames;
DropOnlyDraftGames = options.DropOnlyDraftGames;
MaximumEligibilityLevel = options.AllowedEligibilitySettings.EligibilityLevel.Level;
AllowYearlyInstallments = options.AllowedEligibilitySettings.YearlyInstallment;
AllowEarlyAccess = options.AllowedEligibilitySettings.EarlyAccess;
AllowFreeToPlay = options.AllowedEligibilitySettings.FreeToPlay;
AllowReleasedInternationally = options.AllowedEligibilitySettings.ReleasedInternationally;
AllowExpansions = options.AllowedEligibilitySettings.ExpansionPack;
DraftSystem = options.DraftSystem.Value;
PickupSystem = options.PickupSystem.Value;
ScoringSystem = options.ScoringSystem.Name;
PlayStatus = playStatus.Value;
}
public SeasonStatsModel(SeasonStatsParameters seasonParameters)
{
_seasonStatsParameters = seasonParameters;
_database = new BeaujeauxEntities();
// League
LeagueOptions = _database.Leagues.ToList();
SelectedLeague = LeagueOptions.Where(s => s.Id == _seasonStatsParameters.leagueId).FirstOrDefault();
SelectedLeague = SelectedLeague ?? LeagueOptions.FirstOrDefault();
// All Seasons for the League
var _seasons = _database.Seasons
.Where(s => s.LeagueId == SelectedLeague.Id);
SelectedLeagueEra = seasonParameters.leagueEra;
SetSeasonNumberOptions();
SetSeasonTypeOptions(_seasons);
SetSelectedSeasonType(_seasonStatsParameters.seasonTypeId);
SetSelectedSeason(_seasonStatsParameters.seasonNumber);
SetTeamOptions(_seasons);
SetSelectedTeam(_seasonStatsParameters.teamId);
SetPageNumberInfo(seasonParameters.pageNumber);
SetStatsForPage();
TotalPages = GetTotalPageCount();
BoundCurrentPage();
}
public PublisherSlotRequirementsViewModel(LeagueOptions options)
{
RegularSlot = new PublisherSingleSlotRequirementsViewModel(options.LeagueTags);
if (!options.HasSpecialSlots)
{
OverallSlot = RegularSlot;
SpecialSlots = new List <PublisherSingleSlotRequirementsViewModel>();
}
else
{
var distinctSpecialSlots = options.SpecialGameSlots.DistinctBy(x => string.Join(",", x.Tags.OrderBy(x => x.Name))).ToList();
var specialSlotRequiredTags = distinctSpecialSlots.SelectMany(x => x.Tags.Select(y => y.Name)).Distinct().ToList();
var regularBannedTags = options.LeagueTags.Where(x => x.Status.Equals(TagStatus.Banned)).Select(x => x.Tag.Name).ToList();
var overallBannedTags = regularBannedTags.Except(specialSlotRequiredTags).ToList();
OverallSlot = new PublisherSingleSlotRequirementsViewModel(overallBannedTags);
var specialSlots = new List <PublisherSingleSlotRequirementsViewModel>();
foreach (var specialSlot in distinctSpecialSlots)
{
var specialSlotTags = options.LeagueTags.ToList();
specialSlotTags.AddRange(specialSlot.Tags.Select(x => new LeagueTagStatus(x, TagStatus.Required)));
specialSlots.Add(new PublisherSingleSlotRequirementsViewModel(specialSlotTags));
}
SpecialSlots = specialSlots;
}
}
public Result CanDropGame(bool willRelease, LeagueOptions leagueOptions)
{
if (willRelease)
{
if (leagueOptions.WillReleaseDroppableGames == -1 || leagueOptions.WillReleaseDroppableGames > WillReleaseGamesDropped)
{
return(Result.Success());
}
if (leagueOptions.FreeDroppableGames == -1 || leagueOptions.FreeDroppableGames > FreeGamesDropped)
{
return(Result.Success());
}
return(Result.Failure("Publisher cannot drop any more 'Will Release' games"));
}
if (leagueOptions.WillNotReleaseDroppableGames == -1 || leagueOptions.WillNotReleaseDroppableGames > WillNotReleaseGamesDropped)
{
return(Result.Success());
}
if (leagueOptions.FreeDroppableGames == -1 || leagueOptions.FreeDroppableGames > FreeGamesDropped)
{
return(Result.Success());
}
return(Result.Failure("Publisher cannot drop any more 'Will Not Release' games"));
}
public SettingsViewModel(IUILanguageProvider uiLanguageProvider,
SidekickSettings sidekickSettings,
INativeKeyboard nativeKeyboard,
ILeagueDataService leagueDataService,
IKeybindEvents keybindEvents)
{
this.uiLanguageProvider = uiLanguageProvider;
this.sidekickSettings = sidekickSettings;
this.nativeKeyboard = nativeKeyboard;
this.keybindEvents = keybindEvents;
this.leagueDataService = leagueDataService;
Settings = new SidekickSettings();
AssignValues(sidekickSettings, Settings);
Keybinds.Clear();
Settings.GetType()
.GetProperties()
.Where(x => x.Name.StartsWith("Key"))
.ToList()
.ForEach(x => Keybinds.Add(x.Name, x.GetValue(Settings).ToString()));
WikiOptions.Add("POE Wiki", WikiSetting.PoeWiki.ToString());
WikiOptions.Add("POE Db", WikiSetting.PoeDb.ToString());
this.leagueDataService.Leagues.ForEach(x => LeagueOptions.Add(x.Id, x.Text));
uiLanguageProvider.AvailableLanguages.ForEach(x => UILanguageOptions.Add(x.NativeName.First().ToString().ToUpper() + x.NativeName.Substring(1), x.Name));
nativeKeyboard.OnKeyDown += NativeKeyboard_OnKeyDown;
}
public static int?GetTradeSlotResult(Publisher publisher, LeagueOptions leagueOptions, MasterGameYearWithCounterPick masterGameYearWithCounterPick, MasterGameWithEligibilityFactors eligibilityFactors, IEnumerable <int> openSlotNumbers)
{
var slots = publisher.GetPublisherSlots(leagueOptions);
var openSlots = slots.Where(x => x.CounterPick == masterGameYearWithCounterPick.CounterPick && openSlotNumbers.Contains(x.SlotNumber)).OrderBy(x => x.SlotNumber).ToList();
if (!openSlots.Any())
{
return(null);
}
//At this point, there is an open slot. Which one is best?
//We want to check the special slots first, then the regular slots.
var openSpotsToCheckOrder = openSlots
.OrderByDescending(x => x.SpecialGameSlot is not null)
.ThenBy(x => x.SlotNumber).ToList();
foreach (var openSlot in openSpotsToCheckOrder)
{
var claimErrorsForSlot = GetClaimErrorsForSlot(openSlot, eligibilityFactors);
if (!claimErrorsForSlot.Any())
{
return(openSlot.SlotNumber);
}
}
//This game isn't eligible in any slots, so we will just take the first open one.
var bestSlot = openSlots.First();
return(bestSlot.SlotNumber);
}
public async Task <Result <League> > CreateLeague(LeagueCreationParameters parameters)
{
LeagueOptions options = new LeagueOptions(parameters.LeagueYearParameters);
var validateOptions = options.Validate();
if (validateOptions.IsFailure)
{
return(Result.Failure <League>(validateOptions.Error));
}
if (parameters.LeagueYearParameters.ScoringSystem.Name != DiminishingScoringSystem.StaticName)
{
return(Result.Failure <League>("That scoring mode is no longer supported."));
}
IEnumerable <int> years = new List <int>()
{
parameters.LeagueYearParameters.Year
};
League newLeague = new League(Guid.NewGuid(), parameters.LeagueName, parameters.Manager, years, parameters.PublicLeague, parameters.TestLeague, false, 0);
await _fantasyCriticRepo.CreateLeague(newLeague, parameters.LeagueYearParameters.Year, options);
return(Result.Success(newLeague));
}
public LeagueOptions UpdateOptionsForYear(int requestYear)
{
var newScoringSystem = ScoringSystem.GetDefaultScoringSystem(requestYear);
LeagueOptions options = new LeagueOptions(StandardGames, GamesToDraft, CounterPicks, CounterPicksToDraft, FreeDroppableGames, WillNotReleaseDroppableGames, WillReleaseDroppableGames,
DropOnlyDraftGames, CounterPicksBlockDrops, MinimumBidAmount, LeagueTags, SpecialGameSlots, DraftSystem, PickupSystem, newScoringSystem, TradingSystem, TiebreakSystem, CounterPickDeadline);
return(options);
}
public async Task AddNewLeagueYear(League league, int year, LeagueOptions options, LeagueYear mostRecentLeagueYear)
{
await _fantasyCriticRepo.AddNewLeagueYear(league, year, options);
var mostRecentActivePlayers = await _fantasyCriticRepo.GetActivePlayersForLeagueYear(league, mostRecentLeagueYear.Year);
await _fantasyCriticRepo.SetPlayersActive(league, year, mostRecentActivePlayers);
}
public MasterGameWithEligibilityFactors(MasterGame masterGame, LeagueOptions options, bool?overridenEligibility,
IReadOnlyList <MasterGameTag> tagOverrides, LocalDate dateAcquired)
{
MasterGame = masterGame;
Options = options;
OverridenEligibility = overridenEligibility;
TagOverrides = tagOverrides;
DateAcquired = dateAcquired;
}
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 async Task <Result> EditLeague(League league, EditLeagueYearParameters parameters)
{
LeagueOptions options = new LeagueOptions(parameters);
var validateOptions = options.Validate();
if (validateOptions.IsFailure)
{
return(Result.Failure(validateOptions.Error));
}
var leagueYear = await GetLeagueYear(league.LeagueID, parameters.Year);
if (leagueYear.HasNoValue)
{
throw new Exception($"League year cannot be found: {parameters.LeagueID}|{parameters.Year}");
}
IReadOnlyList <Publisher> publishers = await _publisherService.GetPublishersInLeagueForYear(leagueYear.Value);
int maxStandardGames = publishers.Select(publisher => publisher.PublisherGames.Count(x => !x.CounterPick)).DefaultIfEmpty(0).Max();
int maxCounterPicks = publishers.Select(publisher => publisher.PublisherGames.Count(x => x.CounterPick)).DefaultIfEmpty(0).Max();
if (maxStandardGames > options.StandardGames)
{
return(Result.Failure($"Cannot reduce number of standard games to {options.StandardGames} as a publisher has {maxStandardGames} draft games currently."));
}
if (maxCounterPicks > options.CounterPicks)
{
return(Result.Failure($"Cannot reduce number of counter picks to {options.CounterPicks} as a publisher has {maxCounterPicks} counter picks currently."));
}
int maxFreeGamesFreeDropped = publishers.Select(publisher => publisher.FreeGamesDropped).DefaultIfEmpty(0).Max();
int maxWillNotReleaseGamesDropped = publishers.Select(publisher => publisher.WillNotReleaseGamesDropped).DefaultIfEmpty(0).Max();
int maxWillReleaseGamesDropped = publishers.Select(publisher => publisher.WillReleaseGamesDropped).DefaultIfEmpty(0).Max();
if (maxFreeGamesFreeDropped > options.FreeDroppableGames && options.FreeDroppableGames != -1)
{
return(Result.Failure($"Cannot reduce number of unrestricted droppable games to {options.FreeDroppableGames} as a publisher has already dropped {maxFreeGamesFreeDropped} games."));
}
if (maxWillNotReleaseGamesDropped > options.WillNotReleaseDroppableGames && options.WillNotReleaseDroppableGames != -1)
{
return(Result.Failure($"Cannot reduce number of 'will not release' droppable games to {options.WillNotReleaseDroppableGames} as a publisher has already dropped {maxWillNotReleaseGamesDropped} games."));
}
if (maxWillReleaseGamesDropped > options.WillReleaseDroppableGames && options.WillReleaseDroppableGames != -1)
{
return(Result.Failure($"Cannot reduce number of 'will release' droppable games to {options.WillReleaseDroppableGames} as a publisher has already dropped {maxWillReleaseGamesDropped} games."));
}
var eligibilityOverrides = await GetEligibilityOverrides(league, parameters.Year);
LeagueYear newLeagueYear = new LeagueYear(league, parameters.Year, options, leagueYear.Value.PlayStatus, eligibilityOverrides);
await _fantasyCriticRepo.EditLeagueYear(newLeagueYear);
return(Result.Success());
}
public LeagueYear ToDomain(League league, EligibilityLevel maximumEligibilityLevel)
{
DraftSystem draftSystem = Lib.Enums.DraftSystem.FromValue(DraftSystem);
PickupSystem pickupSystem = Lib.Enums.PickupSystem.FromValue(PickupSystem);
ScoringSystem scoringSystem = Lib.Domain.ScoringSystems.ScoringSystem.GetScoringSystem(ScoringSystem);
LeagueOptions options = new LeagueOptions(StandardGames, GamesToDraft, CounterPicks,
maximumEligibilityLevel, AllowYearlyInstallments, AllowEarlyAccess, draftSystem, pickupSystem, scoringSystem);
return(new LeagueYear(league, Year, options, Lib.Enums.PlayStatus.FromValue(PlayStatus)));
}
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);
}
private IReadOnlyList <ClaimError> GetMasterGameErrors(LeagueOptions yearOptions, MasterGame masterGame, int year, bool counterPick)
{
List <ClaimError> claimErrors = new List <ClaimError>();
bool eligible = masterGame.IsEligible(yearOptions.MaximumEligibilityLevel);
if (!eligible)
{
claimErrors.Add(new ClaimError("That game is not eligible under this league's settings.", true));
}
bool earlyAccessEligible = (!masterGame.EarlyAccess || yearOptions.AllowEarlyAccess);
if (!earlyAccessEligible)
{
claimErrors.Add(new ClaimError("That game is not eligible under this league's early access settings.", true));
}
bool yearlyInstallmentEligible = (!masterGame.YearlyInstallment || yearOptions.AllowYearlyInstallments);
if (!yearlyInstallmentEligible)
{
claimErrors.Add(new ClaimError("That game is not eligible under this league's yearly installment settings.", true));
}
bool released = masterGame.IsReleased(_clock);
if (released)
{
claimErrors.Add(new ClaimError("That game has already been released.", true));
}
if (masterGame.ReleaseDate.HasValue)
{
if (released && masterGame.ReleaseDate.Value.Year < year)
{
claimErrors.Add(new ClaimError($"That game was released prior to the start of {year}.", false));
}
else if (!released && masterGame.ReleaseDate.Value.Year > year && !counterPick)
{
claimErrors.Add(new ClaimError($"That game is not scheduled to be released in {year}.", true));
}
}
bool hasScore = masterGame.CriticScore.HasValue;
if (hasScore)
{
claimErrors.Add(new ClaimError("That game already has a score.", true));
}
return(claimErrors);
}
public async Task AddNewLeagueYear(League league, int year, LeagueOptions options)
{
LeagueYearEntity leagueYearEntity = new LeagueYearEntity(league, year, options, PlayStatus.NotStartedDraft);
using (var connection = new MySqlConnection(_connectionString))
{
await connection.ExecuteAsync(
"insert into tblleagueyear(LeagueID,Year,StandardGames,GamesToDraft,CounterPicks,MaximumEligibilityLevel,AllowYearlyInstallments,AllowEarlyAccess,DraftSystem,PickupSystem,ScoringSystem,PlayStatus) VALUES " +
"(@LeagueID,@Year,@StandardGames,@GamesToDraft,@CounterPicks,@MaximumEligibilityLevel,@AllowYearlyInstallments,@AllowEarlyAccess,@DraftSystem,@PickupSystem,@ScoringSystem,@PlayStatus);",
leagueYearEntity);
}
}
public LeagueYear ToDomain(League league, EligibilityLevel maximumEligibilityLevel, IEnumerable <EligibilityOverride> eligibilityOverrides)
{
DraftSystem draftSystem = Lib.Enums.DraftSystem.FromValue(DraftSystem);
PickupSystem pickupSystem = Lib.Enums.PickupSystem.FromValue(PickupSystem);
ScoringSystem scoringSystem = Lib.Domain.ScoringSystems.ScoringSystem.GetScoringSystem(ScoringSystem);
var eligibilitySettings = new EligibilitySettings(maximumEligibilityLevel, AllowYearlyInstallments, AllowEarlyAccess,
AllowFreeToPlay, AllowReleasedInternationally, AllowExpansions);
LeagueOptions options = new LeagueOptions(StandardGames, GamesToDraft, CounterPicks, FreeDroppableGames, WillNotReleaseDroppableGames, WillReleaseDroppableGames,
DropOnlyDraftGames, eligibilitySettings, draftSystem, pickupSystem, scoringSystem, league.PublicLeague);
return(new LeagueYear(league, Year, options, Lib.Enums.PlayStatus.FromValue(PlayStatus), eligibilityOverrides));
}
public LeagueYearEntity(League league, int year, LeagueOptions options, PlayStatus playStatus)
{
LeagueID = league.LeagueID;
Year = year;
StandardGames = options.StandardGames;
GamesToDraft = options.GamesToDraft;
CounterPicks = options.CounterPicks;
MaximumEligibilityLevel = options.MaximumEligibilityLevel.Level;
AllowYearlyInstallments = options.AllowYearlyInstallments;
AllowEarlyAccess = options.AllowEarlyAccess;
DraftSystem = options.DraftSystem.Value;
PickupSystem = options.PickupSystem.Value;
ScoringSystem = options.ScoringSystem.Name;
PlayStatus = playStatus.Value;
}
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 ToDomain(League league, IEnumerable <EligibilityOverride> eligibilityOverrides, IEnumerable <LeagueTagStatus> leagueTags)
{
DraftSystem draftSystem = Lib.Enums.DraftSystem.FromValue(DraftSystem);
PickupSystem pickupSystem = Lib.Enums.PickupSystem.FromValue(PickupSystem);
ScoringSystem scoringSystem = Lib.Domain.ScoringSystems.ScoringSystem.GetScoringSystem(ScoringSystem);
LeagueOptions options = new LeagueOptions(StandardGames, GamesToDraft, CounterPicks, FreeDroppableGames, WillNotReleaseDroppableGames, WillReleaseDroppableGames,
DropOnlyDraftGames, CounterPicksBlockDrops, MinimumBidAmount, leagueTags, draftSystem, pickupSystem, scoringSystem, league.PublicLeague);
Instant?draftStartedTimestamp = null;
if (DraftStartedTimestamp.HasValue)
{
draftStartedTimestamp = Instant.FromDateTimeUtc(DraftStartedTimestamp.Value);
}
return(new LeagueYear(league, Year, options, Lib.Enums.PlayStatus.FromValue(PlayStatus), eligibilityOverrides, draftStartedTimestamp));
}
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 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 async Task <Result <League> > CreateLeague(LeagueCreationParameters parameters)
{
LeagueOptions options = new LeagueOptions(parameters);
var validateOptions = options.Validate();
if (validateOptions.IsFailure)
{
return(Result.Failure <League>(validateOptions.Error));
}
IEnumerable <int> years = new List <int>()
{
parameters.InitialYear
};
League newLeague = new League(Guid.NewGuid(), parameters.LeagueName, parameters.Manager, years, parameters.PublicLeague, parameters.TestLeague, 0);
await _fantasyCriticRepo.CreateLeague(newLeague, parameters.InitialYear, options);
return(Result.Success(newLeague));
}
public async Task <Result> EditLeague(League league, EditLeagueYearParameters parameters)
{
LeagueOptions options = new LeagueOptions(parameters);
var validateOptions = options.Validate();
if (validateOptions.IsFailure)
{
return(Result.Fail(validateOptions.Error));
}
var leagueYear = await GetLeagueYear(league.LeagueID, parameters.Year);
if (leagueYear.HasNoValue)
{
throw new Exception($"League year cannot be found: {parameters.LeagueID}|{parameters.Year}");
}
IReadOnlyList <Publisher> publishers = await GetPublishersInLeagueForYear(league, parameters.Year);
int maxStandardGames = publishers.Select(publisher => publisher.PublisherGames.Count(x => !x.CounterPick)).DefaultIfEmpty(0).Max();
int maxCounterPicks = publishers.Select(publisher => publisher.PublisherGames.Count(x => x.CounterPick)).DefaultIfEmpty(0).Max();
if (maxStandardGames > options.StandardGames)
{
return(Result.Fail($"Cannot reduce number of standard games to {options.StandardGames} as a publisher has {maxStandardGames} draft games currently."));
}
if (maxCounterPicks > options.CounterPicks)
{
return(Result.Fail($"Cannot reduce number of counter picks to {options.CounterPicks} as a publisher has {maxCounterPicks} counter picks currently."));
}
LeagueYear newLeagueYear = new LeagueYear(league, parameters.Year, options, leagueYear.Value.PlayStatus);
await _fantasyCriticRepo.EditLeagueYear(newLeagueYear);
return(Result.Ok());
}
public IReadOnlyList <PublisherSlot> GetPublisherSlots(LeagueOptions leagueOptions)
{
List <PublisherSlot> publisherSlots = new List <PublisherSlot>();
int overallSlotNumber = 0;
var standardGamesBySlot = PublisherGames.Where(x => !x.CounterPick).ToDictionary(x => x.SlotNumber);
for (int standardGameIndex = 0; standardGameIndex < leagueOptions.StandardGames; standardGameIndex++)
{
PublisherGame?standardGame = null;
if (standardGamesBySlot.TryGetValue(standardGameIndex, out var foundGame))
{
standardGame = foundGame;
}
SpecialGameSlot?specialSlot = leagueOptions.GetSpecialGameSlotByOverallSlotNumber(standardGameIndex);
publisherSlots.Add(new PublisherSlot(standardGameIndex, overallSlotNumber, false, specialSlot, standardGame));
overallSlotNumber++;
}
var counterPicksBySlot = PublisherGames.Where(x => x.CounterPick).ToDictionary(x => x.SlotNumber);
for (int counterPickIndex = 0; counterPickIndex < leagueOptions.CounterPicks; counterPickIndex++)
{
PublisherGame?counterPick = null;
if (counterPicksBySlot.TryGetValue(counterPickIndex, out var foundGame))
{
counterPick = foundGame;
}
publisherSlots.Add(new PublisherSlot(counterPickIndex, overallSlotNumber, true, null, counterPick));
overallSlotNumber++;
}
return(publisherSlots);
}
public ClaimResult CanClaimGame(ClaimGameDomainRequest request, IEnumerable <SupportedYear> supportedYears, LeagueYear leagueYear,
IEnumerable <Publisher> publishersInLeague, Instant?nextBidTime, bool allowIfFull)
{
List <ClaimError> claimErrors = new List <ClaimError>();
var basicErrors = GetBasicErrors(request.Publisher.LeagueYear.League, request.Publisher, supportedYears);
claimErrors.AddRange(basicErrors);
LeagueOptions yearOptions = leagueYear.Options;
if (request.MasterGame.HasValue && !request.CounterPick)
{
var masterGameErrors = GetMasterGameErrors(leagueYear, request.MasterGame.Value, leagueYear.Year, request.CounterPick, false, nextBidTime);
claimErrors.AddRange(masterGameErrors);
}
IReadOnlyList <Publisher> otherPublishers = publishersInLeague.Where(x => x.User.UserID != request.Publisher.User.UserID).ToList();
IReadOnlyList <PublisherGame> gamesForYear = publishersInLeague.SelectMany(x => x.PublisherGames).ToList();
IReadOnlyList <PublisherGame> standardGamesForYear = gamesForYear.Where(x => !x.CounterPick).ToList();
IReadOnlyList <PublisherGame> thisPlayersGames = request.Publisher.PublisherGames;
IReadOnlyList <PublisherGame> otherPlayersGames = otherPublishers.SelectMany(x => x.PublisherGames).ToList();
bool gameAlreadyClaimed = standardGamesForYear.ContainsGame(request);
bool thisPlayerAlreadyHas = thisPlayersGames.ContainsGame(request);
if (!request.CounterPick)
{
if (gameAlreadyClaimed)
{
claimErrors.Add(new ClaimError("Cannot claim a game that someone already has.", false));
}
if (thisPlayerAlreadyHas)
{
claimErrors.Add(new ClaimError("Cannot claim a game that you already have.", false));
}
int leagueDraftGames = yearOptions.StandardGames;
int userDraftGames = thisPlayersGames.Count(x => !x.CounterPick);
if (userDraftGames == leagueDraftGames && !allowIfFull)
{
claimErrors.Add(new ClaimError("User's game spaces are filled.", false));
}
}
if (request.CounterPick)
{
bool otherPlayerHasCounterPick = otherPlayersGames.Where(x => x.CounterPick).ContainsGame(request);
if (otherPlayerHasCounterPick)
{
claimErrors.Add(new ClaimError("Cannot counter-pick a game that someone else has already counter-picked.", false));
}
bool thisPlayerHasCounterPick = thisPlayersGames.Where(x => x.CounterPick).ContainsGame(request);
if (thisPlayerHasCounterPick)
{
claimErrors.Add(new ClaimError("You already have that counter-pick.", false));
}
bool otherPlayerHasDraftGame = otherPlayersGames.Where(x => !x.CounterPick).ContainsGame(request);
int leagueCounterPicks = yearOptions.CounterPicks;
int userCounterPicks = thisPlayersGames.Count(x => x.CounterPick);
if (userCounterPicks == leagueCounterPicks)
{
claimErrors.Add(new ClaimError("User's counter pick spaces are filled.", false));
}
if (!otherPlayerHasDraftGame)
{
claimErrors.Add(new ClaimError("Cannot counterPick a game that no other player is publishing.", false));
}
}
var result = new ClaimResult(claimErrors);
if (result.Overridable && request.ManagerOverride)
{
return(new ClaimResult(new List <ClaimError>()));
}
return(result);
}
private IReadOnlyList <PickupBid> GetWinnableBids(IEnumerable <PickupBid> activeBidsForLeagueYear, LeagueOptions options, SystemWideValues systemWideValues)
{
List <PickupBid> winnableBids = new List <PickupBid>();
var enoughBudgetBids = activeBidsForLeagueYear.Where(x => x.BidAmount <= x.Publisher.Budget);
var groupedByGame = enoughBudgetBids.GroupBy(x => x.MasterGame);
foreach (var gameGroup in groupedByGame)
{
PickupBid bestBid;
if (gameGroup.Count() == 1)
{
bestBid = gameGroup.First();
}
else
{
var bestBids = gameGroup.MaxBy(x => x.BidAmount);
//TODO change projections
var bestBidsByProjectedScore = bestBids.MinBy(x => x.Publisher.GetProjectedFantasyPoints(options, systemWideValues, false, true, _clock));
bestBid = bestBidsByProjectedScore.OrderByDescending(x => x.Publisher.DraftPosition).First();
}
winnableBids.Add(bestBid);
}
return(winnableBids);
}
public Task AddNewLeagueYear(League league, int year, LeagueOptions options)
{
throw new NotImplementedException();
}
public Task CreateLeague(League league, int initialYear, LeagueOptions options)
{
throw new NotImplementedException();
}
