示例#1
0
        public Task <SearchClaimsResult> Execute(SearchClaimsParameter parameter)
        {
            if (parameter == null)
            {
                throw new ArgumentNullException(nameof(parameter));
            }

            return(_claimRepository.Search(parameter));
        }
        public Task <SearchClaimsResult> Search(SearchClaimsParameter parameter)
        {
            if (parameter == null)
            {
                throw new ArgumentNullException(nameof(parameter));
            }

            IEnumerable <ClaimAggregate> result = _claims;

            if (parameter.ClaimKeys != null)
            {
                result = result.Where(c => parameter.ClaimKeys.Any(ck => c.Code.Contains(ck)));
            }

            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 SearchClaimsResult
            {
                Content = result.Select(c => c.Copy()),
                StartIndex = parameter.StartIndex,
                TotalResults = nbResult
            }));
        }
        public async Task <SearchClaimsResult> Search(SearchClaimsParameter parameter)
        {
            if (parameter == null)
            {
                throw new ArgumentNullException(nameof(parameter));
            }

            IQueryable <Models.Claim> claims = _context.Claims;

            if (parameter.ClaimKeys != null)
            {
                claims = claims.Where(c => parameter.ClaimKeys.Any(ck => c.Code.Contains(ck)));
            }

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

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

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

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

            return(new SearchClaimsResult
            {
                Content = await claims.Select(c => c.ToDomain()).ToListAsync().ConfigureAwait(false),
                StartIndex = parameter.StartIndex,
                TotalResults = nbResult
            });
        }
示例#4
0
 public Task <SearchClaimsResult> Search(SearchClaimsParameter parameter)
 {
     return(_searchClaimsAction.Execute(parameter));
 }