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 async Task <IReadOnlyList <MasterGame> > GetMasterGames()
{
if (_masterGamesCache.Any())
{
return(_masterGamesCache.Values.ToList());
}
using (var connection = new MySqlConnection(_connectionString))
{
var masterGameResults = await connection.QueryAsync <MasterGameEntity>("select * from tbl_mastergame;");
var masterSubGameResults = await connection.QueryAsync <MasterSubGameEntity>("select * from tbl_mastergame_subgame;");
var masterSubGames = masterSubGameResults.Select(x => x.ToDomain()).ToList();
List <MasterGame> masterGames = new List <MasterGame>();
foreach (var entity in masterGameResults)
{
EligibilityLevel eligibilityLevel = await GetEligibilityLevel(entity.EligibilityLevel);
MasterGame domain = entity.ToDomain(masterSubGames.Where(sub => sub.MasterGameID == entity.MasterGameID),
eligibilityLevel);
masterGames.Add(domain);
}
_masterGamesCache = masterGames.ToDictionary(x => x.MasterGameID, y => y);
return(masterGames);
}
}
public async Task <IActionResult> EditMasterGame([FromBody] EditMasterGameRequest viewModel)
{
Instant instant = _clock.GetCurrentInstant();
var possibleTags = await _interLeagueService.GetMasterGameTags();
IReadOnlyList <MasterGameTag> tags = possibleTags
.Where(x => viewModel.Tags.Contains(x.Name))
.ToList();
var existingMasterGame = await _interLeagueService.GetMasterGame(viewModel.MasterGameID);
if (existingMasterGame is null)
{
return(BadRequest());
}
MasterGame masterGame = viewModel.ToDomain(existingMasterGame, instant, tags);
await _interLeagueService.EditMasterGame(masterGame);
var currentDate = _clock.GetToday();
var vm = new MasterGameViewModel(masterGame, currentDate);
_logger.LogInformation($"Edited master game: {masterGame.MasterGameID}");
return(CreatedAtAction("MasterGame", "Game", new { id = masterGame.MasterGameID }, vm));
}
public override int GetHashCode()
{
unchecked
{
return((PublisherID.GetHashCode() * 397) ^ (MasterGame != null ? MasterGame.GetHashCode() : 0));
}
}
public async Task CreateMasterGame(MasterGame masterGame)
{
string masterGameCreateSQL = "insert into tbl_mastergame" +
"(MasterGameID,GameName,EstimatedReleaseDate,MinimumReleaseDate,MaximumReleaseDate,EarlyAccessReleaseDate,InternationalReleaseDate,AnnouncementDate," +
"ReleaseDate,OpenCriticID,GGToken,CriticScore,Notes,BoxartFileName,GGCoverArtFileName," +
"FirstCriticScoreTimestamp,DoNotRefreshDate,DoNotRefreshAnything,EligibilityChanged,DelayContention,AddedTimestamp) VALUES " +
"(@MasterGameID,@GameName,@EstimatedReleaseDate,@MinimumReleaseDate,@MaximumReleaseDate,@EarlyAccessReleaseDate,@InternationalReleaseDate,@AnnouncementDate," +
"@ReleaseDate,@OpenCriticID,@GGToken,@CriticScore,@Notes,@BoxartFileName,@GGCoverArtFileName," +
"@FirstCriticScoreTimestamp,@DoNotRefreshDate,@DoNotRefreshAnything,@EligibilityChanged,@DelayContention,@AddedTimestamp);";
var entity = new MasterGameEntity(masterGame);
var tagEntities = masterGame.Tags.Select(x => new MasterGameHasTagEntity(masterGame, x));
var excludeFields = new List <string>()
{
"TimeAdded"
};
await using var connection = new MySqlConnection(_connectionString);
await connection.OpenAsync();
await using var transaction = await connection.BeginTransactionAsync();
await connection.ExecuteAsync(masterGameCreateSQL, entity, transaction);
await connection.BulkInsertAsync <MasterGameHasTagEntity>(tagEntities, "tbl_mastergame_hastag", 500, transaction, excludeFields);
await transaction.CommitAsync();
}
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 MasterGameWithEligibilityFactors GetEligibilityFactorsForMasterGame(MasterGame masterGame, LocalDate dateOfPotentialAcquisition)
{
bool?eligibilityOverride = GetOverriddenEligibility(masterGame);
IReadOnlyList <MasterGameTag> tagOverrides = GetOverriddenTags(masterGame);
return(new MasterGameWithEligibilityFactors(masterGame, Options, eligibilityOverride, tagOverrides, dateOfPotentialAcquisition));
}
public async Task <ClaimResult> QueueGame(Publisher publisher, MasterGame masterGame)
{
IReadOnlyList <QueuedGame> queuedGames = await _fantasyCriticRepo.GetQueuedGames(publisher);
bool alreadyQueued = queuedGames.Select(x => x.MasterGame.MasterGameID).Contains(masterGame.MasterGameID);
if (alreadyQueued)
{
return(new ClaimResult(new List <ClaimError>()
{
new ClaimError("You already have that game queued.", false)
}));
}
var claimRequest = new ClaimGameDomainRequest(publisher, masterGame.GameName, false, false, false, masterGame, null, null);
var supportedYears = await _fantasyCriticRepo.GetSupportedYears();
var leagueYear = publisher.LeagueYear;
var publishersForYear = await _fantasyCriticRepo.GetPublishersInLeagueForYear(publisher.LeagueYear);
var claimResult = CanClaimGame(claimRequest, supportedYears, leagueYear, publishersForYear, null, true);
if (!claimResult.Success)
{
return(claimResult);
}
var nextRank = queuedGames.Count + 1;
QueuedGame queuedGame = new QueuedGame(publisher, masterGame, nextRank);
await _fantasyCriticRepo.QueueGame(queuedGame);
return(claimResult);
}
public AssociateGameDomainRequest(Publisher publisher, PublisherGame publisherGame, MasterGame masterGame, bool managerOverride)
{
Publisher = publisher;
PublisherGame = publisherGame;
MasterGame = masterGame;
ManagerOverride = managerOverride;
}
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 static IReadOnlyList <ClaimError> GameHasValidTags(IEnumerable <LeagueTagStatus> leagueTags, IEnumerable <LeagueTagStatus> slotSpecificTags,
MasterGame masterGame, IEnumerable <MasterGameTag> masterGameTags, LocalDate dateOfAcquisition)
{
var combinedLeagueTags = CombineTags(leagueTags, slotSpecificTags);
var bannedTags = combinedLeagueTags.Where(x => x.Status.Equals(TagStatus.Banned)).ToList();
var requiredTags = combinedLeagueTags.Where(x => x.Status.Equals(TagStatus.Required)).ToList();
List <ClaimError> claimErrors = new List <ClaimError>();
foreach (var bannedTag in bannedTags)
{
if (!bannedTag.GameMeetsTagCriteria(masterGame, masterGameTags, dateOfAcquisition))
{
claimErrors.Add(new ClaimError($"That game is not eligible because the {bannedTag.Tag.ReadableName} tag has been banned", true));
}
}
bool hasNoRequiredTags = requiredTags.Any();
foreach (var requiredTag in requiredTags)
{
if (requiredTag.GameMeetsTagCriteria(masterGame, masterGameTags, dateOfAcquisition))
{
hasNoRequiredTags = false;
break;
}
}
if (hasNoRequiredTags)
{
claimErrors.Add(new ClaimError($"That game is not eligible because it does not have any of the following required tags: ({string.Join(",", requiredTags.Select(x => x.Tag.ReadableName))})", true));
}
return(claimErrors);
}
public async Task <IActionResult> GetOpenCriticGames([FromBody] OpenCriticSearchRequest request)
{
int id = request.MinimumOpenCriticID;
var masterGames = await _fantasyCriticService.GetMasterGames();
while (true)
{
var openCriticGame = await _openCriticService.GetOpenCriticGame(id);
if (openCriticGame.HasNoValue)
{
return(Ok());
}
if (masterGames.Any(x => x.OpenCriticID.HasValue && x.OpenCriticID.Value == id))
{
id++;
continue;
}
EligibilityLevel eligibilityLevel = await _fantasyCriticService.GetEligibilityLevel(0);
int minimumReleaseYear = 2018;
if (openCriticGame.Value.ReleaseDate.HasValue)
{
minimumReleaseYear = openCriticGame.Value.ReleaseDate.Value.Year;
}
MasterGame masterGame = new MasterGame(Guid.NewGuid(), openCriticGame.Value.Name, openCriticGame.Value.ReleaseDate?.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture), openCriticGame.Value.ReleaseDate,
id, openCriticGame.Value.Score, minimumReleaseYear, eligibilityLevel, false, false, "");
await _fantasyCriticService.CreateMasterGame(masterGame);
id++;
}
}
public MasterGameEntity(MasterGame masterGame)
{
MasterGameID = masterGame.MasterGameID;
GameName = masterGame.GameName;
EstimatedReleaseDate = masterGame.EstimatedReleaseDate;
MinimumReleaseDate = masterGame.MinimumReleaseDate;
MaximumReleaseDate = masterGame.MaximumReleaseDate;
EarlyAccessReleaseDate = masterGame.EarlyAccessReleaseDate;
InternationalReleaseDate = masterGame.InternationalReleaseDate;
AnnouncementDate = masterGame.AnnouncementDate;
ReleaseDate = masterGame.ReleaseDate;
OpenCriticID = masterGame.OpenCriticID;
GGToken = masterGame.GGToken;
CriticScore = masterGame.CriticScore;
Notes = masterGame.Notes;
BoxartFileName = masterGame.BoxartFileName;
GGCoverArtFileName = masterGame.GGCoverArtFileName;
FirstCriticScoreTimestamp = masterGame.FirstCriticScoreTimestamp;
DoNotRefreshDate = masterGame.DoNotRefreshDate;
DoNotRefreshAnything = masterGame.DoNotRefreshAnything;
DelayContention = masterGame.DelayContention;
EligibilityChanged = masterGame.EligibilityChanged;
AddedTimestamp = masterGame.AddedTimestamp;
}
public override int GetHashCode()
{
unchecked
{
return(((MasterGame != null ? MasterGame.GetHashCode() : 0) * 397) ^ Year);
}
}
public async Task <IReadOnlyList <MasterGame> > GetMasterGames()
{
if (_masterGamesCache.Any())
{
return(_masterGamesCache.Values.ToList());
}
var possibleTags = await GetMasterGameTags();
await using var connection = new MySqlConnection(_connectionString);
var masterGameResults = await connection.QueryAsync <MasterGameEntity>("select * from tbl_mastergame;");
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 <MasterGame> masterGames = new List <MasterGame>();
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();
MasterGame domain = entity.ToDomain(masterSubGames.Where(sub => sub.MasterGameID == entity.MasterGameID), tags);
masterGames.Add(domain);
}
_masterGamesCache = masterGames.ToDictionary(x => x.MasterGameID, y => y);
return(masterGames);
}
public MasterGameViewModel(MasterGame masterGame, LocalDate currentDate, bool error = false, int numberOutstandingCorrections = 0)
{
MasterGameID = masterGame.MasterGameID;
GameName = masterGame.GameName;
EstimatedReleaseDate = masterGame.EstimatedReleaseDate;
MinimumReleaseDate = masterGame.MinimumReleaseDate;
MaximumReleaseDate = masterGame.GetDefiniteMaximumReleaseDate();
EarlyAccessReleaseDate = masterGame.EarlyAccessReleaseDate;
InternationalReleaseDate = masterGame.InternationalReleaseDate;
AnnouncementDate = masterGame.AnnouncementDate;
ReleaseDate = masterGame.ReleaseDate;
IsReleased = masterGame.IsReleased(currentDate);
DoNotRefreshDate = masterGame.DoNotRefreshDate;
DoNotRefreshAnything = masterGame.DoNotRefreshAnything;
EligibilityChanged = masterGame.EligibilityChanged;
DelayContention = masterGame.DelayContention;
CriticScore = masterGame.CriticScore;
AveragedScore = masterGame.AveragedScore;
Notes = masterGame.Notes;
OpenCriticID = masterGame.OpenCriticID;
GGToken = masterGame.GGToken;
SubGames = masterGame.SubGames.Select(x => new MasterGameViewModel(x, currentDate)).ToList();
Tags = masterGame.Tags.Select(x => x.Name).ToList();
BoxartFileName = masterGame.BoxartFileName;
GGCoverArtFileName = masterGame.GGCoverArtFileName;
AddedTimestamp = masterGame.AddedTimestamp;
Error = error;
NumberOutstandingCorrections = numberOutstandingCorrections;
}
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 async Task SetEligibilityOverride(LeagueYear leagueYear, MasterGame masterGame, bool?eligible)
{
if (!eligible.HasValue)
{
await _fantasyCriticRepo.DeleteEligibilityOverride(leagueYear, masterGame);
}
else
{
await _fantasyCriticRepo.SetEligibilityOverride(leagueYear, masterGame, eligible.Value);
}
var allPublishers = await _publisherService.GetPublishersInLeagueForYear(leagueYear);
var managerPublisher = allPublishers.Single(x => x.User.UserID == leagueYear.League.LeagueManager.UserID);
string description;
if (!eligible.HasValue)
{
description = $"{masterGame.GameName}'s eligibility setting was reset to normal.";
}
else if (eligible.Value)
{
description = $"{masterGame.GameName} was manually set to 'Eligible'";
}
else
{
description = $"{masterGame.GameName} was manually set to 'Ineligible'";
}
LeagueAction eligibilityAction = new LeagueAction(managerPublisher, _clock.GetCurrentInstant(), "Eligibility Setting Changed", description, true);
await _fantasyCriticRepo.AddLeagueAction(eligibilityAction);
}
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 MasterGameYear ToDomain(IEnumerable <MasterSubGame> subGames, EligibilityLevel eligibilityLevel, int year)
{
LocalDate?releaseDate = null;
if (ReleaseDate.HasValue)
{
releaseDate = LocalDate.FromDateTime(ReleaseDate.Value);
}
LocalDate?sortableEstimatedReleaseDate = null;
if (SortableEstimatedReleaseDate.HasValue)
{
sortableEstimatedReleaseDate = LocalDate.FromDateTime(SortableEstimatedReleaseDate.Value);
}
Instant?firstCriticScoreTimestamp = null;
if (FirstCriticScoreTimestamp.HasValue)
{
firstCriticScoreTimestamp = Instant.FromDateTimeUtc(FirstCriticScoreTimestamp.Value);
}
var addedTimestamp = LocalDateTime.FromDateTime(AddedTimestamp).InZoneStrictly(DateTimeZone.Utc).ToInstant();
var eligibilitySettings = new EligibilitySettings(eligibilityLevel, YearlyInstallment, EarlyAccess, FreeToPlay, ReleasedInternationally, ExpansionPack, UnannouncedGame);
var masterGame = new MasterGame(MasterGameID, GameName, EstimatedReleaseDate, sortableEstimatedReleaseDate, releaseDate,
OpenCriticID, CriticScore, LocalDate.FromDateTime(MinimumReleaseDate), eligibilitySettings, subGames.ToList(), BoxartFileName, firstCriticScoreTimestamp,
false, false, EligibilityChanged, addedTimestamp);
return(new MasterGameYear(masterGame, year, PercentStandardGame, PercentCounterPick, EligiblePercentStandardGame, EligiblePercentCounterPick,
NumberOfBids, TotalBidAmount, BidPercentile, AverageDraftPosition, AverageWinningBid, HypeFactor, DateAdjustedHypeFactor, LinearRegressionHypeFactor));
}
public async Task <IActionResult> CreateMasterGame([FromBody] CreateMasterGameRequest viewModel)
{
var possibleTags = await _interLeagueService.GetMasterGameTags();
IReadOnlyList <MasterGameTag> tags = possibleTags
.Where(x => viewModel.Tags.Contains(x.Name))
.ToList();
if (!tags.Any())
{
tags = new List <MasterGameTag>()
{
possibleTags.Single(x => x.Name == "NewGame")
};
}
MasterGame masterGame = viewModel.ToDomain(_clock, tags);
await _interLeagueService.CreateMasterGame(masterGame);
var currentDate = _clock.GetToday();
var vm = new MasterGameViewModel(masterGame, currentDate);
_logger.LogInformation($"Created master game: {masterGame.MasterGameID}");
return(CreatedAtAction("MasterGame", "Game", new { id = masterGame.MasterGameID }, vm));
}
public AssociateGameDomainRequest(LeagueYear leagueYear, Publisher publisher, PublisherGame publisherGame, MasterGame masterGame, bool managerOverride)
{
LeagueYear = leagueYear;
Publisher = publisher;
PublisherGame = publisherGame;
MasterGame = masterGame;
ManagerOverride = managerOverride;
}
public async Task <IActionResult> CreateMasterGame([FromBody] CreateMasterGameRequest viewModel)
{
EligibilityLevel eligibilityLevel = await _fantasyCriticService.GetEligibilityLevel(viewModel.EligibilityLevel);
MasterGame masterGame = viewModel.ToDomain(eligibilityLevel);
await _fantasyCriticService.CreateMasterGame(masterGame);
return(Ok());
}
private IReadOnlyList <MasterGameTag> GetOverriddenTags(MasterGame masterGame)
{
if (!_tagOverridesDictionary.TryGetValue(masterGame, out var tagOverride))
{
return(new List <MasterGameTag>());
}
return(tagOverride.Tags);
}
public MasterGameWithEligibilityFactors(MasterGame masterGame, LeagueOptions options, bool?overridenEligibility,
IReadOnlyList <MasterGameTag> tagOverrides, LocalDate dateAcquired)
{
MasterGame = masterGame;
Options = options;
OverridenEligibility = overridenEligibility;
TagOverrides = tagOverrides;
DateAcquired = dateAcquired;
}
private static MasterGame CreateMasterGame(string guid, string name, string estimatedReleaseDate, LocalDate minimumReleaseDate, LocalDate?maximumReleaseDate, LocalDate?earlyAccessReleaseDate, LocalDate?internationalReleaseDate,
LocalDate?releaseDate, int?openCriticID, decimal?criticScore, string boxartFileName, string firstCriticScoreTimestamp, bool doNotRefreshDate, bool doNotRefreshAnything, string addedTimestamp)
{
var game = new MasterGame(Guid.Parse(guid), name, estimatedReleaseDate, minimumReleaseDate, maximumReleaseDate, earlyAccessReleaseDate, internationalReleaseDate, releaseDate,
openCriticID, criticScore, "", boxartFileName, InstantPattern.ExtendedIso.Parse(firstCriticScoreTimestamp).GetValueOrThrow(), doNotRefreshDate,
doNotRefreshAnything, false, InstantPattern.ExtendedIso.Parse(addedTimestamp).GetValueOrThrow(), new List <MasterSubGame>(), new List <MasterGameTag>());
return(game);
}
public DropRequest(Guid dropRequestID, Publisher publisher, LeagueYear leagueYear, MasterGame masterGame,
Instant timestamp, bool?successful, Guid?processSetID)
{
DropRequestID = dropRequestID;
Publisher = publisher;
LeagueYear = leagueYear;
MasterGame = masterGame;
Timestamp = timestamp;
Successful = successful;
ProcessSetID = processSetID;
}
public PublisherGame GetPublisherGameOrThrow(MasterGame masterGame)
{
var publisherGame = GetPublisherGameByMasterGameID(masterGame.MasterGameID);
if (publisherGame is null)
{
throw new Exception($"Publisher: {PublisherID} does not have master game: {masterGame.GameName}");
}
return(publisherGame);
}
public async Task <IActionResult> BatchCreateMasterGame([FromBody] List <MinimalCreateMasterGameRequest> request)
{
foreach (var singleGame in request)
{
EligibilityLevel eligibilityLevel = await _fantasyCriticService.GetEligibilityLevel(0);
MasterGame masterGame = singleGame.ToDomain(eligibilityLevel);
await _fantasyCriticService.CreateMasterGame(masterGame);
}
return(Ok());
}
public void LoadNextScene () {
Scene currentScene = SceneManager.GetActiveScene ();
_instance = null;
SceneManager.LoadScene (currentScene.buildIndex + 1);
}
