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 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 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 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 => !EligibilitySettings.GetRoyaleEligibilitySettings().GameIsEligible(x.MasterGame).Any())
.Take(100)
.ToList();
}
var viewModels = masterGames.Select(masterGame =>
new PossibleRoyaleMasterGameViewModel(masterGame, _clock, yearQuarter.Value, publisher.Value.PublisherGames.Any(y =>
y.MasterGame.MasterGame.Equals(masterGame.MasterGame)))).ToList();
return(viewModels);
}