public async Task <Result> SellGame(RoyalePublisher publisher, RoyalePublisherGame publisherGame) { var currentDate = _clock.GetToday(); if (publisherGame.MasterGame.MasterGame.IsReleased(currentDate)) { return(Result.Failure("That game has already been released.")); } if (publisherGame.MasterGame.MasterGame.CriticScore.HasValue) { return(Result.Failure("That game already has a score.")); } if (!publisher.PublisherGames.Contains(publisherGame)) { return(Result.Failure("You don't have that game.")); } var masterGameTags = await _masterGameRepo.GetMasterGameTags(); var currentlyInEligible = publisherGame.CalculateIsCurrentlyIneligible(masterGameTags); await _royaleRepo.SellGame(publisherGame, currentlyInEligible); return(Result.Success()); }
public async Task <IActionResult> CreateRoyalePublisher([FromBody] CreateRoyalePublisherRequest request) { var currentUserResult = await GetCurrentUser(); if (currentUserResult.IsFailure) { return(BadRequest(currentUserResult.Error)); } var currentUser = currentUserResult.Value; if (string.IsNullOrWhiteSpace(request.PublisherName)) { return(BadRequest("You cannot have a blank name.")); } IReadOnlyList <RoyaleYearQuarter> supportedQuarters = await _royaleService.GetYearQuarters(); var selectedQuarter = supportedQuarters.Single(x => x.YearQuarter.Year == request.Year && x.YearQuarter.Quarter == request.Quarter); if (!selectedQuarter.OpenForPlay || selectedQuarter.Finished) { return(BadRequest()); } var existingPublisher = await _royaleService.GetPublisher(selectedQuarter, currentUser); if (existingPublisher is not null) { return(BadRequest()); } RoyalePublisher publisher = await _royaleService.CreatePublisher(selectedQuarter, currentUser, request.PublisherName); return(Ok(publisher.PublisherID)); }
public async Task <RoyalePublisher> CreatePublisher(RoyaleYearQuarter yearQuarter, FantasyCriticUser user, string publisherName) { RoyalePublisher publisher = new RoyalePublisher(Guid.NewGuid(), yearQuarter, user, publisherName, null, new List <RoyalePublisherGame>(), 100m); await _royaleRepo.CreatePublisher(publisher); return(publisher); }
public async Task <IActionResult> CreateRoyalePublisher([FromBody] CreateRoyalePublisherRequest request) { var currentUser = await _userManager.FindByNameAsync(User.Identity.Name); if (currentUser is null) { return(BadRequest()); } IReadOnlyList <RoyaleYearQuarter> supportedQuarters = await _royaleService.GetYearQuarters(); var selectedQuarter = supportedQuarters.Single(x => x.YearQuarter.Year == request.Year && x.YearQuarter.Quarter == request.Quarter); if (!selectedQuarter.OpenForPlay || selectedQuarter.Finished) { return(BadRequest()); } var existingPublisher = await _royaleService.GetPublisher(selectedQuarter, currentUser); if (existingPublisher.HasValue) { return(BadRequest()); } RoyalePublisher publisher = await _royaleService.CreatePublisher(selectedQuarter, currentUser, request.PublisherName); return(Ok(publisher.PublisherID)); }
public RoyalePublisherEntity(RoyalePublisher domainRoyalePublisher) { PublisherID = domainRoyalePublisher.PublisherID; UserID = domainRoyalePublisher.User.UserID; Year = domainRoyalePublisher.YearQuarter.YearQuarter.Year; Quarter = domainRoyalePublisher.YearQuarter.YearQuarter.Quarter; PublisherName = domainRoyalePublisher.PublisherName; Budget = domainRoyalePublisher.Budget; }
public async Task CreatePublisher(RoyalePublisher publisher) { RoyalePublisherEntity entity = new RoyalePublisherEntity(publisher); string sql = "insert into tbl_royale_publisher (PublisherID,UserID,Year,Quarter,PublisherName,PublisherIcon,Budget) " + "VALUES (@PublisherID,@UserID,@Year,@Quarter,@PublisherName,@PublisherIcon,@Budget)"; await using var connection = new MySqlConnection(_connectionString); await connection.ExecuteAsync(sql, entity); }
public async Task ChangePublisherIcon(RoyalePublisher publisher, string?publisherIcon) { string sql = "UPDATE tbl_royale_publisher SET PublisherIcon = @publisherIcon WHERE PublisherID = @publisherID;"; await using var connection = new MySqlConnection(_connectionString); await connection.ExecuteAsync(sql, new { publisherID = publisher.PublisherID, publisherIcon }); }
public async Task ChangePublisherName(RoyalePublisher publisher, string publisherName) { string sql = "UPDATE tbl_royale_publisher SET PublisherName = @publisherName WHERE PublisherID = @publisherID;"; using (var connection = new MySqlConnection(_connectionString)) { await connection.ExecuteAsync(sql, new { publisherID = publisher.PublisherID, publisherName }); } }
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 RoyalePublisherViewModel(RoyalePublisher domain, IClock clock, int?ranking) { PublisherID = domain.PublisherID; YearQuarter = new RoyaleYearQuarterViewModel(domain.YearQuarter); PlayerName = domain.User.DisplayName; UserID = domain.User.UserID; PublisherName = domain.PublisherName; PublisherGames = domain.PublisherGames.Select(x => new RoyalePublisherGameViewModel(x, clock)).ToList(); Budget = domain.Budget; TotalFantasyPoints = domain.GetTotalFantasyPoints(); if (TotalFantasyPoints > 0) { Ranking = ranking; } }
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 RoyalePublisherViewModel(RoyalePublisher domain, IClock clock, int?ranking, IEnumerable <RoyaleYearQuarter> quartersWon) { PublisherID = domain.PublisherID; YearQuarter = new RoyaleYearQuarterViewModel(domain.YearQuarter); PlayerName = domain.User.DisplayName; UserID = domain.User.UserID; PublisherName = domain.PublisherName; PublisherGames = domain.PublisherGames.Select(x => new RoyalePublisherGameViewModel(x, clock)).ToList(); Budget = domain.Budget; TotalFantasyPoints = domain.GetTotalFantasyPoints(); if (TotalFantasyPoints > 0) { Ranking = ranking; } QuartersWon = quartersWon.Select(x => new RoyaleYearQuarterViewModel(x)).ToList(); PreviousQuarterWinner = quartersWon.Select(x => x.YearQuarter).Contains(domain.YearQuarter.YearQuarter.LastQuarter); OneTimeWinner = quartersWon.Any(); }
public async Task <Result> SellGame(RoyalePublisher publisher, RoyalePublisherGame publisherGame) { if (publisherGame.MasterGame.MasterGame.IsReleased(_clock.GetCurrentInstant())) { return(Result.Fail("That game has already been released.")); } if (publisherGame.MasterGame.MasterGame.CriticScore.HasValue) { return(Result.Fail("That game already has a score.")); } if (!publisher.PublisherGames.Contains(publisherGame)) { return(Result.Fail("You don't have that game.")); } await _royaleRepo.SellGame(publisherGame); return(Result.Ok()); }
public RoyalePublisherViewModel(RoyalePublisher domain, LocalDate currentDate, int?ranking, IEnumerable <RoyaleYearQuarter> quartersWon, IEnumerable <MasterGameTag> allMasterGameTags) { PublisherID = domain.PublisherID; YearQuarter = new RoyaleYearQuarterViewModel(domain.YearQuarter); PlayerName = domain.User.UserName; UserID = domain.User.Id; PublisherName = domain.PublisherName; PublisherIcon = domain.PublisherIcon; PublisherGames = domain.PublisherGames.Select(x => new RoyalePublisherGameViewModel(x, currentDate, allMasterGameTags)).ToList(); Budget = domain.Budget; TotalFantasyPoints = domain.GetTotalFantasyPoints(); if (TotalFantasyPoints > 0) { Ranking = ranking; } QuartersWon = quartersWon.Select(x => new RoyaleYearQuarterViewModel(x)).ToList(); PreviousQuarterWinner = quartersWon.Select(x => x.YearQuarter).Contains(domain.YearQuarter.YearQuarter.LastQuarter); OneTimeWinner = quartersWon.Any(); }
public async Task <Result> SetAdvertisingMoney(RoyalePublisher publisher, RoyalePublisherGame publisherGame, decimal advertisingMoney) { var currentDate = _clock.GetToday(); if (publisherGame.MasterGame.MasterGame.IsReleased(currentDate)) { return(Result.Failure("That game has already been released.")); } if (publisherGame.MasterGame.MasterGame.CriticScore.HasValue) { return(Result.Failure("That game already has a score.")); } if (!publisher.PublisherGames.Contains(publisherGame)) { return(Result.Failure("You don't have that game.")); } decimal newDollarsToSpend = advertisingMoney - publisherGame.AdvertisingMoney; if (publisher.Budget < newDollarsToSpend) { return(Result.Failure("You don't have enough money.")); } if (advertisingMoney < 0m) { return(Result.Failure("You can't allocate negative dollars in advertising money.")); } if (advertisingMoney > 10m) { return(Result.Failure("You can't allocate more than 10 dollars in advertising money.")); } await _royaleRepo.SetAdvertisingMoney(publisherGame, advertisingMoney); return(Result.Success()); }
public Task CreatePublisher(RoyalePublisher publisher) { throw new NotImplementedException(); }
public Task ChangePublisherIcon(RoyalePublisher publisher, string?publisherIcon) { return(_royaleRepo.ChangePublisherIcon(publisher, publisherIcon)); }
public Task ChangePublisherName(RoyalePublisher publisher, string publisherName) { return(_royaleRepo.ChangePublisherName(publisher, publisherName)); }
public Task ChangePublisherName(RoyalePublisher publisher, string publisherName) { throw new NotImplementedException(); }