protected override async Task OnStartingAsync(
IServiceProvider serviceProvider,
CancellationToken cancellationToken)
{
if (!_yastahAutoMigrationStartupAction.WhenDone.IsCompletedSuccessfully)
{
YastahDbContextLogMessages.ContextMigrationAwaiting(_logger);
}
await _yastahAutoMigrationStartupAction.WhenDone;
CharactersLogMessages.CharacterLevelDefinitionsInitializing(_logger);
var auditableActionsRepository = serviceProvider.GetRequiredService <IAuditableActionsRepository>();
var characterLevelsRepository = serviceProvider.GetRequiredService <ICharacterLevelsRepository>();
using var transactionScope = _transactionScopeFactory.CreateScope();
TransactionsLogMessages.TransactionScopeCreated(_logger);
var level1Exists = await characterLevelsRepository.AnyDefinitionsAsync(
level : 1,
experienceThreshold : 0,
isDeleted : false,
cancellationToken : cancellationToken);
if (!level1Exists)
{
CharactersLogMessages.CharacterLevelsNotInitialized(_logger);
var actionId = await auditableActionsRepository.CreateAsync(
(int)CharacterManagementAdministrationActionType.LevelDefinitionsInitialized,
_systemClock.UtcNow,
null,
cancellationToken);
AuditingLogMessages.AuditingActionCreated(_logger, actionId);
await characterLevelsRepository.MergeDefinitionAsync(
1,
0,
false,
actionId,
cancellationToken);
CharactersLogMessages.CharacterLevelDefinition1Created(_logger);
}
TransactionsLogMessages.TransactionScopeCommitting(_logger);
transactionScope.Complete();
CharactersLogMessages.CharacterLevelDefinitionsInitialized(_logger);
}
private async Task UpdateActiveTicketId(
ulong userId,
long actionId,
CancellationToken cancellationToken)
{
AuthenticationLogMessages.AuthenticationTicketInvalidating(_logger, userId, actionId);
using var transactionScope = _transactionScopeFactory.CreateScope();
TransactionsLogMessages.TransactionScopeCreated(_logger);
AuthenticationLogMessages.AuthenticationTicketActiveIdFetching(_logger, userId);
var activeTicketIdResult = await _authenticationTicketsRepository.ReadActiveIdAsync(userId, cancellationToken);
if (activeTicketIdResult.IsSuccess)
{
AuthenticationLogMessages.AuthenticationTicketActiveIdFetched(_logger, activeTicketIdResult.Value);
AuthenticationLogMessages.AuthenticationTicketDeleting(_logger, userId, activeTicketIdResult.Value);
await _authenticationTicketsRepository.DeleteAsync(
activeTicketIdResult.Value,
actionId,
cancellationToken);
AuthenticationLogMessages.AuthenticationTicketDeleted(_logger, userId, activeTicketIdResult.Value);
}
else
{
AuthenticationLogMessages.AuthenticationTicketActiveIdFetched(_logger, null);
}
AuthenticationLogMessages.AuthenticationTicketCreating(_logger, userId);
var newTicketId = await _authenticationTicketsRepository.CreateAsync(
userId,
actionId,
cancellationToken);
AuthenticationLogMessages.AuthenticationTicketCreated(_logger, userId, newTicketId);
_memoryCache.Set(MakeUserActiveTicketIdCacheKey(userId), newTicketId);
TransactionsLogMessages.TransactionScopeCommitting(_logger);
transactionScope.Complete();
AuthenticationLogMessages.AuthenticationTicketInvalidated(_logger, userId, newTicketId);
}
public async Task <OperationResult> UpdateAsync(
ulong userId,
UserUpdateModel updateModel,
ulong performedById,
CancellationToken cancellationToken)
{
UsersLogMessages.UserUpdating(_logger, userId, updateModel, performedById);
using var transactionScope = _transactionScopeFactory.CreateScope();
TransactionsLogMessages.TransactionScopeCreated(_logger);
var permissionIds = Enumerable.Union(
updateModel.GrantedPermissionIds,
updateModel.DeniedPermissionIds)
.ToArray();
UsersLogMessages.PermissionIdsValidating(_logger, permissionIds);
var permissionIdsValidationResult = await _permissionsService.ValidateIdsAsync(
permissionIds,
cancellationToken);
if (permissionIdsValidationResult.IsFailure)
{
UsersLogMessages.PermissionIdsValidationFailed(_logger, permissionIdsValidationResult);
return(permissionIdsValidationResult);
}
UsersLogMessages.PermissionIdsValidationSucceeded(_logger);
UsersLogMessages.RoleIdsValidating(_logger, updateModel.AssignedRoleIds);
var assignedRoleIdsValidationResult = await _rolesService.ValidateIdsAsync(updateModel.AssignedRoleIds, cancellationToken);
if (assignedRoleIdsValidationResult.IsFailure)
{
UsersLogMessages.RoleIdsValidationFailed(_logger, assignedRoleIdsValidationResult);
return(assignedRoleIdsValidationResult);
}
UsersLogMessages.RoleIdsValidationSucceeded(_logger);
var now = _systemClock.UtcNow;
var actionId = await _auditableActionsRepository.CreateAsync(
(int)UserManagementAdministrationActionType.UserModified,
now,
performedById,
cancellationToken);
AuditingLogMessages.AuditingActionCreated(_logger, actionId);
var anyChanges = false;
UsersLogMessages.UserPermissionMappingIdentitiesFetching(_logger, userId);
var permissionMappings = await _usersRepository.AsyncEnumeratePermissionMappingIdentities(
userId : userId,
isDeleted : false)
.ToArrayAsync(cancellationToken);
UsersLogMessages.UserPermissionMappingIdentitiesFetched(_logger, userId);
anyChanges |= await HandleRemovedPermissionMappings(
userId,
permissionMappings,
updateModel.GrantedPermissionIds,
updateModel.DeniedPermissionIds,
actionId,
cancellationToken);
anyChanges |= await HandleAddedGrantedPermissions(
permissionMappings,
updateModel.GrantedPermissionIds,
userId,
actionId,
cancellationToken);
anyChanges |= await HandleAddedDeniedPermissions(
permissionMappings,
updateModel.DeniedPermissionIds,
userId,
actionId,
cancellationToken);
UsersLogMessages.UserRoleMappingIdentitiesFetching(_logger, userId);
var roleMappings = await _usersRepository.AsyncEnumerateRoleMappingIdentities(
userId : userId,
isDeleted : false)
.ToArrayAsync(cancellationToken);
UsersLogMessages.UserRoleMappingIdentitiesFetched(_logger, userId);
anyChanges |= await HandleRemovedRoleMappings(
userId,
roleMappings,
updateModel.AssignedRoleIds,
actionId,
cancellationToken);
anyChanges |= await HandleAddedRoles(
roleMappings,
updateModel.AssignedRoleIds,
userId,
actionId,
cancellationToken);
if (!anyChanges)
{
UsersLogMessages.UserUpdateNoChangesGiven(_logger, userId);
return(new NoChangesGivenError($"User ID {userId}"));
}
UsersLogMessages.UserUpdatingNotificationPublishing(_logger, userId);
await _messenger.PublishNotificationAsync(
new UserUpdatingNotification(
userId,
actionId),
cancellationToken);
UsersLogMessages.UserUpdatingNotificationPublished(_logger, userId);
TransactionsLogMessages.TransactionScopeCommitting(_logger);
transactionScope.Complete();
UsersLogMessages.UserUpdated(_logger, userId);
return(OperationResult.Success);
}
public async Task TrackUserAsync(
ulong userId,
string username,
string discriminator,
string avatarHash,
CancellationToken cancellationToken)
{
UsersLogMessages.UserTracking(_logger, userId, username, discriminator, avatarHash);
using var transactionScope = _transactionScopeFactory.CreateScope();
TransactionsLogMessages.TransactionScopeCreated(_logger);
var now = _systemClock.UtcNow;
var mergeResult = await _usersRepository.MergeAsync(
userId,
username,
discriminator,
avatarHash,
firstSeen : now,
lastSeen : now,
cancellationToken);
if (mergeResult.RowsInserted > 0)
{
UsersLogMessages.UserCreated(_logger, userId);
var actionId = await _auditableActionsRepository.CreateAsync(
(int)UserManagementAdministrationActionType.UserCreated,
now,
userId,
cancellationToken);
AuditingLogMessages.AuditingActionCreated(_logger, actionId);
UsersLogMessages.DefaultPermissionIdsFetching(_logger);
var defaultPermissionIds = await _usersRepository
.AsyncEnumerateDefaultPermissionIds()
.ToArrayAsync(cancellationToken);
UsersLogMessages.DefaultPermissionIdsFetched(_logger, defaultPermissionIds);
if (defaultPermissionIds.Any())
{
UsersLogMessages.UserPermissionMappingsCreating(_logger, userId, defaultPermissionIds, PermissionMappingType.Granted);
var mappingIds = await _usersRepository.CreatePermissionMappingsAsync(
userId,
defaultPermissionIds,
PermissionMappingType.Granted,
actionId,
cancellationToken);
UsersLogMessages.UserPermissionMappingsCreated(_logger, userId, mappingIds);
}
UsersLogMessages.DefaultRoleIdsFetching(_logger);
var defaultRoleIds = await _usersRepository
.AsyncEnumerateDefaultRoleIds()
.ToArrayAsync(cancellationToken);
UsersLogMessages.DefaultRoleIdsFetched(_logger, defaultRoleIds);
if (defaultRoleIds.Any())
{
UsersLogMessages.UserRoleMappingsCreating(_logger, userId, defaultRoleIds);
var mappingIds = await _usersRepository.CreateRoleMappingsAsync(
userId,
defaultRoleIds,
actionId,
cancellationToken);
UsersLogMessages.UserRoleMappingsCreated(_logger, userId, mappingIds);
}
UsersLogMessages.UserInitializingNotificationPublishing(_logger, userId);
await _messenger.PublishNotificationAsync(
new UserInitializingNotification(
userId,
actionId),
cancellationToken);
UsersLogMessages.UserInitializingNotificationPublished(_logger, userId);
}
else
{
UsersLogMessages.UserUpdated(_logger, userId);
}
TransactionsLogMessages.TransactionScopeCommitting(_logger);
transactionScope.Complete();
UsersLogMessages.UserTracked(_logger, userId);
}