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();
}
