public void EarlyAccessReleasedInternationallyComplexSlotEligible()
{
Instant acquisitionTime = InstantPattern.ExtendedIso.Parse("2022-01-31T20:49:24Z").GetValueOrThrow();
var acquisitionDate = acquisitionTime.ToEasternDate();
MasterGame masterGame = CreateComplexMasterGame("Baldur's Gate 3", new LocalDate(2022, 1, 3), null,
new LocalDate(2020, 10, 6), null, null, new List <MasterGameTag>()
{
_tagDictionary["NG"],
_tagDictionary["C-EA"],
});
var leagueTags = new List <LeagueTagStatus>()
{
new LeagueTagStatus(_tagDictionary["PRT"], TagStatus.Banned),
new LeagueTagStatus(_tagDictionary["C-EA"], TagStatus.Banned),
new LeagueTagStatus(_tagDictionary["R-INT"], TagStatus.Banned),
};
var slotTags = new List <LeagueTagStatus>()
{
new LeagueTagStatus(_tagDictionary["C-EA"], TagStatus.Required),
new LeagueTagStatus(_tagDictionary["R-INT"], TagStatus.Required),
new LeagueTagStatus(_tagDictionary["NG"], TagStatus.Required),
new LeagueTagStatus(_tagDictionary["NGF"], TagStatus.Required),
};
var claimErrors = LeagueTagExtensions.GameHasValidTags(leagueTags, slotTags, masterGame, masterGame.Tags, acquisitionDate);
Assert.AreEqual(0, claimErrors.Count);
}
public void UnannouncedRemakeInEligible()
{
Instant acquisitionTime = InstantPattern.ExtendedIso.Parse("2022-01-05T20:49:24Z").GetValueOrThrow();
var acquisitionDate = acquisitionTime.ToEasternDate();
MasterGame masterGame = CreateComplexMasterGame("The Last of Us Remake", new LocalDate(2022, 1, 27), null,
null, null, null, new List <MasterGameTag>()
{
_tagDictionary["RMKE"],
_tagDictionary["UNA"]
});
var leagueTags = new List <LeagueTagStatus>()
{
new LeagueTagStatus(_tagDictionary["PRT"], TagStatus.Banned),
new LeagueTagStatus(_tagDictionary["C-EA"], TagStatus.Banned),
new LeagueTagStatus(_tagDictionary["R-INT"], TagStatus.Banned),
new LeagueTagStatus(_tagDictionary["RMKE"], TagStatus.Banned)
};
var slotTags = new List <LeagueTagStatus>()
{
};
var claimErrors = LeagueTagExtensions.GameHasValidTags(leagueTags, slotTags, masterGame, masterGame.Tags, acquisitionDate);
Assert.AreEqual(1, claimErrors.Count);
Assert.AreEqual("That game is not eligible because the Remake tag has been banned", claimErrors[0].Error);
}
public void PreviouslyUnannouncedRemakeEligible()
{
Instant acquisitionTime = InstantPattern.ExtendedIso.Parse("2022-01-29T20:49:24Z").GetValueOrThrow();
var acquisitionDate = acquisitionTime.ToEasternDate();
MasterGame masterGame = CreateComplexMasterGame("The Last of Us Remake", new LocalDate(2022, 2, 3), null,
null, null, new LocalDate(2022, 2, 2), new List <MasterGameTag>()
{
_tagDictionary["RMKE"],
});
var leagueTags = new List <LeagueTagStatus>()
{
new LeagueTagStatus(_tagDictionary["PRT"], TagStatus.Banned),
new LeagueTagStatus(_tagDictionary["C-EA"], TagStatus.Banned),
new LeagueTagStatus(_tagDictionary["R-INT"], TagStatus.Banned),
};
var slotTags = new List <LeagueTagStatus>()
{
new LeagueTagStatus(_tagDictionary["RMKE"], TagStatus.Required)
};
var claimErrors = LeagueTagExtensions.GameHasValidTags(leagueTags, slotTags, masterGame, masterGame.Tags, acquisitionDate);
Assert.AreEqual(0, claimErrors.Count);
}
public void PreviouslyUnannouncedGameFailsSlotConditions()
{
Instant acquisitionTime = InstantPattern.ExtendedIso.Parse("2022-01-26T20:49:24Z").GetValueOrThrow();
var acquisitionDate = acquisitionTime.ToEasternDate();
MasterGame masterGame = CreateComplexMasterGame("Star Wars Jedi: Fallen Order 2", new LocalDate(2022, 1, 27), null,
null, null, new LocalDate(2022, 1, 25), new List <MasterGameTag>()
{
_tagDictionary["NG"],
});
var leagueTags = new List <LeagueTagStatus>()
{
new LeagueTagStatus(_tagDictionary["PRT"], TagStatus.Banned),
new LeagueTagStatus(_tagDictionary["C-EA"], TagStatus.Banned),
new LeagueTagStatus(_tagDictionary["R-INT"], TagStatus.Banned),
};
var slotTags = new List <LeagueTagStatus>()
{
new LeagueTagStatus(_tagDictionary["RMKE"], TagStatus.Required)
};
var claimErrors = LeagueTagExtensions.GameHasValidTags(leagueTags, slotTags, masterGame, masterGame.Tags, acquisitionDate);
Assert.AreEqual(1, claimErrors.Count);
Assert.AreEqual("That game is not eligible because it does not have any of the following required tags: (Remake)", claimErrors[0].Error);
}
public void EarlyAccessHasGameAfterEarlyAccessInEligible()
{
Instant acquisitionTime = InstantPattern.ExtendedIso.Parse("2022-03-10T20:49:24Z").GetValueOrThrow();
var acquisitionDate = acquisitionTime.ToEasternDate();
MasterGame masterGame = CreateComplexMasterGame("Have a Nice Death", new LocalDate(2022, 1, 3), null,
new LocalDate(2022, 3, 6), null, null, new List <MasterGameTag>()
{
_tagDictionary["NG"],
_tagDictionary["C-EA"],
});
var leagueTags = new List <LeagueTagStatus>()
{
new LeagueTagStatus(_tagDictionary["PRT"], TagStatus.Banned),
new LeagueTagStatus(_tagDictionary["C-EA"], TagStatus.Banned),
};
var slotTags = new List <LeagueTagStatus>();
var claimErrors = LeagueTagExtensions.GameHasValidTags(leagueTags, slotTags, masterGame, masterGame.Tags, acquisitionDate);
Assert.AreEqual(1, claimErrors.Count);
Assert.AreEqual("That game is not eligible because the Currently in Early Access tag has been banned", claimErrors[0].Error);
}
public void PreviouslyUnannouncedLeagueBannedEligible()
{
Instant acquisitionTime = InstantPattern.ExtendedIso.Parse("2022-01-05T20:49:24Z").GetValueOrThrow();
var acquisitionDate = acquisitionTime.ToEasternDate();
MasterGame masterGame = CreateComplexMasterGame("Star Wars Jedi: Fallen Order 2", new LocalDate(2022, 1, 27), null,
null, null, new LocalDate(2022, 1, 25), new List <MasterGameTag>()
{
_tagDictionary["NG"],
});
var leagueTags = new List <LeagueTagStatus>()
{
new LeagueTagStatus(_tagDictionary["PRT"], TagStatus.Banned),
new LeagueTagStatus(_tagDictionary["C-EA"], TagStatus.Banned),
new LeagueTagStatus(_tagDictionary["R-INT"], TagStatus.Banned),
new LeagueTagStatus(_tagDictionary["UNA"], TagStatus.Banned),
};
var slotTags = new List <LeagueTagStatus>()
{
};
var claimErrors = LeagueTagExtensions.GameHasValidTags(leagueTags, slotTags, masterGame, masterGame.Tags, acquisitionDate);
Assert.AreEqual(0, claimErrors.Count);
}
public PossibleRoyaleMasterGameViewModel(MasterGameYear masterGame, IClock clock, RoyaleYearQuarter yearQuarter, bool alreadyOwned, IEnumerable <MasterGameTag> masterGameTags)
{
MasterGame = new MasterGameYearViewModel(masterGame, clock);
WillReleaseInQuarter = masterGame.WillReleaseInQuarter(yearQuarter.YearQuarter);
IsEligible = !LeagueTagExtensions.GetRoyaleEligibilitySettings(masterGameTags).GameIsEligible(masterGame.MasterGame).Any();
AlreadyOwned = alreadyOwned;
Cost = masterGame.GetRoyaleGameCost();
}
public PossibleRoyaleMasterGameViewModel(MasterGameYear masterGame, LocalDate currentDate, RoyaleYearQuarter yearQuarter, bool alreadyOwned, IEnumerable <MasterGameTag> masterGameTags)
{
MasterGame = new MasterGameYearViewModel(masterGame, currentDate);
WillReleaseInQuarter = masterGame.WillReleaseInQuarter(yearQuarter.YearQuarter);
AlreadyOwned = alreadyOwned;
IsEligible = !LeagueTagExtensions.GetRoyaleClaimErrors(masterGameTags, masterGame.MasterGame, currentDate).Any();
IsReleased = masterGame.MasterGame.IsReleased(currentDate);
HasScore = masterGame.MasterGame.CriticScore.HasValue;
Cost = masterGame.GetRoyaleGameCost();
}
public async Task <ClaimResult> PurchaseGame(RoyalePublisher publisher, MasterGameYear masterGame)
{
if (publisher.PublisherGames.Count >= MAX_GAMES)
{
return(new ClaimResult("Roster is full.", null));
}
if (publisher.PublisherGames.Select(x => x.MasterGame).Contains(masterGame))
{
return(new ClaimResult("Publisher already has that game.", null));
}
if (!masterGame.WillReleaseInQuarter(publisher.YearQuarter.YearQuarter))
{
return(new ClaimResult("Game will not release this quarter.", null));
}
var now = _clock.GetCurrentInstant();
var currentDate = now.ToEasternDate();
if (masterGame.MasterGame.IsReleased(currentDate))
{
return(new ClaimResult("Game has been released.", null));
}
if (masterGame.MasterGame.CriticScore.HasValue)
{
return(new ClaimResult("Game has a score.", null));
}
var masterGameTags = await _masterGameRepo.GetMasterGameTags();
var eligibilityErrors = LeagueTagExtensions.GetRoyaleClaimErrors(masterGameTags, masterGame.MasterGame, currentDate);
if (eligibilityErrors.Any())
{
return(new ClaimResult("Game is not eligible under Royale rules.", null));
}
var currentBudget = publisher.Budget;
var gameCost = masterGame.GetRoyaleGameCost();
if (currentBudget < gameCost)
{
return(new ClaimResult("Not enough budget.", null));
}
RoyalePublisherGame game = new RoyalePublisherGame(publisher.PublisherID, publisher.YearQuarter, masterGame, now, gameCost, 0m, null);
await _royaleRepo.PurchaseGame(game);
var nextSlot = publisher.PublisherGames.Count;
return(new ClaimResult(nextSlot));
}
public void SimpleEligibleTest()
{
Instant acquisitionTime = InstantPattern.ExtendedIso.Parse("2022-01-31T20:49:24Z").GetValueOrThrow();
var acquisitionDate = acquisitionTime.ToEasternDate();
MasterGame masterGame = CreateBasicMasterGame("Elden Ring", new LocalDate(2022, 2, 25), _tagDictionary["NGF"]);
var leagueTags = new List <LeagueTagStatus>()
{
new LeagueTagStatus(_tagDictionary["PRT"], TagStatus.Banned)
};
var slotTags = new List <LeagueTagStatus>();
var claimErrors = LeagueTagExtensions.GameHasValidTags(leagueTags, slotTags, masterGame, masterGame.Tags, acquisitionDate);
Assert.AreEqual(0, claimErrors.Count);
}
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 void SimpleInEligibleTest()
{
Instant acquisitionTime = InstantPattern.ExtendedIso.Parse("2022-01-31T20:49:24Z").GetValueOrThrow();
var acquisitionDate = acquisitionTime.ToEasternDate();
MasterGame masterGame = CreateBasicMasterGame("GTA 5 (PS5)", new LocalDate(2022, 2, 25), _tagDictionary["PRT"]);
var leagueTags = new List <LeagueTagStatus>()
{
new LeagueTagStatus(_tagDictionary["PRT"], TagStatus.Banned)
};
var slotTags = new List <LeagueTagStatus>();
var claimErrors = LeagueTagExtensions.GameHasValidTags(leagueTags, slotTags, masterGame, masterGame.Tags, acquisitionDate);
Assert.AreEqual(1, claimErrors.Count);
Assert.AreEqual("That game is not eligible because the Port tag has been banned", claimErrors[0].Error);
}
public async Task <ActionResult <List <PossibleRoyaleMasterGameViewModel> > > PossibleMasterGames(string?gameName, Guid publisherID)
{
RoyalePublisher?publisher = await _royaleService.GetPublisher(publisherID);
if (publisher is null)
{
return(NotFound());
}
var yearQuarter = await _royaleService.GetYearQuarter(publisher.YearQuarter.YearQuarter.Year, publisher.YearQuarter.YearQuarter.Quarter);
if (yearQuarter is null)
{
return(BadRequest());
}
var currentDate = _clock.GetToday();
var masterGameTags = await _interLeagueService.GetMasterGameTags();
var masterGames = await _royaleService.GetMasterGamesForYearQuarter(yearQuarter.YearQuarter);
if (!string.IsNullOrWhiteSpace(gameName))
{
masterGames = MasterGameSearching.SearchMasterGameYears(gameName, masterGames);
}
else
{
masterGames = masterGames
.Where(x => x.WillReleaseInQuarter(yearQuarter.YearQuarter))
.Where(x => !x.MasterGame.IsReleased(currentDate))
.Where(x => !LeagueTagExtensions.GetRoyaleClaimErrors(masterGameTags, x.MasterGame, currentDate).Any())
.Take(1000)
.ToList();
}
var viewModels = masterGames.Select(masterGame =>
new PossibleRoyaleMasterGameViewModel(masterGame, currentDate, yearQuarter, publisher.PublisherGames.Any(y =>
y.MasterGame.MasterGame.Equals(masterGame.MasterGame)), masterGameTags)).ToList();
return(viewModels);
}
public async Task <ActionResult <List <PossibleRoyaleMasterGameViewModel> > > PossibleMasterGames(string gameName, Guid publisherID)
{
Maybe <RoyalePublisher> publisher = await _royaleService.GetPublisher(publisherID);
if (publisher.HasNoValue)
{
return(NotFound());
}
var yearQuarter = await _royaleService.GetYearQuarter(publisher.Value.YearQuarter.YearQuarter.Year, publisher.Value.YearQuarter.YearQuarter.Quarter);
if (yearQuarter.HasNoValue)
{
return(BadRequest());
}
var masterGameTags = await _interLeagueService.GetMasterGameTags();
var masterGames = await _royaleService.GetMasterGamesForYearQuarter(yearQuarter.Value.YearQuarter);
if (!string.IsNullOrWhiteSpace(gameName))
{
masterGames = MasterGameSearching.SearchMasterGameYears(gameName, masterGames);
}
else
{
masterGames = masterGames
.Where(x => x.WillReleaseInQuarter(yearQuarter.Value.YearQuarter))
.Where(x => !x.MasterGame.IsReleased(_clock.GetCurrentInstant()))
.Where(x => !LeagueTagExtensions.GetRoyaleEligibilitySettings(masterGameTags).GameIsEligible(x.MasterGame).Any())
.Take(1000)
.ToList();
}
var viewModels = masterGames.Select(masterGame =>
new PossibleRoyaleMasterGameViewModel(masterGame, _clock, yearQuarter.Value, publisher.Value.PublisherGames.Any(y =>
y.MasterGame.MasterGame.Equals(masterGame.MasterGame)), masterGameTags)).ToList();
return(viewModels);
}
public void SlotInEligibleTest()
{
Instant acquisitionTime = InstantPattern.ExtendedIso.Parse("2022-01-31T20:49:24Z").GetValueOrThrow();
var acquisitionDate = acquisitionTime.ToEasternDate();
MasterGame masterGame = CreateBasicMasterGame("Horizon Forbidden West", new LocalDate(2022, 2, 25), _tagDictionary["NG"]);
var leagueTags = new List <LeagueTagStatus>()
{
new LeagueTagStatus(_tagDictionary["PRT"], TagStatus.Banned)
};
var slotTags = new List <LeagueTagStatus>()
{
new LeagueTagStatus(_tagDictionary["NGF"], TagStatus.Required)
};
var claimErrors = LeagueTagExtensions.GameHasValidTags(leagueTags, slotTags, masterGame, masterGame.Tags, acquisitionDate);
Assert.AreEqual(1, claimErrors.Count);
Assert.AreEqual("That game is not eligible because it does not have any of the following required tags: (New Gaming Franchise)", claimErrors[0].Error);
}
public void EarlyAccessHasGameBeforeEarlyAccessEligible()
{
Instant acquisitionTime = InstantPattern.ExtendedIso.Parse("2022-01-05T20:49:24Z").GetValueOrThrow();
var acquisitionDate = acquisitionTime.ToEasternDate();
MasterGame masterGame = CreateComplexMasterGame("Have a Nice Death", new LocalDate(2022, 1, 3), null,
new LocalDate(2022, 3, 6), null, null, new List <MasterGameTag>()
{
_tagDictionary["NG"],
_tagDictionary["C-EA"],
});
var leagueTags = new List <LeagueTagStatus>()
{
new LeagueTagStatus(_tagDictionary["PRT"], TagStatus.Banned),
new LeagueTagStatus(_tagDictionary["C-EA"], TagStatus.Banned),
};
var slotTags = new List <LeagueTagStatus>();
var claimErrors = LeagueTagExtensions.GameHasValidTags(leagueTags, slotTags, masterGame, masterGame.Tags, acquisitionDate);
Assert.AreEqual(0, claimErrors.Count);
}
public bool CalculateIsCurrentlyIneligible(IEnumerable <MasterGameTag> allMasterGameTags)
{
var royaleTags = LeagueTagExtensions.GetRoyaleEligibilitySettings(allMasterGameTags);
var customCodeTags = royaleTags.Where(x => x.Tag.HasCustomCode).ToList();
var nonCustomCodeTags = royaleTags.Except(customCodeTags).ToList();
var masterGame = MasterGame.MasterGame;
var bannedTags = nonCustomCodeTags.Where(x => x.Status == TagStatus.Banned).Select(x => x.Tag);
var requiredTags = nonCustomCodeTags.Where(x => x.Status == TagStatus.Required).Select(x => x.Tag);
var bannedTagsIntersection = masterGame.Tags.Intersect(bannedTags);
var missingRequiredTags = requiredTags.Except(masterGame.Tags);
if (bannedTagsIntersection.Any() || missingRequiredTags.Any())
{
return(true);
}
var masterGameCustomCodeTags = masterGame.Tags.Where(x => x.HasCustomCode).ToList();
if (!masterGameCustomCodeTags.Any())
{
return(false);
}
var dateGameWasAcquired = Timestamp.InZone(TimeExtensions.EasternTimeZone).Date;
if (masterGame.EarlyAccessReleaseDate.HasValue)
{
var plannedForEarlyAccessTag = customCodeTags.SingleOrDefault(x => x.Tag.Name == "PlannedForEarlyAccess");
if (plannedForEarlyAccessTag is not null)
{
if (plannedForEarlyAccessTag.Status == TagStatus.Banned)
{
return(true);
}
}
var currentlyInEarlyAccessTag = customCodeTags.SingleOrDefault(x => x.Tag.Name == "CurrentlyInEarlyAccess");
if (currentlyInEarlyAccessTag is not null)
{
if (currentlyInEarlyAccessTag.Status == TagStatus.Banned)
{
var pickedUpBeforeInEarlyAccess = dateGameWasAcquired < masterGame.EarlyAccessReleaseDate.Value;
if (!pickedUpBeforeInEarlyAccess)
{
return(true);
}
}
}
}
if (masterGame.InternationalReleaseDate.HasValue)
{
var willReleaseInternationallyFirstTag = customCodeTags.SingleOrDefault(x => x.Tag.Name == "WillReleaseInternationallyFirst");
if (willReleaseInternationallyFirstTag is not null)
{
if (willReleaseInternationallyFirstTag.Status == TagStatus.Banned)
{
return(true);
}
}
var releasedInternationallyTag = customCodeTags.SingleOrDefault(x => x.Tag.Name == "ReleasedInternationally");
if (releasedInternationallyTag is not null)
{
if (releasedInternationallyTag.Status == TagStatus.Banned)
{
var pickedUpBeforeReleasedInternationally = dateGameWasAcquired < masterGame.InternationalReleaseDate.Value;
if (!pickedUpBeforeReleasedInternationally)
{
return(true);
}
}
}
}
return(false);
}
public IReadOnlyList <ClaimError> CheckGameAgainstTags(IEnumerable <LeagueTagStatus> leagueTags, IEnumerable <LeagueTagStatus> slotTags)
{
var tagsToUse = TagOverrides.Any() ? TagOverrides : MasterGame.Tags;
return(LeagueTagExtensions.GameHasValidTags(leagueTags, slotTags, MasterGame, tagsToUse, DateAcquired));
}
