Exemplo n.º 1
0
        public IHttpActionResult Search(ConsituentSearchViewModel vm)
        {
            var page     = vm.Page.GetValueOrDefault(0);
            var pageSize = vm.PageSize.GetValueOrDefault(10);
            var skipRows = (page - 1) * pageSize;

            var pred = PredicateBuilder.True <Constituent>();

            if (!string.IsNullOrWhiteSpace(vm.Name))
            {
                pred = pred.And(p => p.Name.Contains(vm.Name));
            }
            if (!string.IsNullOrWhiteSpace(vm.FinderNumber))
            {
                pred = pred.And(p => p.FinderNumber.Contains(vm.FinderNumber));
            }
            if (!string.IsNullOrWhiteSpace(vm.LookupId))
            {
                pred = pred.And(p => p.LookupId.Contains(vm.LookupId));
            }
            if (!string.IsNullOrWhiteSpace(vm.City))
            {
                pred = pred.And(p => p.State.StartsWith(vm.City));
            }
            if (!string.IsNullOrWhiteSpace(vm.State))
            {
                pred = pred.And(p => p.State.StartsWith(vm.State));
            }
            if (!string.IsNullOrWhiteSpace(vm.Zipcode))
            {
                pred = pred.And(p => p.Zipcode.StartsWith(vm.Zipcode));
            }
            if (!string.IsNullOrWhiteSpace(vm.Email))
            {
                pred = pred.And(p => p.Email.Contains(vm.Email));
            }
            if (!string.IsNullOrWhiteSpace(vm.Phone))
            {
                pred = pred.And(p => p.Phone.Contains(vm.Phone));
            }

            var list = context.Constituents.AsQueryable()
                       .Order(vm.OrderBy, vm.OrderDirection == "desc" ? SortDirection.Descending : SortDirection.Ascending)
                       .Where(pred)
                       .Include(x => x.TaxItems)
                       .Skip(skipRows)
                       .Take(pageSize)
                       .ProjectTo <ConstituentViewModel>();

            var totalCount  = context.Constituents.Count();
            var filterCount = context.Constituents.Where(pred).Count();
            var totalPages  = (int)Math.Ceiling((decimal)filterCount / pageSize);

            vm.TotalCount    = totalCount;
            vm.FilteredCount = filterCount;
            vm.TotalPages    = totalPages;

            vm.Items = list.ToList();
            return(Ok(vm));
        }
Exemplo n.º 2
0
        public async Task <object> Get([FromUri] ConsituentSearchViewModel pager)
        {
            try
            {
                var stopwatch = new Stopwatch();
                stopwatch.Restart();
                if (pager == null)
                {
                    pager = new ConsituentSearchViewModel();
                }

                var query      = _context.Constituents;
                var totalCount = await query.CountAsync();

                var pred = PredicateBuilder.True <Constituent>();
                if (!string.IsNullOrWhiteSpace(pager.Name))
                {
                    pred = pred.And(p => p.Name.Contains(pager.Name));
                }
                if (!string.IsNullOrWhiteSpace(pager.FinderNumber))
                {
                    pred = pred.And(p => p.FinderNumber.Contains(pager.FinderNumber));
                }
                if (!string.IsNullOrWhiteSpace(pager.LookupId))
                {
                    pred = pred.And(p => p.LookupId.Contains(pager.LookupId));
                }
                if (!string.IsNullOrWhiteSpace(pager.City))
                {
                    pred = pred.And(p => p.State.StartsWith(pager.City));
                }
                if (!string.IsNullOrWhiteSpace(pager.State))
                {
                    pred = pred.And(p => p.State.StartsWith(pager.State));
                }
                if (!string.IsNullOrWhiteSpace(pager.Zipcode))
                {
                    pred = pred.And(p => p.Zipcode.StartsWith(pager.Zipcode));
                }
                if (!string.IsNullOrWhiteSpace(pager.Email))
                {
                    pred = pred.And(p => p.Email.Contains(pager.Email));
                }
                if (!string.IsNullOrWhiteSpace(pager.Phone))
                {
                    pred = pred.And(p => p.Phone.Contains(pager.Phone));
                }

                var filteredQuery = query.Where(pred);
                var pagerCount    = filteredQuery.Count();
                var totalPages    = Math.Ceiling((double)pagerCount / pager.PageSize ?? PAGE_SIZE);

                var results = await filteredQuery.Where(pred)
                              .Order(pager.OrderBy, pager.OrderDirection == "desc" ? SortDirection.Descending : SortDirection.Ascending)
                              .Skip(pager.PageSize * (pager.Page - 1) ?? 0)
                              .Take(pager.PageSize ?? PAGE_SIZE)
                              .ProjectTo <ConstituentViewModel>().ToListAsync();

                pager.TotalCount    = totalCount;
                pager.FilteredCount = pagerCount;
                pager.TotalPages    = totalPages;
                pager.Results       = results;
                stopwatch.Stop();
                pager.ElapsedTime = stopwatch.Elapsed;
                return(Ok(pager));
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.InnerException.Message));
            }
        }