public async Task <IReadOnlyList <PossibleMasterGameYear> > GetQueuedPossibleGames(Publisher currentPublisher, IReadOnlyList <Publisher> publishersInLeagueForYear,
IEnumerable <QueuedGame> queuedGames)
{
HashSet <MasterGame> publisherMasterGames = publishersInLeagueForYear
.SelectMany(x => x.PublisherGames)
.Where(x => !x.CounterPick && x.MasterGame.HasValue)
.Select(x => x.MasterGame.Value.MasterGame)
.ToHashSet();
HashSet <MasterGame> myPublisherMasterGames = currentPublisher.MyMasterGames;
IReadOnlyList <MasterGameYear> masterGameYears = await _interLeagueService.GetMasterGameYears(currentPublisher.LeagueYear.Year, true);
var masterGamesForThisYear = masterGameYears.Where(x => x.Year == currentPublisher.LeagueYear.Year);
var masterGameYearDictionary = masterGamesForThisYear.ToDictionary(x => x.MasterGame.MasterGameID, y => y);
List <PossibleMasterGameYear> possibleMasterGames = new List <PossibleMasterGameYear>();
foreach (var queuedGame in queuedGames)
{
var masterGame = masterGameYearDictionary[queuedGame.MasterGame.MasterGameID];
PossibleMasterGameYear possibleMasterGame = GetPossibleMasterGameYear(masterGame, publisherMasterGames,
myPublisherMasterGames, currentPublisher.LeagueYear.Options.AllowedEligibilitySettings);
possibleMasterGames.Add(possibleMasterGame);
}
return(possibleMasterGames);
}
public async Task <IReadOnlyList <PossibleMasterGameYear> > SearchGames(string searchName, LeagueYear leagueYear, Publisher currentPublisher, int year)
{
HashSet <MasterGame> publisherMasterGames = leagueYear.Publishers
.SelectMany(x => x.PublisherGames)
.Where(x => !x.CounterPick && x.MasterGame is not null)
.Select(x => x.MasterGame !.MasterGame)
.ToHashSet();
HashSet <MasterGame> myPublisherMasterGames = currentPublisher.MyMasterGames;
IReadOnlyList <MasterGameYear> masterGames = await _interLeagueService.GetMasterGameYears(year);
IReadOnlyList <MasterGameYear> matchingMasterGames = MasterGameSearching.SearchMasterGameYears(searchName, masterGames);
List <PossibleMasterGameYear> possibleMasterGames = new List <PossibleMasterGameYear>();
var slots = currentPublisher.GetPublisherSlots(leagueYear.Options);
var openNonCounterPickSlots = slots.Where(x => !x.CounterPick && x.PublisherGame is null).OrderBy(x => x.SlotNumber).ToList();
LocalDate currentDate = _clock.GetToday();
foreach (var masterGame in matchingMasterGames)
{
var eligibilityFactors = leagueYear.GetEligibilityFactorsForMasterGame(masterGame.MasterGame, currentDate);
PossibleMasterGameYear possibleMasterGame = GetPossibleMasterGameYear(masterGame, openNonCounterPickSlots, publisherMasterGames,
myPublisherMasterGames, eligibilityFactors, currentDate);
possibleMasterGames.Add(possibleMasterGame);
}
return(possibleMasterGames);
}
public async Task <IReadOnlyList <PossibleMasterGameYear> > GetTopAvailableGames(Publisher currentPublisher, IReadOnlyList <Publisher> publishersInLeagueForYear, int year)
{
HashSet <MasterGame> publisherMasterGames = publishersInLeagueForYear
.SelectMany(x => x.PublisherGames)
.Where(x => !x.CounterPick && x.MasterGame.HasValue)
.Select(x => x.MasterGame.Value.MasterGame)
.ToHashSet();
HashSet <MasterGame> myPublisherMasterGames = currentPublisher.MyMasterGames;
IReadOnlyList <MasterGameYear> masterGames = await _interLeagueService.GetMasterGameYears(year, true);
IReadOnlyList <MasterGameYear> matchingMasterGames = masterGames.OrderByDescending(x => x.DateAdjustedHypeFactor).ToList();
List <PossibleMasterGameYear> possibleMasterGames = new List <PossibleMasterGameYear>();
foreach (var masterGame in matchingMasterGames)
{
PossibleMasterGameYear possibleMasterGame = GetPossibleMasterGameYear(masterGame, publisherMasterGames,
myPublisherMasterGames, currentPublisher.LeagueYear.Options.AllowedEligibilitySettings);
if (!possibleMasterGame.IsAvailable)
{
continue;
}
possibleMasterGames.Add(possibleMasterGame);
}
return(possibleMasterGames);
}
public async Task <IReadOnlyList <PossibleMasterGameYear> > GetTopAvailableGames(LeagueYear leagueYear, Publisher currentPublisher)
{
HashSet <MasterGame> publisherMasterGames = leagueYear.Publishers
.SelectMany(x => x.PublisherGames)
.Where(x => !x.CounterPick && x.MasterGame is not null)
.Select(x => x.MasterGame !.MasterGame)
.ToHashSet();
HashSet <MasterGame> myPublisherMasterGames = currentPublisher.MyMasterGames;
IReadOnlyList <MasterGameYear> masterGames = await _interLeagueService.GetMasterGameYears(leagueYear.Year);
IReadOnlyList <MasterGameYear> matchingMasterGames = masterGames.OrderByDescending(x => x.DateAdjustedHypeFactor).ToList();
List <PossibleMasterGameYear> possibleMasterGames = new List <PossibleMasterGameYear>();
var slots = currentPublisher.GetPublisherSlots(leagueYear.Options);
var openNonCounterPickSlots = slots.Where(x => !x.CounterPick && x.PublisherGame is null).OrderBy(x => x.SlotNumber).ToList();
LocalDate currentDate = _clock.GetToday();
foreach (var masterGame in matchingMasterGames)
{
var eligibilityFactors = leagueYear.GetEligibilityFactorsForMasterGame(masterGame.MasterGame, currentDate);
PossibleMasterGameYear possibleMasterGame = GetPossibleMasterGameYear(masterGame, openNonCounterPickSlots,
publisherMasterGames, myPublisherMasterGames, eligibilityFactors, currentDate);
if (!possibleMasterGame.IsAvailable)
{
continue;
}
possibleMasterGames.Add(possibleMasterGame);
}
return(possibleMasterGames);
}
public async Task <IReadOnlyList <PossibleMasterGameYear> > GetQueuedPossibleGames(LeagueYear leagueYear, Publisher currentPublisher, IEnumerable <QueuedGame> queuedGames)
{
HashSet <MasterGame> publisherMasterGames = leagueYear.Publishers
.SelectMany(x => x.PublisherGames)
.Where(x => !x.CounterPick && x.MasterGame is not null)
.Select(x => x.MasterGame !.MasterGame)
.ToHashSet();
HashSet <MasterGame> myPublisherMasterGames = currentPublisher.MyMasterGames;
IReadOnlyList <MasterGameYear> masterGameYears = await _interLeagueService.GetMasterGameYears(leagueYear.Year);
var masterGamesForThisYear = masterGameYears.Where(x => x.Year == leagueYear.Year);
var masterGameYearDictionary = masterGamesForThisYear.ToDictionary(x => x.MasterGame.MasterGameID, y => y);
var slots = currentPublisher.GetPublisherSlots(leagueYear.Options);
var openNonCounterPickSlots = slots.Where(x => !x.CounterPick && x.PublisherGame is null).OrderBy(x => x.SlotNumber).ToList();
List <PossibleMasterGameYear> possibleMasterGames = new List <PossibleMasterGameYear>();
LocalDate currentDate = _clock.GetToday();
foreach (var queuedGame in queuedGames)
{
var masterGame = masterGameYearDictionary[queuedGame.MasterGame.MasterGameID];
var eligibilityFactors = leagueYear.GetEligibilityFactorsForMasterGame(masterGame.MasterGame, currentDate);
PossibleMasterGameYear possibleMasterGame = GetPossibleMasterGameYear(masterGame, openNonCounterPickSlots,
publisherMasterGames, myPublisherMasterGames, eligibilityFactors, currentDate);
possibleMasterGames.Add(possibleMasterGame);
}
return(possibleMasterGames);
}
public PossibleMasterGameYearViewModel(PossibleMasterGameYear masterGame, IClock clock)
{
MasterGame = new MasterGameYearViewModel(masterGame.MasterGame, clock);
Taken = masterGame.Taken;
AlreadyOwned = masterGame.AlreadyOwned;
IsEligible = masterGame.IsEligible;
IsReleased = masterGame.IsReleased;
WillRelease = masterGame.WillRelease;
HasScore = masterGame.HasScore;
IsAvailable = masterGame.IsAvailable;
}
public PossibleMasterGameYearViewModel(PossibleMasterGameYear masterGame, LocalDate currentDate)
{
MasterGame = new MasterGameYearViewModel(masterGame.MasterGame, currentDate);
Taken = masterGame.Taken;
AlreadyOwned = masterGame.AlreadyOwned;
IsEligible = masterGame.IsEligible;
IsEligibleInOpenSlot = masterGame.IsEligibleInOpenSlot;
IsReleased = masterGame.IsReleased;
WillRelease = masterGame.WillRelease;
HasScore = masterGame.HasScore;
IsAvailable = masterGame.IsAvailable;
}
public PossibleMasterGameYear GetPossibleMasterGameYear(MasterGameYear masterGame, HashSet <MasterGame> publisherStandardMasterGames, HashSet <MasterGame> myPublisherMasterGames, IEnumerable <LeagueTagStatus> leagueTags)
{
var eligibilityErrors = leagueTags.GameIsEligible(masterGame.MasterGame);
bool isEligible = !eligibilityErrors.Any();
bool taken = publisherStandardMasterGames.Contains(masterGame.MasterGame);
bool alreadyOwned = myPublisherMasterGames.Contains(masterGame.MasterGame);
bool isReleased = masterGame.MasterGame.IsReleased(_clock.GetCurrentInstant());
bool willRelease = masterGame.WillRelease();
bool hasScore = masterGame.MasterGame.CriticScore.HasValue;
PossibleMasterGameYear possibleMasterGame = new PossibleMasterGameYear(masterGame, taken, alreadyOwned, isEligible, isReleased, willRelease, hasScore);
return(possibleMasterGame);
}
public PossibleMasterGameYear GetPossibleMasterGameYear(MasterGameYear masterGame, HashSet <MasterGame> publisherMasterGames, HashSet <MasterGame> myPublisherMasterGames,
EligibilitySettings eligibilitySettings)
{
var eligibilityErrors = eligibilitySettings.GameIsEligible(masterGame.MasterGame);
bool isEligible = !eligibilityErrors.Any();
bool taken = publisherMasterGames.Contains(masterGame.MasterGame);
bool alreadyOwned = myPublisherMasterGames.Contains(masterGame.MasterGame);
bool isReleased = masterGame.MasterGame.IsReleased(_clock);
bool willRelease = masterGame.WillRelease();
bool hasScore = masterGame.MasterGame.CriticScore.HasValue;
PossibleMasterGameYear possibleMasterGame = new PossibleMasterGameYear(masterGame, taken, alreadyOwned, isEligible, isReleased, willRelease, hasScore);
return(possibleMasterGame);
}
public static PossibleMasterGameYear GetPossibleMasterGameYear(MasterGameYear masterGame, IReadOnlyList <PublisherSlot> openNonCounterPickSlots,
HashSet <MasterGame> publisherStandardMasterGames, HashSet <MasterGame> myPublisherMasterGames,
MasterGameWithEligibilityFactors eligibilityFactors, LocalDate currentDate)
{
bool isEligible = SlotEligibilityService.GameIsEligibleInLeagueYear(eligibilityFactors);
bool taken = publisherStandardMasterGames.Contains(masterGame.MasterGame);
bool alreadyOwned = myPublisherMasterGames.Contains(masterGame.MasterGame);
bool isReleased = masterGame.MasterGame.IsReleased(currentDate);
bool willRelease = masterGame.WillRelease();
bool hasScore = masterGame.MasterGame.CriticScore.HasValue;
bool isEligibleInOpenSlot = SlotEligibilityService.GameIsEligibleInOpenSlot(openNonCounterPickSlots, eligibilityFactors);
PossibleMasterGameYear possibleMasterGame = new PossibleMasterGameYear(masterGame, taken, alreadyOwned, isEligible, isEligibleInOpenSlot, isReleased, willRelease, hasScore);
return(possibleMasterGame);
}
public PossibleMasterGameYear GetPossibleMasterGameYear(MasterGameYear masterGame, IReadOnlyList <PublisherSlot> openNonCounterPickSlots,
HashSet <MasterGame> publisherStandardMasterGames, HashSet <MasterGame> myPublisherMasterGames,
MasterGameWithEligibilityFactors eligibilityFactors, IEnumerable <LeagueTagStatus> tagsForSlot, LocalDate currentDate)
{
var tagsToUse = eligibilityFactors.TagOverrides.Any() ? eligibilityFactors.TagOverrides : masterGame.MasterGame.Tags;
var claimErrors = LeagueTagExtensions.GameHasValidTags(tagsForSlot, new List <LeagueTagStatus>(), masterGame.MasterGame, tagsToUse, currentDate);
bool isEligible = !claimErrors.Any();
bool taken = publisherStandardMasterGames.Contains(masterGame.MasterGame);
bool alreadyOwned = myPublisherMasterGames.Contains(masterGame.MasterGame);
bool isReleased = masterGame.MasterGame.IsReleased(currentDate);
bool willRelease = masterGame.WillRelease();
bool hasScore = masterGame.MasterGame.CriticScore.HasValue;
bool isEligibleInOpenSlot = SlotEligibilityService.GameIsEligibleInOpenSlot(openNonCounterPickSlots, eligibilityFactors);
PossibleMasterGameYear possibleMasterGame = new PossibleMasterGameYear(masterGame, taken, alreadyOwned, isEligible, isEligibleInOpenSlot, isReleased, willRelease, hasScore);
return(possibleMasterGame);
}
public async Task <IReadOnlyList <PossibleMasterGameYear> > SearchGames(string searchName, Publisher currentPublisher, IReadOnlyList <Publisher> publishersInLeagueForYear, int year)
{
HashSet <MasterGame> publisherMasterGames = publishersInLeagueForYear
.SelectMany(x => x.MyMasterGames)
.ToHashSet();
HashSet <MasterGame> myPublisherMasterGames = currentPublisher.MyMasterGames;
IReadOnlyList <MasterGameYear> masterGames = await _interLeagueService.GetMasterGameYears(year, true);
IReadOnlyList <MasterGameYear> matchingMasterGames = MasterGameSearching.SearchMasterGameYears(searchName, masterGames);
List <PossibleMasterGameYear> possibleMasterGames = new List <PossibleMasterGameYear>();
foreach (var masterGame in matchingMasterGames)
{
PossibleMasterGameYear possibleMasterGame = GetPossibleMasterGameYear(masterGame, publisherMasterGames,
myPublisherMasterGames, currentPublisher.LeagueYear.Options.AllowedEligibilitySettings);
possibleMasterGames.Add(possibleMasterGame);
}
return(possibleMasterGames);
}
