public FinalizedActionProcessingResults ProcessActions(SystemWideValues systemWideValues, IReadOnlyDictionary <LeagueYear, IReadOnlyList <PickupBid> > allActiveBids,
IReadOnlyDictionary <LeagueYear, IReadOnlyList <DropRequest> > allActiveDrops, IEnumerable <Publisher> publishers, Instant processingTime, IReadOnlyDictionary <Guid, MasterGameYear> masterGameYearDictionary)
{
var publisherStateSet = new PublisherStateSet(publishers);
var flatBids = allActiveBids.SelectMany(x => x.Value);
var invalidBids = flatBids.Where(x => x.CounterPick && x.ConditionalDropPublisherGame is not null);
if (invalidBids.Any())
{
throw new Exception("There are counter pick bids with conditional drops.");
}
string processName = $"Drop/Bid Processing ({processingTime.ToEasternDate()})";
Guid processSetID = Guid.NewGuid();
if (!allActiveBids.Any() && !allActiveDrops.Any())
{
var emptyResults = ActionProcessingResults.GetEmptyResultsSet(publisherStateSet);
return(new FinalizedActionProcessingResults(processSetID, processingTime, processName, emptyResults));
}
ActionProcessingResults dropResults = ProcessDrops(allActiveDrops, publisherStateSet, processingTime);
if (!allActiveBids.Any())
{
return(new FinalizedActionProcessingResults(processSetID, processingTime, processName, dropResults));
}
ActionProcessingResults bidResults = ProcessPickupsIteration(systemWideValues, allActiveBids, dropResults, processingTime, masterGameYearDictionary);
return(new FinalizedActionProcessingResults(processSetID, processingTime, processName, bidResults));
}
private ActionProcessingResults(IEnumerable <SucceededPickupBid> successBids, IEnumerable <FailedPickupBid> failedBids,
IEnumerable <DropRequest> successDrops, IEnumerable <DropRequest> failedDrops, IEnumerable <LeagueAction> leagueActions,
PublisherStateSet publisherStateSet, IEnumerable <PublisherGame> addedPublisherGames, IEnumerable <FormerPublisherGame> removedPublisherGames)
{
SuccessBids = successBids.ToList();
FailedBids = failedBids.ToList();
SuccessDrops = successDrops.ToList();
FailedDrops = failedDrops.ToList();
LeagueActions = leagueActions.ToList();
PublisherStateSet = publisherStateSet;
AddedPublisherGames = addedPublisherGames.ToList();
RemovedPublisherGames = removedPublisherGames.ToList();
}
public IReadOnlyList <Publisher> GetUpdatedPublishers()
{
var publisherStateSet = new PublisherStateSet(new List <Publisher>()
{
Proposer,
CounterParty
});
publisherStateSet.ObtainBudgetForPublisher(Proposer, CounterPartyBudgetSendAmount);
publisherStateSet.SpendBudgetForPublisher(Proposer, ProposerBudgetSendAmount);
publisherStateSet.ObtainBudgetForPublisher(CounterParty, ProposerBudgetSendAmount);
publisherStateSet.SpendBudgetForPublisher(CounterParty, CounterPartyBudgetSendAmount);
return(publisherStateSet.Publishers);
}
public IReadOnlyList <LeagueYearPublisherPair> GetAllAffectedPublisherPairs()
{
var publisherPairsToInclude = SuccessBids.Select(x => x.PickupBid.GetLeagueYearPublisherPair())
.Concat(FailedBids.Select(x => x.PickupBid.GetLeagueYearPublisherPair()))
.Concat(SuccessDrops.Select(x => x.GetLeagueYearPublisherPair()))
.Concat(FailedDrops.Select(x => x.GetLeagueYearPublisherPair()));
List <LeagueYearPublisherPair> updatedPublisherPairs = new List <LeagueYearPublisherPair>();
foreach (var publisherPair in publisherPairsToInclude)
{
var updatedPublisher = PublisherStateSet.GetPublisher(publisherPair.Publisher.PublisherID);
updatedPublisherPairs.Add(new LeagueYearPublisherPair(publisherPair.LeagueYear, updatedPublisher));
}
return(updatedPublisherPairs);
}
public static ActionProcessingResults GetResultsSetFromBidResults(IEnumerable <SucceededPickupBid> successBids, IEnumerable <FailedPickupBid> simpleFailedBids,
IEnumerable <LeagueAction> leagueActions, PublisherStateSet publisherStateSet, IEnumerable <PublisherGame> gamesToAdd, IEnumerable <FormerPublisherGame> droppedPublisherGames)
{
return(new ActionProcessingResults(successBids, simpleFailedBids, new List <DropRequest>(),
new List <DropRequest>(), leagueActions, publisherStateSet, gamesToAdd, droppedPublisherGames));
}
public static ActionProcessingResults GetResultsSetFromDropResults(IEnumerable <DropRequest> successDrops, IEnumerable <DropRequest> failedDrops,
IEnumerable <LeagueAction> leagueActions, PublisherStateSet publisherStateSet, IEnumerable <FormerPublisherGame> droppedPublisherGames)
{
return(new ActionProcessingResults(new List <SucceededPickupBid>(), new List <FailedPickupBid>(), successDrops,
failedDrops, leagueActions, publisherStateSet, new List <PublisherGame>(), droppedPublisherGames));
}
public static ActionProcessingResults GetEmptyResultsSet(PublisherStateSet publisherStateSet)
{
return(new ActionProcessingResults(new List <SucceededPickupBid>(), new List <FailedPickupBid>(), new List <DropRequest>(),
new List <DropRequest>(), new List <LeagueAction>(), publisherStateSet, new List <PublisherGame>(), new List <FormerPublisherGame>()));
}
private ActionProcessingResults ProcessDrops(IReadOnlyDictionary <LeagueYear, IReadOnlyList <DropRequest> > allDropRequests, PublisherStateSet publisherStateSet, Instant processingTime)
{
List <FormerPublisherGame> gamesToDelete = new List <FormerPublisherGame>();
List <LeagueAction> leagueActions = new List <LeagueAction>();
List <DropRequest> successDrops = new List <DropRequest>();
List <DropRequest> failedDrops = new List <DropRequest>();
foreach (var leagueYearGroup in allDropRequests)
{
foreach (var dropRequest in leagueYearGroup.Value)
{
var affectedPublisher = publisherStateSet.GetPublisher(dropRequest.Publisher.PublisherID);
var dropResult = _gameAcquisitionService.CanDropGame(dropRequest, leagueYearGroup.Key, affectedPublisher);
if (dropResult.Result.IsSuccess)
{
successDrops.Add(dropRequest);
var publisherGame = dropRequest.Publisher.GetPublisherGameOrThrow(dropRequest.MasterGame);
var formerPublisherGame = publisherGame.GetFormerPublisherGame(processingTime, "Dropped by player");
gamesToDelete.Add(formerPublisherGame);
LeagueAction leagueAction = new LeagueAction(dropRequest, dropResult, processingTime);
publisherStateSet.DropGameForPublisher(affectedPublisher, publisherGame, leagueYearGroup.Key.Options);
leagueActions.Add(leagueAction);
}
else
{
failedDrops.Add(dropRequest);
LeagueAction leagueAction = new LeagueAction(dropRequest, dropResult, processingTime);
leagueActions.Add(leagueAction);
}
}
}
ActionProcessingResults dropProcessingResults = ActionProcessingResults.GetResultsSetFromDropResults(successDrops, failedDrops, leagueActions, publisherStateSet, gamesToDelete);
return(dropProcessingResults);
}
private ProcessedBidSet ProcessPickupsForLeagueYear(LeagueYear leagueYear, IReadOnlyList <PickupBid> activeBidsForLeague,
PublisherStateSet publisherStateSet, SystemWideValues systemWideValues, Instant processingTime)
{
LeagueYear updatedLeagueYear = publisherStateSet.GetUpdatedLeagueYear(leagueYear);
var gamesGroupedByPublisherAndGame = activeBidsForLeague.GroupBy(x => (x.Publisher.PublisherID, x.MasterGame.MasterGameID));
var duplicateBidGroups = gamesGroupedByPublisherAndGame.Where(x => x.Count() > 1).ToList();
List <PickupBid> duplicateBids = new List <PickupBid>();
foreach (var duplicateBidGroup in duplicateBidGroups)
{
var bestBid = duplicateBidGroup.WhereMax(x => x.BidAmount).WhereMin(x => x.Timestamp).First();
var otherBids = duplicateBidGroup.Except(new List <PickupBid>()
{
bestBid
});
duplicateBids.AddRange(otherBids);
}
var nonDuplicateBids = activeBidsForLeague.Except(duplicateBids);
List <PickupBid> noSpaceLeftBids = new List <PickupBid>();
List <PickupBid> insufficientFundsBids = new List <PickupBid>();
List <PickupBid> belowMinimumBids = new List <PickupBid>();
List <KeyValuePair <PickupBid, string> > invalidGameBids = new List <KeyValuePair <PickupBid, string> >();
var currentDate = processingTime.ToEasternDate();
List <ValidPickupBid> validPickupBids = new List <ValidPickupBid>();
foreach (var activeBid in nonDuplicateBids)
{
Publisher bidPublisher = publisherStateSet.GetPublisher(activeBid.Publisher.PublisherID);
bool counterPickedGameIsManualWillNotRelease = PlayerGameExtensions.CounterPickedGameIsManualWillNotRelease(updatedLeagueYear, activeBid.CounterPick, activeBid.MasterGame, true);
var gameRequest = new ClaimGameDomainRequest(updatedLeagueYear, bidPublisher, activeBid.MasterGame.GameName, activeBid.CounterPick, counterPickedGameIsManualWillNotRelease, false, false, activeBid.MasterGame, null, null);
PickupBid pickupBidWithConditionalDropResult = activeBid;
int? validConditionalDropSlot = null;
if (activeBid.ConditionalDropPublisherGame is not null)
{
var conditionalDropResult = _gameAcquisitionService.CanConditionallyDropGame(activeBid, updatedLeagueYear, bidPublisher, processingTime);
pickupBidWithConditionalDropResult = activeBid.WithConditionalDropResult(conditionalDropResult);
if (conditionalDropResult.Result.IsSuccess)
{
validConditionalDropSlot = activeBid.ConditionalDropPublisherGame.SlotNumber;
}
}
var claimResult = _gameAcquisitionService.CanClaimGame(gameRequest, null, validConditionalDropSlot, true, false);
if (claimResult.NoSpaceError)
{
noSpaceLeftBids.Add(pickupBidWithConditionalDropResult);
continue;
}
if (!claimResult.Success)
{
invalidGameBids.Add(new KeyValuePair <PickupBid, string>(pickupBidWithConditionalDropResult, string.Join(" AND ", claimResult.Errors.Select(x => x.Error))));
continue;
}
if (pickupBidWithConditionalDropResult.BidAmount > bidPublisher.Budget)
{
insufficientFundsBids.Add(pickupBidWithConditionalDropResult);
continue;
}
if (pickupBidWithConditionalDropResult.BidAmount < updatedLeagueYear.Options.MinimumBidAmount)
{
belowMinimumBids.Add(pickupBidWithConditionalDropResult);
continue;
}
validPickupBids.Add(new ValidPickupBid(pickupBidWithConditionalDropResult, claimResult.BestSlotNumber !.Value));
}
var winnableBids = GetWinnableBids(updatedLeagueYear, validPickupBids, systemWideValues, currentDate);
var winningBids = GetWinningBids(winnableBids);
var takenGames = winningBids.Select(x => x.PickupBid.MasterGame);
var losingBids = activeBidsForLeague
.Except(winningBids.Select(x => x.PickupBid))
.Except(duplicateBids)
.Except(noSpaceLeftBids)
.Except(insufficientFundsBids)
.Except(belowMinimumBids)
.Except(invalidGameBids.Select(x => x.Key))
.Where(x => takenGames.Contains(x.MasterGame))
.Select(x => new FailedPickupBid(x, "Publisher was outbid.", systemWideValues, currentDate));
var duplicateBidFailures = duplicateBids.Select(x => new FailedPickupBid(x, "You cannot have multiple bids for the same game. This bid has been ignored.", systemWideValues, currentDate));
var invalidGameBidFailures = invalidGameBids.Select(x => new FailedPickupBid(x.Key, "Game is no longer eligible: " + x.Value, systemWideValues, currentDate));
var insufficientFundsBidFailures = insufficientFundsBids.Select(x => new FailedPickupBid(x, "Not enough budget.", systemWideValues, currentDate));
var belowMinimumBidFailures = belowMinimumBids.Select(x => new FailedPickupBid(x, "Bid is below the minimum bid amount.", systemWideValues, currentDate));
List <FailedPickupBid> noSpaceLeftBidFailures = new List <FailedPickupBid>();
foreach (var noSpaceLeftBid in noSpaceLeftBids)
{
FailedPickupBid failedBid;
if (noSpaceLeftBid.ConditionalDropPublisherGame is not null && noSpaceLeftBid.ConditionalDropResult !.Result.IsFailure)
{
failedBid = new FailedPickupBid(noSpaceLeftBid, "No roster spots available. Attempted to conditionally drop game: " +
$"{noSpaceLeftBid.ConditionalDropPublisherGame.MasterGame!.MasterGame.GameName} " +
$"but failed because: {noSpaceLeftBid.ConditionalDropResult.Result.Error}", systemWideValues, currentDate);
}