public async Task <DropResult> MakeDropRequest(Publisher publisher, PublisherGame publisherGame)
{
if (publisherGame.CounterPick)
{
return(new DropResult(Result.Failure("You can't drop a counterpick."), false));
}
if (publisherGame.MasterGame.HasNoValue)
{
return(new DropResult(Result.Failure("You can't drop a game that is not linked to a master game. Please see the FAQ section on dropping games."), false));
}
MasterGame masterGame = publisherGame.MasterGame.Value.MasterGame;
IReadOnlyList <DropRequest> dropRequests = await _fantasyCriticRepo.GetActiveDropRequests(publisher);
bool alreadyDropping = dropRequests.Select(x => x.MasterGame.MasterGameID).Contains(masterGame.MasterGameID);
if (alreadyDropping)
{
return(new DropResult(Result.Failure("You cannot have two active drop requests for the same game."), false));
}
DropRequest dropRequest = new DropRequest(Guid.NewGuid(), publisher, publisher.LeagueYear, masterGame, _clock.GetCurrentInstant(), null);
var supportedYears = await _fantasyCriticRepo.GetSupportedYears();
var publishersInLeague = await _fantasyCriticRepo.GetPublishersInLeagueForYear(publisher.LeagueYear);
var otherPublishers = publishersInLeague.Except(new List <Publisher>()
{
publisher
});
var dropResult = CanDropGame(dropRequest, supportedYears, publisher.LeagueYear, publisher, otherPublishers);
if (dropResult.Result.IsFailure)
{
return(dropResult);
}
await _fantasyCriticRepo.CreateDropRequest(dropRequest);
return(dropResult);
}
public async Task <DropProcessingResults> GetDropProcessingDryRun(int year)
{
IReadOnlyDictionary <LeagueYear, IReadOnlyList <DropRequest> > leaguesAndDropRequests = await _fantasyCriticRepo.GetActiveDropRequests(year);
IReadOnlyList <Publisher> allPublishers = await _fantasyCriticRepo.GetAllPublishersForYear(year);
var supportedYears = await _fantasyCriticRepo.GetSupportedYears();
IReadOnlyDictionary <LeagueYear, IReadOnlyList <DropRequest> > onlyLeaguesWithDrops = leaguesAndDropRequests.Where(x => x.Value.Any()).ToDictionary(x => x.Key, y => y.Value);
var publishersInLeagues = allPublishers.Where(x => onlyLeaguesWithDrops.ContainsKey(x.LeagueYear));
DropProcessingResults results = _actionProcessingService.ProcessDropsIteration(onlyLeaguesWithDrops, publishersInLeagues, _clock, supportedYears);
return(results);
}
public async Task <DropResult> MakeDropRequest(LeagueYear leagueYear, Publisher publisher, PublisherGame publisherGame, bool justCheck)
{
if (publisherGame.CounterPick)
{
return(new DropResult(Result.Failure("You can't drop a counter pick.")));
}
if (publisherGame.MasterGame is null)
{
return(new DropResult(Result.Failure("You can't drop a game that is not linked to a master game. Please see the FAQ section on dropping games.")));
}
MasterGame masterGame = publisherGame.MasterGame.MasterGame;
IReadOnlyList <DropRequest> dropRequests = await _fantasyCriticRepo.GetActiveDropRequests(leagueYear, publisher);
bool alreadyDropping = dropRequests.Select(x => x.MasterGame.MasterGameID).Contains(masterGame.MasterGameID);
if (alreadyDropping)
{
return(new DropResult(Result.Failure("You cannot have two active drop requests for the same game.")));
}
DropRequest dropRequest = new DropRequest(Guid.NewGuid(), publisher, leagueYear, masterGame, _clock.GetCurrentInstant(), null, null);
var dropResult = CanDropGame(dropRequest, leagueYear, publisher);
if (dropResult.Result.IsFailure)
{
return(dropResult);
}
if (!justCheck)
{
await _fantasyCriticRepo.CreateDropRequest(dropRequest);
}
return(dropResult);
}
public async Task <FinalizedActionProcessingResults> GetActionProcessingDryRun(SystemWideValues systemWideValues, int year, Instant processingTime, IReadOnlyList <LeagueYear> allLeagueYears)
{
IReadOnlyDictionary <LeagueYear, IReadOnlyList <PickupBid> > leaguesAndBids = await _fantasyCriticRepo.GetActivePickupBids(year, allLeagueYears);
IReadOnlyDictionary <LeagueYear, IReadOnlyList <DropRequest> > leaguesAndDropRequests = await _fantasyCriticRepo.GetActiveDropRequests(year, allLeagueYears);
var onlyLeaguesWithActions = leaguesAndBids
.Where(x => x.Value.Any()).Select(x => x.Key)
.Concat(leaguesAndDropRequests.Where(x => x.Value.Any()).Select(x => x.Key))
.Distinct().Select(x => x.Key).ToHashSet();
var publishersInLeagues = allLeagueYears.SelectMany(x => x.Publishers).Where(x => onlyLeaguesWithActions.Contains(x.LeagueYearKey));
var masterGameYears = await _interLeagueService.GetMasterGameYears(year);
var masterGameYearDictionary = masterGameYears.ToDictionary(x => x.MasterGame.MasterGameID);
FinalizedActionProcessingResults results = _actionProcessingService.ProcessActions(systemWideValues, leaguesAndBids, leaguesAndDropRequests, publishersInLeagues, processingTime, masterGameYearDictionary);
return(results);
}