Пример #1
0
        public IAsyncEnumerable <RolePermissionMappingIdentityViewModel> AsyncEnumeratePermissionMappingIdentities(
            long roleId,
            Optional <bool> isDeleted = default)
        {
            RolesLogMessages.RolePermissionMappingIdentitiesEnumerating(_logger, roleId, isDeleted);

            var query = _context.Set <RolePermissionMappingEntity>()
                        .AsQueryable()
                        .Where(x => x.RoleId == roleId);

            RepositoryLogMessages.QueryInitializing(_logger, query);

            if (isDeleted.IsSpecified)
            {
                RepositoryLogMessages.QueryAddingWhereClause(_logger, nameof(isDeleted));
                query = isDeleted.Value
                    ? query.Where(x => x.DeletionId != null)
                    : query.Where(x => x.DeletionId == null);
            }

            RepositoryLogMessages.QueryTerminating(_logger);
            var result = query
                         .Select(RolePermissionMappingIdentityViewModel.FromEntityProjection)
                         .AsAsyncEnumerable();

            RepositoryLogMessages.QueryBuilt(_logger);
            return(result);
        }
Пример #2
0
        public async Task <long> CreateAsync(
            string name,
            long actionId,
            CancellationToken cancellationToken)
        {
            RolesLogMessages.RoleCreating(_logger, name, actionId);

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

            var role = new RoleEntity(
                id: default);
Пример #3
0
        public Task <bool> AnyVersionsAsync(
            Optional <IEnumerable <long> > excludedRoleIds = default,
            Optional <string> name              = default,
            Optional <bool> isDeleted           = default,
            Optional <bool> isLatestVersion     = default,
            CancellationToken cancellationToken = default)
        {
            RolesLogMessages.RoleVersionsEnumeratingAny(_logger, excludedRoleIds, name, isDeleted, isLatestVersion);

            var query = _context.Set <RoleVersionEntity>()
                        .AsQueryable();

            RepositoryLogMessages.QueryInitializing(_logger, query);

            if (excludedRoleIds.IsSpecified)
            {
                RepositoryLogMessages.QueryAddingWhereClause(_logger, nameof(excludedRoleIds));
                query = query.Where(x => !excludedRoleIds.Value.Contains(x.RoleId));
            }

            if (name.IsSpecified)
            {
                RepositoryLogMessages.QueryAddingWhereClause(_logger, nameof(name));
                query = query.Where(x => x.Name == name.Value);
            }

            if (isDeleted.IsSpecified)
            {
                RepositoryLogMessages.QueryAddingWhereClause(_logger, nameof(isDeleted));
                query = query.Where(x => x.IsDeleted == isDeleted.Value);
            }

            if (isLatestVersion.IsSpecified)
            {
                RepositoryLogMessages.QueryAddingWhereClause(_logger, nameof(isLatestVersion));
                query = isLatestVersion.Value
                    ? query.Where(x => x.NextVersionId == null)
                    : query.Where(x => x.NextVersionId != null);
            }

            RepositoryLogMessages.QueryTerminating(_logger);
            var result = query.AnyAsync(cancellationToken);

            RepositoryLogMessages.QueryExecuting(_logger);
            return(result);
        }