public Task <SearchResourceOwnerResult> Execute(SearchResourceOwnerParameter parameter)
        {
            if (parameter == null)
            {
                throw new ArgumentNullException(nameof(parameter));
            }

            return(_resourceOwnerRepository.Search(parameter));
        }
        public Task <SearchResourceOwnerResult> Search(SearchResourceOwnerParameter parameter)
        {
            if (parameter == null)
            {
                throw new ArgumentNullException(nameof(parameter));
            }

            IEnumerable <ResourceOwner> result = _users;

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

            var nbResult = result.Count();

            if (parameter.Order != null)
            {
                switch (parameter.Order.Target)
                {
                case "update_datetime":
                    switch (parameter.Order.Type)
                    {
                    case OrderTypes.Asc:
                        result = result.OrderBy(c => c.UpdateDateTime);
                        break;

                    case OrderTypes.Desc:
                        result = result.OrderByDescending(c => c.UpdateDateTime);
                        break;
                    }
                    break;
                }
            }
            else
            {
                result = result.OrderByDescending(c => c.UpdateDateTime);
            }

            if (parameter.IsPagingEnabled)
            {
                result = result.Skip(parameter.StartIndex).Take(parameter.Count);
            }

            return(Task.FromResult(new SearchResourceOwnerResult
            {
                Content = result.Select(u => u.Copy()),
                StartIndex = parameter.StartIndex,
                TotalResults = nbResult
            }));
        }
Example #3
0
        public async Task <SearchResourceOwnerResult> Search(SearchResourceOwnerParameter parameter)
        {
            if (parameter == null)
            {
                throw new ArgumentNullException(nameof(parameter));
            }

            try
            {
                var claimIdentifier = await _context.Claims.FirstOrDefaultAsync(c => c.IsIdentifier).ConfigureAwait(false);

                if (claimIdentifier == null)
                {
                    throw new InvalidOperationException("no claim can be used to uniquely identified the resource owner");
                }

                IQueryable <Models.ResourceOwner> result = _context.ResourceOwners
                                                           .Include(r => r.Claims);

                if (parameter.Subjects != null)
                {
                    result = result.Where(r => r.Claims.Any(c => c.ClaimCode == claimIdentifier.Code && parameter.Subjects.Contains(c.Value)));
                }

                if (result == null)
                {
                    return(null);
                }

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

                if (parameter.IsPagingEnabled)
                {
                    result = result.Skip(parameter.StartIndex).Take(parameter.Count);
                }

                return(new SearchResourceOwnerResult
                {
                    Content = result.Select(r => r.ToDomain()),
                    StartIndex = parameter.StartIndex,
                    TotalResults = nbResult
                });
            }
            catch (Exception ex)
            {
                _managerEventSource.Failure(ex);
                return(null);
            }
        }
 public Task<SearchResourceOwnerResult> Search(SearchResourceOwnerParameter parameter)
 {
     return _searchResourceOwnersAction.Execute(parameter);
 }