public async Task <ClaimResult> ClaimGame(ClaimGameDomainRequest request, bool managerAction, bool draft, IReadOnlyList <Publisher> publishersForYear)
{
Maybe <MasterGameYear> masterGameYear = Maybe <MasterGameYear> .None;
if (request.MasterGame.HasValue)
{
masterGameYear = new MasterGameYear(request.MasterGame.Value, request.Publisher.LeagueYear.Year);
}
PublisherGame playerGame = new PublisherGame(request.Publisher.PublisherID, Guid.NewGuid(), request.GameName, _clock.GetCurrentInstant(), request.CounterPick, null, null,
masterGameYear, request.DraftPosition, request.OverallDraftPosition);
var supportedYears = await _fantasyCriticRepo.GetSupportedYears();
LeagueYear leagueYear = request.Publisher.LeagueYear;
ClaimResult claimResult = CanClaimGame(request, supportedYears, leagueYear, publishersForYear, null, false);
if (!claimResult.Success)
{
return(claimResult);
}
LeagueAction leagueAction = new LeagueAction(request, _clock.GetCurrentInstant(), managerAction, draft, request.AutoDraft);
await _fantasyCriticRepo.AddLeagueAction(leagueAction);
await _fantasyCriticRepo.AddPublisherGame(playerGame);
return(claimResult);
}
public async Task <ClaimResult> ClaimGame(ClaimGameDomainRequest request, bool managerAction, bool draft, bool drafting)
{
MasterGameYear?masterGameYear = null;
if (request.MasterGame is not null)
{
masterGameYear = new MasterGameYear(request.MasterGame, request.LeagueYear.Year);
}
ClaimResult claimResult = CanClaimGame(request, null, null, true, drafting);
if (!claimResult.Success)
{
return(claimResult);
}
PublisherGame playerGame = new PublisherGame(request.Publisher.PublisherID, Guid.NewGuid(), request.GameName, _clock.GetCurrentInstant(), request.CounterPick, null, false, null,
masterGameYear, claimResult.BestSlotNumber !.Value, request.DraftPosition, request.OverallDraftPosition, null, null);
LeagueAction leagueAction = new LeagueAction(request, _clock.GetCurrentInstant(), managerAction, draft, request.AutoDraft);
await _fantasyCriticRepo.AddLeagueAction(leagueAction);
await _fantasyCriticRepo.AddPublisherGame(playerGame);
return(claimResult);
}
public MasterGameYearViewModel(MasterSubGame masterSubGame, MasterGameYear masterGame, IClock clock)
{
MasterGameID = masterSubGame.MasterGameID;
Year = masterGame.Year;
GameName = masterSubGame.GameName;
EstimatedReleaseDate = masterSubGame.EstimatedReleaseDate;
SortableEstimatedReleaseDate = masterSubGame.SortableEstimatedReleaseDate;
ReleaseDate = masterSubGame.ReleaseDate;
IsReleased = masterSubGame.IsReleased(clock);
WillRelease = masterGame.WillRelease();
CriticScore = masterSubGame.CriticScore;
AveragedScore = false;
EligibilitySettings = new EligibilitySettingsViewModel(masterGame.MasterGame.EligibilitySettings, false);
OpenCriticID = masterSubGame.OpenCriticID;
SubGames = null;
PercentStandardGame = masterGame.PercentStandardGame;
PercentCounterPick = masterGame.PercentCounterPick;
EligiblePercentStandardGame = masterGame.EligiblePercentStandardGame;
EligiblePercentCounterPick = masterGame.EligiblePercentCounterPick;
AverageDraftPosition = masterGame.AverageDraftPosition;
HypeFactor = masterGame.HypeFactor;
DateAdjustedHypeFactor = masterGame.DateAdjustedHypeFactor;
ProjectedFantasyPoints = masterGame.GetAlwaysProjectedFantasyPoints(new StandardScoringSystem(), false);
ProjectedOrRealFantasyPoints = masterGame.GetProjectedOrRealFantasyPoints(new StandardScoringSystem(), false, clock);
AddedTimestamp = masterGame.MasterGame.AddedTimestamp;
}
public async Task <IReadOnlyList <MasterGameYear> > GetMasterGameYears(int year, bool useCache)
{
if (useCache && _masterGameYearsCache.ContainsKey(year))
{
return(_masterGameYearsCache[year].Values.ToList());
}
string sqlSource = useCache ? "tbl_caching_mastergameyear" : "vw_cacher_mastergameyear";
using (var connection = new MySqlConnection(_connectionString))
{
var masterGameResults = await connection.QueryAsync <MasterGameYearEntity>($"select * from {sqlSource} where Year = @year;", new { year });
var masterSubGameResults = await connection.QueryAsync <MasterSubGameEntity>("select * from tbl_mastergame_subgame;");
var masterSubGames = masterSubGameResults.Select(x => x.ToDomain()).ToList();
List <MasterGameYear> masterGames = new List <MasterGameYear>();
foreach (var entity in masterGameResults)
{
EligibilityLevel eligibilityLevel = await GetEligibilityLevel(entity.EligibilityLevel);
MasterGameYear domain = entity.ToDomain(masterSubGames.Where(sub => sub.MasterGameID == entity.MasterGameID),
eligibilityLevel, year);
masterGames.Add(domain);
}
if (useCache)
{
_masterGameYearsCache[year] = masterGames.ToDictionary(x => x.MasterGame.MasterGameID, y => y);
}
return(masterGames);
}
}
public PossibleRoyaleMasterGameViewModel(MasterGameYear masterGame, IClock clock, RoyaleYearQuarter yearQuarter, bool alreadyOwned)
{
MasterGame = new MasterGameYearViewModel(masterGame, clock);
WillReleaseInQuarter = masterGame.WillReleaseInQuarter(yearQuarter.YearQuarter);
IsEligible = !EligibilitySettings.GetRoyaleEligibilitySettings().GameIsEligible(masterGame.MasterGame).Any();
AlreadyOwned = alreadyOwned;
Cost = masterGame.GetRoyaleGameCost();
}
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 RoyalePublisherGame ToDomain(RoyaleYearQuarter yearQuarter, MasterGameYear masterGameYear)
{
if (Timestamp.Kind != DateTimeKind.Utc)
{
LocalDateTime localDateTime = LocalDateTime.FromDateTime(Timestamp);
Instant instant = localDateTime.InZoneStrictly(DateTimeZoneProviders.Tzdb.GetZoneOrNull("America/New_York")).ToInstant();
return(new RoyalePublisherGame(PublisherID, yearQuarter, masterGameYear, instant, AmountSpent, AdvertisingMoney, FantasyPoints));
}
return(new RoyalePublisherGame(PublisherID, yearQuarter, masterGameYear, Instant.FromDateTimeUtc(Timestamp), AmountSpent, AdvertisingMoney, FantasyPoints));
}
public RoyalePublisherGame ToDomain(RoyaleYearQuarter yearQuarter, MasterGameYear masterGameYear)
{
if (Timestamp.Kind != DateTimeKind.Utc)
{
LocalDateTime localDateTime = LocalDateTime.FromDateTime(Timestamp);
Instant instant = localDateTime.InZoneStrictly(TimeExtensions.EasternTimeZone).ToInstant();
return(new RoyalePublisherGame(PublisherID, yearQuarter, masterGameYear, instant, AmountSpent, AdvertisingMoney, FantasyPoints));
}
return(new RoyalePublisherGame(PublisherID, yearQuarter, masterGameYear, Instant.FromDateTimeUtc(Timestamp), AmountSpent, AdvertisingMoney, FantasyPoints));
}
public UpcomingGameViewModel(MasterGameYear masterGame, IEnumerable <Publisher> publishers, IEnumerable <Publisher> standardGamePublishers, bool userMode, IClock clock)
{
MasterGame = new MasterGameYearViewModel(masterGame, clock);
MasterGameID = masterGame.MasterGame.MasterGameID;
GameName = masterGame.MasterGame.GameName;
EstimatedReleaseDate = masterGame.MasterGame.EstimatedReleaseDate;
SortableEstimatedReleaseDate = masterGame.MasterGame.GetDefiniteSortableEstimatedReleaseDate();
ReleaseDate = masterGame.MasterGame.ReleaseDate;
if (userMode)
{
if (publishers.Count() == 1)
{
var publisher = publishers.Single();
LeagueID = publisher.LeagueYear.League.LeagueID;
Year = publisher.LeagueYear.Year;
LeagueName = publisher.LeagueYear.League.LeagueName;
PublisherID = publisher.PublisherID;
PublisherName = publisher.PublisherName;
}
else
{
LeagueName = $"{publishers.Count()} Leagues";
PublisherName = "Multiple";
}
}
else
{
if (publishers.Count() == 1)
{
var publisher = publishers.Single();
LeagueID = publisher.LeagueYear.League.LeagueID;
Year = publisher.LeagueYear.Year;
LeagueName = publisher.LeagueYear.League.LeagueName;
PublisherID = publisher.PublisherID;
PublisherName = publisher.PublisherName;
}
else if (standardGamePublishers.Count() == 1)
{
var publisher = standardGamePublishers.Single();
var counterPickPublisher = publishers.Single(x => x.PublisherID != publisher.PublisherID);
LeagueID = publisher.LeagueYear.League.LeagueID;
Year = publisher.LeagueYear.Year;
LeagueName = publisher.LeagueYear.League.LeagueName;
PublisherID = publisher.PublisherID;
PublisherName = publisher.PublisherName;
CounterPickPublisherID = counterPickPublisher.PublisherID;
CounterPickPublisherName = counterPickPublisher.PublisherName;
}
else
{
throw new Exception($"Problem with upcoming games. Happened for Game: {masterGame.MasterGame.GameName} and publisherIDs: {string.Join('|', publishers.Select(x => x.PublisherID))}");
}
}
}
public SingleGameNewsViewModel(MasterGameYear masterGame, IReadOnlyList <LeagueYearPublisherPair> publishersPairsThatHaveGame, bool userMode, LocalDate currentDate)
{
MasterGame = new MasterGameYearViewModel(masterGame, currentDate);
MasterGameID = masterGame.MasterGame.MasterGameID;
GameName = masterGame.MasterGame.GameName;
EstimatedReleaseDate = masterGame.MasterGame.EstimatedReleaseDate;
MaximumReleaseDate = masterGame.MasterGame.GetDefiniteMaximumReleaseDate();
ReleaseDate = masterGame.MasterGame.ReleaseDate;
if (userMode)
{
if (publishersPairsThatHaveGame.Count() == 1)
{
var publisherPair = publishersPairsThatHaveGame.Single();
LeagueID = publisherPair.LeagueYear.League.LeagueID;
Year = publisherPair.LeagueYear.Year;
LeagueName = publisherPair.LeagueYear.League.LeagueName;
PublisherID = publisherPair.Publisher.PublisherID;
PublisherName = publisherPair.Publisher.PublisherName;
}
else
{
LeagueName = $"{publishersPairsThatHaveGame.Count()} Leagues";
PublisherName = "Multiple";
}
}
else
{
if (publishersPairsThatHaveGame.Count() == 1)
{
var publisherPair = publishersPairsThatHaveGame.Single();
LeagueID = publisherPair.LeagueYear.League.LeagueID;
Year = publisherPair.LeagueYear.Year;
LeagueName = publisherPair.LeagueYear.League.LeagueName;
PublisherID = publisherPair.Publisher.PublisherID;
PublisherName = publisherPair.Publisher.PublisherName;
}
else if (publishersPairsThatHaveGame.Count() == 2)
{
var standardPublisherPair = publishersPairsThatHaveGame.Single(x => x.Publisher.PublisherGames.Where(y => !y.CounterPick).Where(y => y.MasterGame is not null).Any(y => y.MasterGame !.MasterGame.MasterGameID == masterGame.MasterGame.MasterGameID));
var counterPickPublisherPair = publishersPairsThatHaveGame.Single(x => x.Publisher.PublisherID != standardPublisherPair.Publisher.PublisherID);
LeagueID = standardPublisherPair.LeagueYear.League.LeagueID;
Year = standardPublisherPair.LeagueYear.Year;
LeagueName = standardPublisherPair.LeagueYear.League.LeagueName;
PublisherID = standardPublisherPair.Publisher.PublisherID;
PublisherName = standardPublisherPair.Publisher.PublisherName;
CounterPickPublisherID = counterPickPublisherPair.Publisher.PublisherID;
CounterPickPublisherName = counterPickPublisherPair.Publisher.PublisherName;
}
else
{
throw new Exception($"Problem with upcoming games. Happened for Game: {masterGame.MasterGame.GameName} and publisherIDs: {string.Join('|', publishersPairsThatHaveGame.Select(x => x.Publisher.PublisherID))}");
}
}
}
public RoyalePublisherGame(Guid publisherID, RoyaleYearQuarter yearQuarter, MasterGameYear masterGame, Instant timestamp,
decimal amountSpent, decimal advertisingMoney, decimal?fantasyPoints)
{
PublisherID = publisherID;
YearQuarter = yearQuarter;
MasterGame = masterGame;
Timestamp = timestamp;
AmountSpent = amountSpent;
AdvertisingMoney = advertisingMoney;
FantasyPoints = fantasyPoints;
}
public PossibleMasterGameYear(MasterGameYear masterGame, bool taken, bool alreadyOwned, bool isEligible, bool isEligibleInOpenSlot,
bool isReleased, bool willRelease, bool hasScore)
{
MasterGame = masterGame;
Taken = taken;
AlreadyOwned = alreadyOwned;
IsEligible = isEligible;
IsEligibleInOpenSlot = isEligibleInOpenSlot;
IsReleased = isReleased;
WillRelease = willRelease;
HasScore = hasScore;
}
public Task <MasterGameYear?> GetMasterGameYear(Guid masterGameID, int year)
{
var matchingGame = _masterGames.SingleOrDefault(x => x.MasterGameID == masterGameID);
if (matchingGame is null)
{
return(Task.FromResult <MasterGameYear?>(null));
}
var masterGameYear = new MasterGameYear(matchingGame, year);
return(Task.FromResult <MasterGameYear?>(masterGameYear));
}
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 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 MasterGameYearViewModel(MasterGameYear masterGame, LocalDate currentDate)
{
MasterGameID = masterGame.MasterGame.MasterGameID;
Year = masterGame.Year;
GameName = masterGame.MasterGame.GameName;
EstimatedReleaseDate = masterGame.MasterGame.EstimatedReleaseDate;
MinimumReleaseDate = masterGame.MasterGame.MinimumReleaseDate;
MaximumReleaseDate = masterGame.MasterGame.GetDefiniteMaximumReleaseDate();
EarlyAccessReleaseDate = masterGame.MasterGame.EarlyAccessReleaseDate;
InternationalReleaseDate = masterGame.MasterGame.InternationalReleaseDate;
AnnouncementDate = masterGame.MasterGame.AnnouncementDate;
ReleaseDate = masterGame.MasterGame.ReleaseDate;
IsReleased = masterGame.MasterGame.IsReleased(currentDate);
WillRelease = masterGame.WillRelease();
DelayContention = masterGame.MasterGame.DelayContention;
CriticScore = masterGame.MasterGame.CriticScore;
FantasyPoints = masterGame.GetFantasyPoints(ScoringSystem.GetDefaultScoringSystem(Year), false, currentDate);
AveragedScore = masterGame.MasterGame.AveragedScore;
OpenCriticID = masterGame.MasterGame.OpenCriticID;
GGToken = masterGame.MasterGame.GGToken;
SubGames = masterGame.MasterGame.SubGames.Select(x => new MasterGameYearViewModel(x, masterGame, currentDate)).ToList();
Tags = masterGame.MasterGame.Tags.Select(x => x.Name).ToList();
ReadableTags = masterGame.MasterGame.Tags.Select(x => x.ReadableName).ToList();
BoxartFileName = masterGame.MasterGame.BoxartFileName;
GGCoverArtFileName = masterGame.MasterGame.GGCoverArtFileName;
PercentStandardGame = masterGame.PercentStandardGame;
PercentCounterPick = masterGame.PercentCounterPick;
AdjustedPercentCounterPick = masterGame.AdjustedPercentCounterPick;
if (masterGame.MasterGame.EligibilityChanged)
{
EligiblePercentStandardGame = masterGame.PercentStandardGame;
}
else
{
EligiblePercentStandardGame = masterGame.EligiblePercentStandardGame;
}
AverageDraftPosition = masterGame.AverageDraftPosition;
HypeFactor = masterGame.HypeFactor;
DateAdjustedHypeFactor = masterGame.DateAdjustedHypeFactor;
PeakHypeFactor = masterGame.PeakHypeFactor;
ProjectedFantasyPoints = masterGame.GetProjectedFantasyPoints(ScoringSystem.GetDefaultScoringSystem(Year), false);
ProjectedOrRealFantasyPoints = FantasyPoints ?? ProjectedFantasyPoints;
AddedTimestamp = masterGame.MasterGame.AddedTimestamp;
}
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 <ClaimResult> PurchaseGame(RoyalePublisher publisher, MasterGameYear masterGame)
{
if (publisher.PublisherGames.Count >= MAX_GAMES)
{
return(new ClaimResult("Roster is full."));
}
if (publisher.PublisherGames.Select(x => x.MasterGame).Contains(masterGame))
{
return(new ClaimResult("Publisher already has that game."));
}
if (!masterGame.WillReleaseInQuarter(publisher.YearQuarter.YearQuarter))
{
return(new ClaimResult("Game will not release this quarter."));
}
if (masterGame.MasterGame.IsReleased(_clock.GetCurrentInstant()))
{
return(new ClaimResult("Game has been released."));
}
if (masterGame.MasterGame.CriticScore.HasValue)
{
return(new ClaimResult("Game has a score."));
}
var eligibilityErrors = EligibilitySettings.GetRoyaleEligibilitySettings().GameIsEligible(masterGame.MasterGame);
if (eligibilityErrors.Any())
{
return(new ClaimResult("Game is not eligible under Royale rules."));
}
var currentBudget = publisher.Budget;
var gameCost = masterGame.GetRoyaleGameCost();
if (currentBudget < gameCost)
{
return(new ClaimResult("Not enough budget."));
}
RoyalePublisherGame game = new RoyalePublisherGame(publisher.PublisherID, publisher.YearQuarter, masterGame, _clock.GetCurrentInstant(), gameCost, 0m, null);
await _royaleRepo.PurchaseGame(game);
return(new ClaimResult());
}
public MasterGameCalculatedStats(MasterGame masterGame, MasterGameYear cachedMasterGameYear)
{
MasterGame = masterGame;
Year = cachedMasterGameYear.Year;
PercentStandardGame = cachedMasterGameYear.PercentStandardGame;
PercentCounterPick = cachedMasterGameYear.PercentCounterPick;
EligiblePercentStandardGame = cachedMasterGameYear.EligiblePercentStandardGame;
EligiblePercentCounterPick = cachedMasterGameYear.EligiblePercentCounterPick;
NumberOfBids = cachedMasterGameYear.NumberOfBids;
TotalBidAmount = cachedMasterGameYear.TotalBidAmount;
BidPercentile = cachedMasterGameYear.BidPercentile;
AverageDraftPosition = cachedMasterGameYear.AverageDraftPosition;
AverageWinningBid = cachedMasterGameYear.AverageWinningBid;
HypeFactor = cachedMasterGameYear.HypeFactor;
DateAdjustedHypeFactor = cachedMasterGameYear.DateAdjustedHypeFactor;
LinearRegressionHypeFactor = cachedMasterGameYear.LinearRegressionHypeFactor;
}
public async Task <Maybe <MasterGameYear> > GetMasterGameYear(Guid masterGameID, int year)
{
using (var connection = new MySqlConnection(_connectionString))
{
MasterGameYearEntity masterGame = await connection.QuerySingleOrDefaultAsync <MasterGameYearEntity>("select * from vwmastergame where MasterGameID = @masterGameID and Year = @year", new { masterGameID, year });
if (masterGame == null)
{
return(Maybe <MasterGameYear> .None);
}
IEnumerable <MasterSubGameEntity> masterSubGames = await connection.QueryAsync <MasterSubGameEntity>("select * from tblmastersubgame where MasterGameID = @masterGameID", new { masterGameID });
EligibilityLevel eligibilityLevel = await GetEligibilityLevel(masterGame.EligibilityLevel);
MasterGameYear domain = masterGame.ToDomain(masterSubGames.Select(x => x.ToDomain()), eligibilityLevel, year);
return(Maybe <MasterGameYear> .From(domain));
}
}
public MasterGameYearViewModel(MasterSubGame masterSubGame, MasterGameYear masterGame, LocalDate currentDate)
{
MasterGameID = masterSubGame.MasterGameID;
Year = masterGame.Year;
GameName = masterSubGame.GameName;
EstimatedReleaseDate = masterSubGame.EstimatedReleaseDate;
MinimumReleaseDate = masterSubGame.MinimumReleaseDate;
MaximumReleaseDate = masterSubGame.GetDefiniteMaximumReleaseDate();
ReleaseDate = masterGame.MasterGame.ReleaseDate;
IsReleased = masterGame.MasterGame.IsReleased(currentDate);
WillRelease = masterGame.WillRelease();
CriticScore = masterSubGame.CriticScore;
FantasyPoints = masterGame.GetFantasyPoints(ScoringSystem.GetDefaultScoringSystem(Year), false, currentDate);
AveragedScore = false;
OpenCriticID = masterSubGame.OpenCriticID;
SubGames = null;
Tags = new List <string>();
ReadableTags = new List <string>();
PercentStandardGame = masterGame.PercentStandardGame;
PercentCounterPick = masterGame.PercentCounterPick;
AdjustedPercentCounterPick = masterGame.AdjustedPercentCounterPick;
if (masterGame.MasterGame.EligibilityChanged)
{
EligiblePercentStandardGame = masterGame.PercentStandardGame;
}
else
{
EligiblePercentStandardGame = masterGame.EligiblePercentStandardGame;
}
AverageDraftPosition = masterGame.AverageDraftPosition;
HypeFactor = masterGame.HypeFactor;
DateAdjustedHypeFactor = masterGame.DateAdjustedHypeFactor;
PeakHypeFactor = masterGame.PeakHypeFactor;
ProjectedFantasyPoints = masterGame.GetProjectedFantasyPoints(ScoringSystem.GetDefaultScoringSystem(Year), false);
ProjectedOrRealFantasyPoints = FantasyPoints ?? ProjectedFantasyPoints;
AddedTimestamp = masterGame.MasterGame.AddedTimestamp;
}
public MasterGameYearViewModel(MasterGameYear masterGame, IClock clock)
{
MasterGameID = masterGame.MasterGame.MasterGameID;
Year = masterGame.Year;
GameName = masterGame.MasterGame.GameName;
EstimatedReleaseDate = masterGame.MasterGame.EstimatedReleaseDate;
MinimumReleaseDate = masterGame.MasterGame.MinimumReleaseDate;
MaximumReleaseDate = masterGame.MasterGame.GetDefiniteMaximumReleaseDate();
EarlyAccessReleaseDate = masterGame.MasterGame.EarlyAccessReleaseDate;
InternationalReleaseDate = masterGame.MasterGame.InternationalReleaseDate;
ReleaseDate = masterGame.MasterGame.ReleaseDate;
IsReleased = masterGame.MasterGame.IsReleased(clock.GetCurrentInstant());
WillRelease = masterGame.WillRelease();
CriticScore = masterGame.MasterGame.CriticScore;
AveragedScore = masterGame.MasterGame.AveragedScore;
OpenCriticID = masterGame.MasterGame.OpenCriticID;
SubGames = masterGame.MasterGame.SubGames.Select(x => new MasterGameYearViewModel(x, masterGame, clock)).ToList();
Tags = masterGame.MasterGame.Tags.Select(x => x.Name).ToList();
BoxartFileName = masterGame.MasterGame.BoxartFileName;
PercentStandardGame = masterGame.PercentStandardGame;
PercentCounterPick = masterGame.PercentCounterPick;
if (masterGame.MasterGame.EligibilityChanged)
{
EligiblePercentStandardGame = masterGame.PercentStandardGame;
EligiblePercentCounterPick = masterGame.PercentCounterPick;
}
else
{
EligiblePercentStandardGame = masterGame.EligiblePercentStandardGame;
EligiblePercentCounterPick = masterGame.EligiblePercentCounterPick;
}
AverageDraftPosition = masterGame.AverageDraftPosition;
HypeFactor = masterGame.HypeFactor;
DateAdjustedHypeFactor = masterGame.DateAdjustedHypeFactor;
ProjectedFantasyPoints = masterGame.GetAlwaysProjectedFantasyPoints(new StandardScoringSystem(), false);
ProjectedOrRealFantasyPoints = masterGame.GetProjectedOrRealFantasyPoints(new StandardScoringSystem(), false, clock);
AddedTimestamp = masterGame.MasterGame.AddedTimestamp;
}
public MasterGameYearScriptInput(MasterGameYear masterGameYear)
{
Year = masterGameYear.Year;
MasterGameID = masterGameYear.MasterGame.MasterGameID;
GameName = masterGameYear.MasterGame.GameName;
EligiblePercentStandardGame = masterGameYear.EligiblePercentStandardGame;
AdjustedPercentCounterPick = masterGameYear.AdjustedPercentCounterPick ?? 0;
AverageDraftPosition = masterGameYear.AverageDraftPosition;
DateAdjustedHypeFactor = masterGameYear.DateAdjustedHypeFactor;
TotalBidAmount = masterGameYear.TotalBidAmount;
BidPercentile = masterGameYear.BidPercentile;
if (masterGameYear.MasterGame.CriticScore.HasValue)
{
CriticScore = masterGameYear.MasterGame.CriticScore.Value;
}
else if (!masterGameYear.WillRelease())
{
CriticScore = 70m;
}
}
public async Task <IReadOnlyList <MasterGameYear> > GetMasterGameYears(int year)
{
if (_masterGameYearsCache.ContainsKey(year))
{
return(_masterGameYearsCache[year].Values.ToList());
}
var possibleTags = await GetMasterGameTags();
using (var connection = new MySqlConnection(_connectionString))
{
var masterGameResults = await connection.QueryAsync <MasterGameYearEntity>("select * from tbl_caching_mastergameyear where Year = @year;", new { year });
var masterSubGameResults = await connection.QueryAsync <MasterSubGameEntity>("select * from tbl_mastergame_subgame;");
var masterGameTagResults = await connection.QueryAsync <MasterGameHasTagEntity>("select * from tbl_mastergame_hastag;");
var masterGameTagLookup = masterGameTagResults.ToLookup(x => x.MasterGameID);
var masterSubGames = masterSubGameResults.Select(x => x.ToDomain()).ToList();
List <MasterGameYear> masterGames = new List <MasterGameYear>();
foreach (var entity in masterGameResults)
{
var tagAssociations = masterGameTagLookup[entity.MasterGameID].Select(x => x.TagName);
IReadOnlyList <MasterGameTag> tags = possibleTags
.Where(x => tagAssociations.Contains(x.Name))
.ToList();
MasterGameYear domain = entity.ToDomain(masterSubGames.Where(sub => sub.MasterGameID == entity.MasterGameID), year, tags);
masterGames.Add(domain);
}
_masterGameYearsCache[year] = masterGames.ToDictionary(x => x.MasterGame.MasterGameID, y => y);
return(masterGames);
}
}
public PublicBiddingMasterGame(MasterGameYear masterGameYear, bool counterPick, IEnumerable <ClaimError> claimErrors)
{
MasterGameYear = masterGameYear;
CounterPick = counterPick;
ClaimErrors = claimErrors.ToList();
}
public RoyalePublisherGame ToDomain(RoyaleYearQuarter yearQuarter, MasterGameYear masterGameYear)
{
return(new RoyalePublisherGame(PublisherID, yearQuarter, masterGameYear, Timestamp, AmountSpent, AdvertisingMoney, FantasyPoints));
}
public MasterGameYearWithCounterPickViewModel(MasterGameYear masterGameYear, bool counterPick, LocalDate currentDate)
{
MasterGameYear = new MasterGameYearViewModel(masterGameYear, currentDate);
CounterPick = counterPick;
}
