public async Task <IActionResult> ManagerClaimGame([FromBody] ClaimGameRequest request) { var leagueYearPublisherRecord = await GetExistingLeagueYearAndPublisher(request.PublisherID, ActionProcessingModeBehavior.Ban, RequiredRelationship.LeagueManager, RequiredYearStatus.YearNotFinishedDraftFinished); if (leagueYearPublisherRecord.FailedResult is not null) { return(leagueYearPublisherRecord.FailedResult); } var validResult = leagueYearPublisherRecord.ValidResult !; var leagueYear = validResult.LeagueYear; var publisher = validResult.Publisher; MasterGame?masterGame = null; if (request.MasterGameID.HasValue) { masterGame = await _interLeagueService.GetMasterGame(request.MasterGameID.Value); } bool counterPickedGameIsManualWillNotRelease = PlayerGameExtensions.CounterPickedGameIsManualWillNotRelease(leagueYear, request.CounterPick, masterGame, false); ClaimGameDomainRequest domainRequest = new ClaimGameDomainRequest(leagueYear, publisher, request.GameName, request.CounterPick, counterPickedGameIsManualWillNotRelease, request.ManagerOverride, false, masterGame, null, null); ClaimResult result = await _gameAcquisitionService.ClaimGame(domainRequest, true, false, false); var viewModel = new ManagerClaimResultViewModel(result); await _fantasyCriticService.UpdatePublisherGameCalculatedStats(leagueYear); return(Ok(viewModel)); }
public async Task <ClaimResult> ClaimGame(ClaimGameDomainRequest request) { PublisherGame playerGame = new PublisherGame(Guid.NewGuid(), request.GameName, _clock.GetCurrentInstant(), request.CounterPick, null, null, new MasterGameYear(request.MasterGame.Value, request.Publisher.Year), request.DraftPosition, request.OverallDraftPosition, request.Publisher.Year); ClaimResult claimResult = await CanClaimGame(request); if (!claimResult.Success) { return(claimResult); } LeagueAction leagueAction = new LeagueAction(request, _clock.GetCurrentInstant()); await _fantasyCriticRepo.AddLeagueAction(leagueAction); await _fantasyCriticRepo.AddPublisherGame(request.Publisher, playerGame); return(claimResult); }
public async Task <ClaimResult> MakePickupBid(Publisher publisher, MasterGame masterGame, uint bidAmount) { if (bidAmount > publisher.Budget) { return(new ClaimResult(new List <ClaimError>() { new ClaimError("You do not have enough budget to make that bid.", false) })); } IReadOnlyList <PickupBid> pickupBids = await _fantasyCriticRepo.GetActivePickupBids(publisher); bool alreadyBidFor = pickupBids.Select(x => x.MasterGame.MasterGameID).Contains(masterGame.MasterGameID); if (alreadyBidFor) { return(new ClaimResult(new List <ClaimError>() { new ClaimError("You cannot have two active bids for the same game.", false) })); } var claimRequest = new ClaimGameDomainRequest(publisher, masterGame.GameName, false, false, masterGame, null, null); var claimResult = await CanClaimGame(claimRequest); if (!claimResult.Success) { return(claimResult); } var nextPriority = pickupBids.Count + 1; PickupBid currentBid = new PickupBid(Guid.NewGuid(), publisher, masterGame, bidAmount, nextPriority, _clock.GetCurrentInstant(), null); await _fantasyCriticRepo.CreatePickupBid(currentBid); return(claimResult); }
private async Task <ClaimResult> CanClaimGame(ClaimGameDomainRequest request) { List <ClaimError> claimErrors = new List <ClaimError>(); var basicErrors = await GetBasicErrors(request.Publisher.League, request.Publisher); claimErrors.AddRange(basicErrors); var leagueYear = await _fantasyCriticRepo.GetLeagueYear(request.Publisher.League, request.Publisher.Year); if (leagueYear.HasNoValue) { throw new Exception("Something has gone terribly wrong with league years."); } LeagueOptions yearOptions = leagueYear.Value.Options; if (request.MasterGame.HasValue) { var masterGameErrors = GetMasterGameErrors(leagueYear.Value.Options, request.MasterGame.Value, leagueYear.Value.Year, request.CounterPick); claimErrors.AddRange(masterGameErrors); } IReadOnlyList <Publisher> allPublishers = await _fantasyCriticRepo.GetPublishersInLeagueForYear(request.Publisher.League, request.Publisher.Year); IReadOnlyList <Publisher> otherPublishers = allPublishers.Where(x => x.User.UserID != request.Publisher.User.UserID).ToList(); IReadOnlyList <PublisherGame> gamesForYear = allPublishers.SelectMany(x => x.PublisherGames).ToList(); IReadOnlyList <PublisherGame> thisPlayersGames = request.Publisher.PublisherGames; IReadOnlyList <PublisherGame> otherPlayersGames = otherPublishers.SelectMany(x => x.PublisherGames).ToList(); bool gameAlreadyClaimed = gamesForYear.ContainsGame(request); if (!request.CounterPick) { if (gameAlreadyClaimed) { claimErrors.Add(new ClaimError("Cannot claim a game that someone already has.", false)); } int leagueDraftGames = yearOptions.StandardGames; int userDraftGames = thisPlayersGames.Count(x => !x.CounterPick); if (userDraftGames == leagueDraftGames) { claimErrors.Add(new ClaimError("User's game spaces are filled.", false)); } } if (request.CounterPick) { bool otherPlayerHasCounterPick = otherPlayersGames.Where(x => x.CounterPick).ContainsGame(request); if (otherPlayerHasCounterPick) { claimErrors.Add(new ClaimError("Cannot counter-pick a game that someone else has already counter-picked.", false)); } bool otherPlayerHasDraftGame = otherPlayersGames.Where(x => !x.CounterPick).ContainsGame(request); int leagueCounterPicks = yearOptions.CounterPicks; int userCounterPicks = thisPlayersGames.Count(x => x.CounterPick); if (userCounterPicks == leagueCounterPicks) { claimErrors.Add(new ClaimError("User's counter pick spaces are filled.", false)); } if (!otherPlayerHasDraftGame) { claimErrors.Add(new ClaimError("Cannot counterPick a game that no other player is publishing.", false)); } } var result = new ClaimResult(claimErrors); if (result.Overridable && request.ManagerOverride) { return(new ClaimResult(new List <ClaimError>())); } return(result); }