public EditLeagueYearParameters ToDomain(FantasyCriticUser manager, EligibilityLevel maximumEligibilityLevel)
{
DraftSystem draftSystem = Lib.Enums.DraftSystem.FromValue(DraftSystem);
PickupSystem pickupSystem = Lib.Enums.PickupSystem.FromValue(PickupSystem);
ScoringSystem scoringSystem = Lib.Domain.ScoringSystems.ScoringSystem.GetScoringSystem(ScoringSystem);
int freeDroppableGames = FreeDroppableGames;
if (UnlimitedFreeDroppableGames)
{
freeDroppableGames = -1;
}
int willNotReleaseDroppableGames = WillNotReleaseDroppableGames;
if (UnlimitedWillNotReleaseDroppableGames)
{
willNotReleaseDroppableGames = -1;
}
int willReleaseDroppableGames = WillReleaseDroppableGames;
if (UnlimitedWillReleaseDroppableGames)
{
willReleaseDroppableGames = -1;
}
EditLeagueYearParameters parameters = new EditLeagueYearParameters(manager, LeagueID, Year, StandardGames, GamesToDraft, CounterPicks,
freeDroppableGames, willNotReleaseDroppableGames, willReleaseDroppableGames, DropOnlyDraftGames, maximumEligibilityLevel, AllowYearlyInstallments,
AllowEarlyAccess, AllowFreeToPlay, AllowReleasedInternationally, AllowExpansions, draftSystem, pickupSystem, scoringSystem, PublicLeague);
return(parameters);
}
public EditLeagueYearParameters ToDomain(FantasyCriticUser manager, IReadOnlyDictionary <string, MasterGameTag> tagDictionary)
{
DraftSystem draftSystem = Lib.Enums.DraftSystem.FromValue(DraftSystem);
PickupSystem pickupSystem = Lib.Enums.PickupSystem.FromValue(PickupSystem);
ScoringSystem scoringSystem = Lib.Domain.ScoringSystems.ScoringSystem.GetScoringSystem(ScoringSystem);
int freeDroppableGames = FreeDroppableGames;
if (UnlimitedFreeDroppableGames)
{
freeDroppableGames = -1;
}
int willNotReleaseDroppableGames = WillNotReleaseDroppableGames;
if (UnlimitedWillNotReleaseDroppableGames)
{
willNotReleaseDroppableGames = -1;
}
int willReleaseDroppableGames = WillReleaseDroppableGames;
if (UnlimitedWillReleaseDroppableGames)
{
willReleaseDroppableGames = -1;
}
var leagueTags = Tags.ToDomain(tagDictionary);
EditLeagueYearParameters parameters = new EditLeagueYearParameters(manager, LeagueID, Year, StandardGames, GamesToDraft, CounterPicks,
freeDroppableGames, willNotReleaseDroppableGames, willReleaseDroppableGames, DropOnlyDraftGames, CounterPicksBlockDrops, MinimumBidAmount,
leagueTags, draftSystem, pickupSystem, scoringSystem, PublicLeague);
return(parameters);
}
public async Task <IActionResult> EditLeagueYearSettings([FromBody] LeagueYearSettingsViewModel request)
{
var currentUser = await _userManager.FindByNameAsync(User.Identity.Name);
if (currentUser == null)
{
return(BadRequest());
}
if (!request.ValidForOldYears())
{
return(BadRequest());
}
var systemWideSettings = await _interLeagueService.GetSystemWideSettings();
if (systemWideSettings.BidProcessingMode)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
var league = await _fantasyCriticService.GetLeagueByID(request.LeagueID);
if (league.HasNoValue)
{
return(BadRequest());
}
var leagueYear = await _fantasyCriticService.GetLeagueYear(league.Value.LeagueID, request.Year);
if (leagueYear.HasNoValue)
{
return(BadRequest());
}
if (league.Value.LeagueManager.UserID != currentUser.UserID)
{
return(Forbid());
}
EligibilityLevel eligibilityLevel = await _interLeagueService.GetEligibilityLevel(request.MaximumEligibilityLevel);
EditLeagueYearParameters domainRequest = request.ToDomain(currentUser, eligibilityLevel);
Result result = await _fantasyCriticService.EditLeague(league.Value, domainRequest);
if (result.IsFailure)
{
return(BadRequest(result.Error));
}
await _fantasyCriticService.UpdateFantasyPoints(leagueYear.Value);
return(Ok());
}
public async Task <Result> EditLeague(League league, EditLeagueYearParameters parameters)
{
LeagueOptions options = new LeagueOptions(parameters);
var validateOptions = options.Validate();
if (validateOptions.IsFailure)
{
return(Result.Failure(validateOptions.Error));
}
var leagueYear = await GetLeagueYear(league.LeagueID, parameters.Year);
if (leagueYear.HasNoValue)
{
throw new Exception($"League year cannot be found: {parameters.LeagueID}|{parameters.Year}");
}
IReadOnlyList <Publisher> publishers = await _publisherService.GetPublishersInLeagueForYear(leagueYear.Value);
int maxStandardGames = publishers.Select(publisher => publisher.PublisherGames.Count(x => !x.CounterPick)).DefaultIfEmpty(0).Max();
int maxCounterPicks = publishers.Select(publisher => publisher.PublisherGames.Count(x => x.CounterPick)).DefaultIfEmpty(0).Max();
if (maxStandardGames > options.StandardGames)
{
return(Result.Failure($"Cannot reduce number of standard games to {options.StandardGames} as a publisher has {maxStandardGames} draft games currently."));
}
if (maxCounterPicks > options.CounterPicks)
{
return(Result.Failure($"Cannot reduce number of counter picks to {options.CounterPicks} as a publisher has {maxCounterPicks} counter picks currently."));
}
int maxFreeGamesFreeDropped = publishers.Select(publisher => publisher.FreeGamesDropped).DefaultIfEmpty(0).Max();
int maxWillNotReleaseGamesDropped = publishers.Select(publisher => publisher.WillNotReleaseGamesDropped).DefaultIfEmpty(0).Max();
int maxWillReleaseGamesDropped = publishers.Select(publisher => publisher.WillReleaseGamesDropped).DefaultIfEmpty(0).Max();
if (maxFreeGamesFreeDropped > options.FreeDroppableGames && options.FreeDroppableGames != -1)
{
return(Result.Failure($"Cannot reduce number of unrestricted droppable games to {options.FreeDroppableGames} as a publisher has already dropped {maxFreeGamesFreeDropped} games."));
}
if (maxWillNotReleaseGamesDropped > options.WillNotReleaseDroppableGames && options.WillNotReleaseDroppableGames != -1)
{
return(Result.Failure($"Cannot reduce number of 'will not release' droppable games to {options.WillNotReleaseDroppableGames} as a publisher has already dropped {maxWillNotReleaseGamesDropped} games."));
}
if (maxWillReleaseGamesDropped > options.WillReleaseDroppableGames && options.WillReleaseDroppableGames != -1)
{
return(Result.Failure($"Cannot reduce number of 'will release' droppable games to {options.WillReleaseDroppableGames} as a publisher has already dropped {maxWillReleaseGamesDropped} games."));
}
var eligibilityOverrides = await GetEligibilityOverrides(league, parameters.Year);
LeagueYear newLeagueYear = new LeagueYear(league, parameters.Year, options, leagueYear.Value.PlayStatus, eligibilityOverrides);
await _fantasyCriticRepo.EditLeagueYear(newLeagueYear);
return(Result.Success());
}
public EditLeagueYearParameters ToDomain(FantasyCriticUser manager, EligibilityLevel maximumEligibilityLevel)
{
DraftSystem draftSystem = Lib.Enums.DraftSystem.FromValue(DraftSystem);
PickupSystem pickupSystem = Lib.Enums.PickupSystem.FromValue(PickupSystem);
ScoringSystem scoringSystem = Lib.Domain.ScoringSystems.ScoringSystem.GetScoringSystem(ScoringSystem);
EditLeagueYearParameters parameters = new EditLeagueYearParameters(manager, LeagueID, Year, StandardGames, GamesToDraft, CounterPicks,
maximumEligibilityLevel, AllowYearlyInstallments, AllowEarlyAccess, draftSystem, pickupSystem, scoringSystem);
return(parameters);
}
public LeagueOptions(EditLeagueYearParameters parameters)
{
StandardGames = parameters.StandardGames;
GamesToDraft = parameters.GamesToDraft;
CounterPicks = parameters.CounterPicks;
MaximumEligibilityLevel = parameters.MaximumEligibilityLevel;
AllowYearlyInstallments = parameters.AllowYearlyInstallments;
AllowEarlyAccess = parameters.AllowEarlyAccess;
DraftSystem = parameters.DraftSystem;
PickupSystem = parameters.PickupSystem;
ScoringSystem = parameters.ScoringSystem;
}
public LeagueOptions(EditLeagueYearParameters parameters)
{
StandardGames = parameters.StandardGames;
GamesToDraft = parameters.GamesToDraft;
CounterPicks = parameters.CounterPicks;
FreeDroppableGames = parameters.FreeDroppableGames;
WillNotReleaseDroppableGames = parameters.WillNotReleaseDroppableGames;
WillReleaseDroppableGames = parameters.WillReleaseDroppableGames;
DropOnlyDraftGames = parameters.DropOnlyDraftGames;
AllowedEligibilitySettings = parameters.AllowedEligibilitySettings;
DraftSystem = parameters.DraftSystem;
PickupSystem = parameters.PickupSystem;
ScoringSystem = parameters.ScoringSystem;
PublicLeague = parameters.PublicLeague;
}
public LeagueOptions(EditLeagueYearParameters parameters)
{
StandardGames = parameters.StandardGames;
GamesToDraft = parameters.GamesToDraft;
CounterPicks = parameters.CounterPicks;
FreeDroppableGames = parameters.FreeDroppableGames;
WillNotReleaseDroppableGames = parameters.WillNotReleaseDroppableGames;
WillReleaseDroppableGames = parameters.WillReleaseDroppableGames;
DropOnlyDraftGames = parameters.DropOnlyDraftGames;
CounterPicksBlockDrops = parameters.CounterPicksBlockDrops;
MinimumBidAmount = parameters.MinimumBidAmount;
LeagueTags = parameters.LeagueTags;
DraftSystem = parameters.DraftSystem;
PickupSystem = parameters.PickupSystem;
ScoringSystem = parameters.ScoringSystem;
PublicLeague = parameters.PublicLeague;
}
public async Task <Result> EditLeague(League league, EditLeagueYearParameters parameters)
{
LeagueOptions options = new LeagueOptions(parameters);
var validateOptions = options.Validate();
if (validateOptions.IsFailure)
{
return(Result.Fail(validateOptions.Error));
}
var leagueYear = await GetLeagueYear(league.LeagueID, parameters.Year);
if (leagueYear.HasNoValue)
{
throw new Exception($"League year cannot be found: {parameters.LeagueID}|{parameters.Year}");
}
IReadOnlyList <Publisher> publishers = await GetPublishersInLeagueForYear(league, parameters.Year);
int maxStandardGames = publishers.Select(publisher => publisher.PublisherGames.Count(x => !x.CounterPick)).DefaultIfEmpty(0).Max();
int maxCounterPicks = publishers.Select(publisher => publisher.PublisherGames.Count(x => x.CounterPick)).DefaultIfEmpty(0).Max();
if (maxStandardGames > options.StandardGames)
{
return(Result.Fail($"Cannot reduce number of standard games to {options.StandardGames} as a publisher has {maxStandardGames} draft games currently."));
}
if (maxCounterPicks > options.CounterPicks)
{
return(Result.Fail($"Cannot reduce number of counter picks to {options.CounterPicks} as a publisher has {maxCounterPicks} counter picks currently."));
}
LeagueYear newLeagueYear = new LeagueYear(league, parameters.Year, options, leagueYear.Value.PlayStatus);
await _fantasyCriticRepo.EditLeagueYear(newLeagueYear);
return(Result.Ok());
}
