public Task <SearchAuthPoliciesResult> Search(SearchAuthPoliciesParameter parameter)
        {
            if (parameter == null)
            {
                throw new ArgumentNullException(nameof(parameter));
            }

            IEnumerable <Policy> result = _policies;

            if (parameter.Ids != null && parameter.Ids.Any())
            {
                result = result.Where(r => parameter.Ids.Contains(r.Id));
            }

            if (parameter.ResourceIds != null && parameter.ResourceIds.Any())
            {
                result = result.Where(p => p.ResourceSetIds.Any(r => parameter.ResourceIds.Contains(r)));
            }

            var nbResult = result.Count();

            result = result.OrderBy(c => c.Id);
            if (parameter.IsPagingEnabled)
            {
                result = result.Skip(parameter.StartIndex).Take(parameter.Count);
            }

            return(Task.FromResult(new SearchAuthPoliciesResult
            {
                Content = result.Select(r => r.Copy()),
                StartIndex = parameter.StartIndex,
                TotalResults = nbResult
            }));
        }
Esempio n. 2
0
        public Task <SearchAuthPoliciesResult> Execute(SearchAuthPoliciesParameter parameter)
        {
            if (parameter == null)
            {
                throw new ArgumentNullException(nameof(parameter));
            }

            return(_policyRepository.Search(parameter));
        }
        public async Task <SearchAuthPoliciesResult> Search(SearchAuthPoliciesParameter parameter)
        {
            if (parameter == null)
            {
                throw new ArgumentNullException(nameof(parameter));
            }

            IQueryable <Models.Policy> policies = _context.Policies
                                                  .Include(p => p.ResourceSetPolicies)
                                                  .Include(p => p.Scopes)
                                                  .Include(p => p.Claims)
                                                  .Include(p => p.Clients);

            if (parameter.Ids != null && parameter.Ids.Any())
            {
                policies = policies.Where(r => parameter.Ids.Contains(r.Id));
            }

            if (parameter.ResourceIds != null && parameter.ResourceIds.Any())
            {
                policies = policies.Where(p => p.ResourceSetPolicies.Any(r => parameter.ResourceIds.Contains(r.ResourceSetId)));
            }

            var nbResult = await policies.CountAsync().ConfigureAwait(false);

            policies = policies.OrderBy(c => c.Id);
            if (parameter.IsPagingEnabled)
            {
                policies = policies.Skip(parameter.StartIndex).Take(parameter.Count);
            }

            return(new SearchAuthPoliciesResult
            {
                Content = await policies.Select(c => c.ToDomain()).ToListAsync().ConfigureAwait(false),
                StartIndex = parameter.StartIndex,
                TotalResults = nbResult
            });
        }
Esempio n. 4
0
 public Task <SearchAuthPoliciesResult> Search(SearchAuthPoliciesParameter parameter)
 {
     return(_searchAuthPoliciesAction.Execute(parameter));
 }