public async Task <OperationResult <long> > CreateAsync(
            CharacterGuildCreationModel creationModel,
            CancellationToken cancellationToken)
        {
            using var logScope = OperationLogMessages.BeginOperationScope(_logger, this);
            OperationLogMessages.OperationPerforming(_logger);

            OperationLogMessages.OperationAuthorizing(_logger);
            var authResult = await _authorizationService.RequirePermissionsAsync(
                new[] { (int)CharacterAdministrationPermission.ManageGuilds },
                cancellationToken);

            if (authResult.IsFailure)
            {
                OperationLogMessages.OperationNotAuthorized(_logger);
                return(authResult.Error);
            }
            OperationLogMessages.OperationAuthorized(_logger);

            var performedById = _authenticationService.CurrentTicket !.UserId;

            var result = await _characterGuildsService.CreateAsync(creationModel, performedById, cancellationToken);

            OperationLogMessages.OperationPerformed(_logger, result);

            return(result);
        }
Exemplo n.º 2
0
 public static void CharacterGuildCreating(
     ILogger logger,
     CharacterGuildCreationModel creationModel,
     ulong performedById)
 => _characterGuildCreating.Invoke(
     logger,
     creationModel,
     performedById);
        public async Task <OperationResult <long> > CreateAsync(
            CharacterGuildCreationModel creationModel,
            ulong performedById,
            CancellationToken cancellationToken)
        {
            CharactersLogMessages.CharacterGuildCreating(_logger, creationModel, performedById);

            using var transactionScope = _transactionScopeFactory.CreateScope();
            TransactionsLogMessages.TransactionScopeCreated(_logger);

            var nameValidationResult = await ValidateNameAsync(creationModel.Name, null, cancellationToken);

            if (nameValidationResult.IsFailure)
            {
                CharactersLogMessages.CharacterGuildNameValidationFailed(_logger, creationModel.Name, nameValidationResult);
                return(nameValidationResult.Error);
            }
            CharactersLogMessages.CharacterGuildNameValidationSucceeded(_logger, creationModel.Name);

            var actionId = await _auditableActionsRepository.CreateAsync(
                (int)CharacterManagementAdministrationActionType.GuildCreated,
                _systemClock.UtcNow,
                performedById,
                cancellationToken);

            AuditingLogMessages.AuditingActionCreated(_logger, actionId);

            var guildId = await _characterGuildsRepository.CreateAsync(
                creationModel.Name,
                actionId,
                cancellationToken);

            CharactersLogMessages.CharacterGuildCreated(_logger, guildId);

            transactionScope.Complete();
            TransactionsLogMessages.TransactionScopeCommitted(_logger);

            return(guildId.ToSuccess());
        }