public Publisher(Guid publisherID, LeagueYearKey leagueYearKey, FantasyCriticUser user, string publisherName, string?publisherIcon, int draftPosition,
IEnumerable <PublisherGame> publisherGames, IEnumerable <FormerPublisherGame> formerPublisherGames, uint budget, int freeGamesDropped, int willNotReleaseGamesDropped, int willReleaseGamesDropped,
bool autoDraft)
{
PublisherID = publisherID;
LeagueYearKey = leagueYearKey;
User = user;
PublisherName = publisherName;
PublisherIcon = publisherIcon;
DraftPosition = draftPosition;
PublisherGames = publisherGames.ToList();
FormerPublisherGames = formerPublisherGames.ToList();
Budget = budget;
FreeGamesDropped = freeGamesDropped;
WillNotReleaseGamesDropped = willNotReleaseGamesDropped;
WillReleaseGamesDropped = willReleaseGamesDropped;
AutoDraft = autoDraft;
}
public async Task DeleteUserAccount(FantasyCriticUser user)
{
string deleteRoyaleGames = "delete tbl_royale_publishergame from tbl_royale_publishergame " +
"join tbl_royale_publisher on tbl_royale_publisher.PublisherID = tbl_royale_publishergame.PublisherID " +
"where UserID = @userID;";
string deleteRoyalePublishers = "delete tbl_royale_publisher from tbl_royale_publisher " +
"where UserID = @userID;";
string updatePublisherNames = "UPDATE tbl_league_publisher SET PublisherName = '<Deleted>' WHERE UserID = @userID;";
string deleteUnprocessedDrops = "DELETE tbl_league_pickupbid FROM tbl_league_pickupbid " +
"join tbl_league_publisher on tbl_league_publisher.PublisherID = tbl_league_pickupbid.PublisherID " +
"WHERE UserID = @userID AND Successful IS null;";
string deleteUnprocessedBids = "DELETE tbl_league_droprequest FROM tbl_league_droprequest " +
"join tbl_league_publisher on tbl_league_publisher.PublisherID = tbl_league_droprequest.PublisherID " +
"WHERE UserID = @userID AND Successful IS null;";
string updateUserAccount = "UPDATE tbl_user SET " +
"DisplayName = '<Deleted>', " +
"EmailAddress = @fakeEmailAddress, " +
"NormalizedEmailAddress = @fakeEmailAddress, " +
"PasswordHash = '', " +
"SecurityStamp = '', " +
"IsDeleted = 1 " +
"WHERE UserID = @userID;";
var deleteObject = new
{
userID = user.UserID,
fakeEmailAddress = $"{user.UserID}@fake.fake"
};
using (var connection = new MySqlConnection(_connectionString))
{
await connection.OpenAsync();
using (var transaction = await connection.BeginTransactionAsync())
{
await connection.ExecuteAsync(deleteRoyaleGames, deleteObject, transaction);
await connection.ExecuteAsync(deleteRoyalePublishers, deleteObject, transaction);
await connection.ExecuteAsync(updatePublisherNames, deleteObject, transaction);
await connection.ExecuteAsync(deleteUnprocessedDrops, deleteObject, transaction);
await connection.ExecuteAsync(deleteUnprocessedBids, deleteObject, transaction);
await connection.ExecuteAsync(updateUserAccount, deleteObject, transaction);
transaction.Commit();
}
}
}
public async Task <IReadOnlyList <League> > GetLeaguesForUser(FantasyCriticUser currentUser)
{
IEnumerable <LeagueEntity> leagueEntities;
using (var connection = new MySqlConnection(_connectionString))
{
var queryObject = new
{
userID = currentUser.UserID,
};
leagueEntities = await connection.QueryAsync <LeagueEntity>(
"select tblleague.* from tblleague join tblleaguehasuser on (tblleague.LeagueID = tblleaguehasuser.LeagueID) where tblleaguehasuser.UserID = @userID;", queryObject);
}
IReadOnlyList <League> leagues = await ConvertLeagueEntitiesToDomain(leagueEntities);
return(leagues);
}
public MasterGameRequest ToDomain(FantasyCriticUser user, Instant requestTimestamp, EligibilityLevel eligibilityLevel)
{
int?steamID = null;
var steamGameIDString = SubstringSearching.GetBetween(SteamLink, "/app/", "/");
if (steamGameIDString.IsSuccess)
{
bool parseResult = int.TryParse(steamGameIDString.Value, out int steamIDResult);
if (parseResult)
{
steamID = steamIDResult;
}
}
int?openCriticID = URLParsingExtensions.GetOpenCriticIDFromURL(OpenCriticLink);
return(new MasterGameRequest(Guid.NewGuid(), user, requestTimestamp, RequestNote, GameName, steamID, openCriticID, EstimatedReleaseDate, eligibilityLevel,
YearlyInstallment, EarlyAccess, FreeToPlay, ReleasedInternationally, ExpansionPack, false, null, null, Maybe <Lib.Domain.MasterGame> .None, false));
}
public async Task RemoveLoginAsync(FantasyCriticUser user, string loginProvider, string providerKey, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var sql = "DELETE from tbl_user_externallogin where LoginProvider = @LoginProvider and ProviderKey = @ProviderKey and UserID = @UserID;";
var deleteObject = new
{
LoginProvider = loginProvider,
ProviderKey = providerKey,
UserID = user.Id
};
await using (var connection = new MySqlConnection(_connectionString))
{
await connection.ExecuteAsync(sql, deleteObject);
}
_userCache = null;
}
public MasterGameRequest ToDomain(FantasyCriticUser user, EligibilityLevel eligibilityLevel, Maybe <MasterGame> masterGame)
{
Instant requestTimestamp = LocalDateTime.FromDateTime(RequestTimestamp).InZoneStrictly(DateTimeZone.Utc).ToInstant();
Instant?responseTimestamp = null;
if (ResponseTimestamp.HasValue)
{
responseTimestamp = LocalDateTime.FromDateTime(ResponseTimestamp.Value).InZoneStrictly(DateTimeZone.Utc).ToInstant();
}
LocalDate?releaseDate = null;
if (ReleaseDate.HasValue)
{
releaseDate = LocalDate.FromDateTime(ReleaseDate.Value);
}
return(new MasterGameRequest(RequestID, user, requestTimestamp, RequestNote, GameName, SteamID, OpenCriticID, releaseDate, EstimatedReleaseDate, eligibilityLevel,
YearlyInstallment, EarlyAccess, FreeToPlay, ReleasedInternationally, ExpansionPack, UnannouncedGame, Answered, responseTimestamp, ResponseNote, masterGame, Hidden));
}
public async Task <IReadOnlyList <League> > GetLeaguesInvitedTo(FantasyCriticUser currentUser)
{
var query = new
{
email = currentUser.EmailAddress
};
IEnumerable <LeagueEntity> leagueEntities;
using (var connection = new MySqlConnection(_connectionString))
{
leagueEntities = await connection.QueryAsync <LeagueEntity>(
"select tblleague.* from tblleague join tblleagueinvite on (tblleague.LeagueID = tblleagueinvite.LeagueID) where tblleagueinvite.EmailAddress = @email;",
query);
}
IReadOnlyList <League> leagues = await ConvertLeagueEntitiesToDomain(leagueEntities);
return(leagues);
}
public MasterGameRequest(Guid requestID, FantasyCriticUser user, Instant requestTimestamp, string requestNote,
string gameName, int?steamID, int?openCriticID, string?ggToken, LocalDate?releaseDate, string estimatedReleaseDate,
bool answered, Instant?responseTimestamp, string?responseNote, MasterGame?masterGame, bool hidden)
{
RequestID = requestID;
User = user;
RequestTimestamp = requestTimestamp;
RequestNote = requestNote;
GameName = gameName;
SteamID = steamID;
OpenCriticID = openCriticID;
GGToken = ggToken;
ReleaseDate = releaseDate;
EstimatedReleaseDate = estimatedReleaseDate;
Answered = answered;
ResponseTimestamp = responseTimestamp;
ResponseNote = responseNote;
MasterGame = masterGame;
Hidden = hidden;
}
public async Task <Result> AcceptInvite(League league, FantasyCriticUser inviteUser)
{
bool userInLeague = await UserIsInLeague(league, inviteUser);
if (userInLeague)
{
return(Result.Failure("User is already in league."));
}
var invite = await GetMatchingInvite(league, inviteUser.EmailAddress);
if (invite.HasNoValue)
{
return(Result.Failure("User is not invited to this league."));
}
await _fantasyCriticRepo.AcceptInvite(invite.Value, inviteUser);
return(Result.Success());
}
public MasterGameRequest ToDomain(FantasyCriticUser user, Maybe <MasterGame> masterGame)
{
Instant requestTimestamp = LocalDateTime.FromDateTime(RequestTimestamp).InZoneStrictly(DateTimeZone.Utc).ToInstant();
Instant?responseTimestamp = null;
if (ResponseTimestamp.HasValue)
{
responseTimestamp = LocalDateTime.FromDateTime(ResponseTimestamp.Value).InZoneStrictly(DateTimeZone.Utc).ToInstant();
}
LocalDate?releaseDate = null;
if (ReleaseDate.HasValue)
{
releaseDate = LocalDate.FromDateTime(ReleaseDate.Value);
}
return(new MasterGameRequest(RequestID, user, requestTimestamp, RequestNote, GameName, SteamID, OpenCriticID, releaseDate, EstimatedReleaseDate,
Answered, responseTimestamp, ResponseNote, masterGame, Hidden));
}
public async Task <Result> DeclineInvite(League league, FantasyCriticUser inviteUser)
{
bool userInLeague = await UserIsInLeague(league, inviteUser);
if (userInLeague)
{
return(Result.Fail("User is already in league."));
}
bool userInvited = await UserIsInvited(league, inviteUser.EmailAddress);
if (!userInvited)
{
return(Result.Fail("User is not invited to this league."));
}
await _fantasyCriticRepo.DeclineInvite(league, inviteUser);
return(Result.Ok());
}
private async Task <ObjectResult> GetToken(FantasyCriticUser user)
{
var roles = await _userManager.GetRolesAsync(user);
var claims = user.GetUserClaims(roles);
var jwtToken = _tokenService.GenerateAccessToken(claims);
var refreshToken = _tokenService.GenerateRefreshToken();
await _userManager.AddRefreshToken(user, refreshToken);
await _userManager.ClearOldRefreshTokens(user);
var jwtString = new JwtSecurityTokenHandler().WriteToken(jwtToken);
return(new ObjectResult(new
{
token = jwtString,
refreshToken,
expiration = jwtToken.ValidTo
}));
}
public async Task <IdentityResult> CreateAsync(FantasyCriticUser user, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
FantasyCriticUserEntity entity = new FantasyCriticUserEntity(user);
await using (var connection = new MySqlConnection(_connectionString))
{
await connection.OpenAsync(cancellationToken);
await connection.ExecuteAsync(
"insert into tbl_user(UserID,DisplayName,PatreonDonorNameOverride,DisplayNumber,EmailAddress,NormalizedEmailAddress,PasswordHash,SecurityStamp," +
"TwoFactorEnabled,AuthenticatorKey,LastChangedCredentials,EmailConfirmed,IsDeleted) VALUES " +
"(@UserID,@DisplayName,@PatreonDonorNameOverride,@DisplayNumber,@EmailAddress,@NormalizedEmailAddress,@PasswordHash,@SecurityStamp," +
"@TwoFactorEnabled,@AuthenticatorKey,@LastChangedCredentials,@EmailConfirmed,@IsDeleted)",
entity);
}
_userCache = null;
return(IdentityResult.Success);
}
public async Task <Maybe <League> > GetLeagueByID(Guid id)
{
using (var connection = new MySqlConnection(_connectionString))
{
var queryObject = new
{
leagueID = id
};
LeagueEntity leagueEntity = await connection.QuerySingleAsync <LeagueEntity>(
"select * from tblleague where LeagueID = @leagueID", queryObject);
FantasyCriticUser manager = await _userStore.FindByIdAsync(leagueEntity.LeagueManager.ToString(), CancellationToken.None);
IEnumerable <LeagueYearEntity> yearEntities = await connection.QueryAsync <LeagueYearEntity>("select * from tblleagueyear where LeagueID = @leagueID", queryObject);
IEnumerable <int> years = yearEntities.Select(x => x.Year);
League league = leagueEntity.ToDomain(manager, years);
return(league);
}
}
public async Task <Result> InviteUserByUserID(League league, FantasyCriticUser inviteUser)
{
var existingInvite = await GetMatchingInvite(league, inviteUser);
if (existingInvite.HasValue)
{
return(Result.Failure("User is already invited to this league."));
}
bool userInLeague = await UserIsInLeague(league, inviteUser);
if (userInLeague)
{
return(Result.Failure("User is already in league."));
}
LeagueInvite invite = new LeagueInvite(Guid.NewGuid(), league, inviteUser);
await _fantasyCriticRepo.SaveInvite(invite);
return(Result.Success());
}
public EditLeagueYearParameters(FantasyCriticUser manager, Guid leagueID, int year, int standardGames, int gamesToDraft, int counterPicks,
int freeDroppableGames, int willNotReleaseDroppableGames, int willReleaseDroppableGames, bool dropOnlyDraftGames, bool counterPicksBlockDrops, int minimumBidAmount,
IEnumerable <LeagueTagStatus> leagueTags, DraftSystem draftSystem, PickupSystem pickupSystem, ScoringSystem scoringSystem, bool publicLeague)
{
Manager = manager;
LeagueID = leagueID;
Year = year;
StandardGames = standardGames;
GamesToDraft = gamesToDraft;
CounterPicks = counterPicks;
FreeDroppableGames = freeDroppableGames;
WillNotReleaseDroppableGames = willNotReleaseDroppableGames;
WillReleaseDroppableGames = willReleaseDroppableGames;
DropOnlyDraftGames = dropOnlyDraftGames;
CounterPicksBlockDrops = counterPicksBlockDrops;
MinimumBidAmount = minimumBidAmount;
LeagueTags = leagueTags.ToList();
DraftSystem = draftSystem;
PickupSystem = pickupSystem;
ScoringSystem = scoringSystem;
PublicLeague = publicLeague;
}
public EditLeagueYearParameters(FantasyCriticUser manager, Guid leagueID, int year, int standardGames, int gamesToDraft, int counterPicks,
int freeDroppableGames, int willNotReleaseDroppableGames, int willReleaseDroppableGames, bool dropOnlyDraftGames, EligibilityLevel maximumEligibilityLevel, bool allowYearlyInstallments,
bool allowEarlyAccess, bool allowFreeToPlay, bool allowReleasedInternationally, bool allowExpansions, DraftSystem draftSystem,
PickupSystem pickupSystem, ScoringSystem scoringSystem, bool publicLeague)
{
Manager = manager;
LeagueID = leagueID;
Year = year;
StandardGames = standardGames;
GamesToDraft = gamesToDraft;
CounterPicks = counterPicks;
FreeDroppableGames = freeDroppableGames;
WillNotReleaseDroppableGames = willNotReleaseDroppableGames;
WillReleaseDroppableGames = willReleaseDroppableGames;
DropOnlyDraftGames = dropOnlyDraftGames;
AllowedEligibilitySettings = new EligibilitySettings(maximumEligibilityLevel, allowYearlyInstallments, allowEarlyAccess, allowFreeToPlay,
allowReleasedInternationally, allowExpansions);
DraftSystem = draftSystem;
PickupSystem = pickupSystem;
ScoringSystem = scoringSystem;
PublicLeague = publicLeague;
}
public LeagueCreationParameters(FantasyCriticUser manager, string leagueName, int standardGames, int gamesToDraft, int counterPicks,
int freeDroppableGames, int willNotReleaseDroppableGames, int willReleaseDroppableGames, bool dropOnlyDraftGames, bool counterPicksBlockDrops, int minimumBidAmount,
int initialYear, IEnumerable <LeagueTagStatus> leagueTags, DraftSystem draftSystem, PickupSystem pickupSystem, ScoringSystem scoringSystem, bool publicLeague, bool testLeague)
{
Manager = manager;
LeagueName = leagueName;
StandardGames = standardGames;
GamesToDraft = gamesToDraft;
CounterPicks = counterPicks;
FreeDroppableGames = freeDroppableGames;
WillNotReleaseDroppableGames = willNotReleaseDroppableGames;
WillReleaseDroppableGames = willReleaseDroppableGames;
DropOnlyDraftGames = dropOnlyDraftGames;
CounterPicksBlockDrops = counterPicksBlockDrops;
MinimumBidAmount = minimumBidAmount;
InitialYear = initialYear;
LeagueTags = leagueTags.ToList();
DraftSystem = draftSystem;
PickupSystem = pickupSystem;
ScoringSystem = scoringSystem;
PublicLeague = publicLeague;
TestLeague = testLeague;
}
public async Task AddLoginAsync(FantasyCriticUser user, UserLoginInfo login, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
ExternalLoginEntity entity = new ExternalLoginEntity()
{
UserID = user.Id,
LoginProvider = login.LoginProvider,
ProviderKey = login.ProviderKey,
ProviderDisplayName = login.ProviderDisplayName,
};
await using (var connection = new MySqlConnection(_connectionString))
{
await connection.OpenAsync(cancellationToken);
string insertSQL = "insert into tbl_user_externallogin (LoginProvider,ProviderKey,UserID,ProviderDisplayName) " +
"VALUES (@LoginProvider,@ProviderKey,@UserID,@ProviderDisplayName);";
await connection.ExecuteAsync(insertSQL, entity);
}
_userCache = null;
}
public LeagueCreationParameters(FantasyCriticUser manager, string leagueName, int standardGames, int gamesToDraft, int counterPicks,
int freeDroppableGames, int willNotReleaseDroppableGames, int willReleaseDroppableGames, bool dropOnlyDraftGames, int initialYear, EligibilityLevel maximumEligibilityLevel,
bool allowYearlyInstallments, bool allowEarlyAccess, bool allowFreeToPlay, bool allowReleasedInternationally,
bool allowExpansions, bool allowUnannouncedGames, DraftSystem draftSystem, PickupSystem pickupSystem, ScoringSystem scoringSystem, bool publicLeague, bool testLeague)
{
Manager = manager;
LeagueName = leagueName;
StandardGames = standardGames;
GamesToDraft = gamesToDraft;
CounterPicks = counterPicks;
FreeDroppableGames = freeDroppableGames;
WillNotReleaseDroppableGames = willNotReleaseDroppableGames;
WillReleaseDroppableGames = willReleaseDroppableGames;
DropOnlyDraftGames = dropOnlyDraftGames;
InitialYear = initialYear;
AllowedEligibilitySettings = new EligibilitySettings(maximumEligibilityLevel, allowYearlyInstallments, allowEarlyAccess,
allowFreeToPlay, allowReleasedInternationally, allowExpansions, allowUnannouncedGames);
DraftSystem = draftSystem;
PickupSystem = pickupSystem;
ScoringSystem = scoringSystem;
PublicLeague = publicLeague;
TestLeague = testLeague;
}
public async Task <RoyalePublisher?> GetPublisher(RoyaleYearQuarter yearQuarter, FantasyCriticUser user)
{
string sql = "select * from tbl_royale_publisher where UserID = @userID and Year = @year and Quarter = @quarter;";
await using var connection = new MySqlConnection(_connectionString);
var entity = await connection.QuerySingleOrDefaultAsync <RoyalePublisherEntity>(sql,
new
{
userID = user.Id,
year = yearQuarter.YearQuarter.Year,
quarter = yearQuarter.YearQuarter.Quarter
});
if (entity is null)
{
return(null);
}
var publisherGames = await GetGamesForPublisher(entity.PublisherID, yearQuarter);
var domain = entity.ToDomain(yearQuarter, user, publisherGames);
return(domain);
}
private async Task <IReadOnlyList <League> > ConvertLeagueEntitiesToDomain(IEnumerable <LeagueEntity> leagueEntities)
{
using (var connection = new MySqlConnection(_connectionString))
{
List <League> leagues = new List <League>();
foreach (var leagueEntity in leagueEntities)
{
FantasyCriticUser manager = await _userStore.FindByIdAsync(leagueEntity.LeagueManager.ToString(),
CancellationToken.None);
IEnumerable <LeagueYearEntity> yearEntities = await connection.QueryAsync <LeagueYearEntity>(
"select * from tblleagueyear where LeagueID = @leagueID", new
{
leagueID = leagueEntity.LeagueID
});
IEnumerable <int> years = yearEntities.Select(x => x.Year);
League league = leagueEntity.ToDomain(manager, years);
leagues.Add(league);
}
return(leagues);
}
}
public async Task <Result> InviteUser(League league, string inviteEmail)
{
bool userInvited = await UserIsInvited(league, inviteEmail);
if (userInvited)
{
return(Result.Fail("User is already invited to this league."));
}
FantasyCriticUser inviteUser = await _userManager.FindByEmailAsync(inviteEmail);
if (inviteUser != null)
{
bool userInLeague = await UserIsInLeague(league, inviteUser);
if (userInLeague)
{
return(Result.Fail("User is already in league."));
}
}
IReadOnlyList <FantasyCriticUser> players = await GetUsersInLeague(league);
IReadOnlyList <string> outstandingInvites = await GetOutstandingInvitees(league);
int totalPlayers = players.Count + outstandingInvites.Count;
if (totalPlayers >= 14)
{
return(Result.Fail("A league cannot have more than 14 players."));
}
await _fantasyCriticRepo.SaveInvite(league, inviteEmail);
return(Result.Ok());
}
public async Task <IReadOnlyList <MasterGameChangeRequest> > GetMasterGameChangeRequestsForUser(FantasyCriticUser user)
{
var sql = "select * from tbl_mastergame_changerequest where UserID = @userID and Hidden = 0";
using (var connection = new MySqlConnection(_connectionString))
{
IEnumerable <MasterGameChangeRequestEntity> entities = await connection.QueryAsync <MasterGameChangeRequestEntity>(sql, new { userID = user.UserID });
return(await ConvertMasterGameChangeRequestEntities(entities));
}
}
public LeagueInvite ToDomain(League league, FantasyCriticUser user)
{
return(new LeagueInvite(InviteID, league, user));
}
public Task <string> GetEmailAsync(FantasyCriticUser user, CancellationToken cancellationToken)
{
return(Task.FromResult(user.EmailAddress));
}
public Task SetEmailAsync(FantasyCriticUser user, string email, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public Task <IdentityResult> DeleteAsync(FantasyCriticUser user, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public Task SetNormalizedUserNameAsync(FantasyCriticUser user, string normalizedName, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public Task <string> GetNormalizedUserNameAsync(FantasyCriticUser user, CancellationToken cancellationToken)
{
return(Task.FromResult(user.NormalizedEmailAddress));
}
