public async Task <object> Export([FromUri] DemographicSearchViewModel pager)
        {
            try
            {
                if (pager == null)
                {
                    pager = new DemographicSearchViewModel();
                }

                var query = _context.DemographicChanges;

                var pred = PredicateBuilder.True <DemographicChange>();
                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));
                }
                if (pager.Source != null)
                {
                    pred = pred.And(p => (int)p.Source == pager.Source);
                }

                var filteredQuery = query.Where(pred);

                var results = await filteredQuery.ProjectTo <DemographicViewModel>().ToListAsync();

                var path = HttpContext.Current.Server.MapPath(@"~\app_data\demographiclist.csv");

                using (var csv = new CsvWriter(new StreamWriter(File.Create(path))))
                {
                    csv.WriteHeader <DemographicChange>();
                    csv.WriteRecords(results);
                }
                var filename = $"demographic-changes-{DateTime.Now:u}.csv";

                var response = new HttpResponseMessage(HttpStatusCode.OK);
                var stream   = new FileStream(path, FileMode.Open, FileAccess.Read);
                response.Content = new StreamContent(stream);
                response.Content.Headers.ContentType        = new MediaTypeHeaderValue("application/octet-stream");
                response.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
                {
                    FileName = filename
                };
                response.Content.Headers.Add("x-filename", filename);

                return(ResponseMessage(response));
            }
            catch (Exception e)
            {
                return(BadRequest(e.Message));
            }
        }
        public async Task <object> Get([FromUri] DemographicSearchViewModel pager)
        {
            try
            {
                var stopwatch = new Stopwatch();
                stopwatch.Restart();
                if (pager == null)
                {
                    pager = new DemographicSearchViewModel();
                }

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

                var pred = PredicateBuilder.True <DemographicChange>();
                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));
                }
                if (pager.Source != null)
                {
                    pred = pred.And(p => (int)p.Source == pager.Source);
                }

                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 <DemographicViewModel>().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.Message));
            }
        }
Example #3
0
        public IHttpActionResult Search(DemographicSearchViewModel vm)
        {
            var page     = vm.Page.GetValueOrDefault(0);
            var pageSize = vm.PageSize.GetValueOrDefault(10);
            var skipRows = (page - 1) * pageSize;

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

            if (!string.IsNullOrWhiteSpace(vm.Name))
            {
                pred = pred.And(p => p.Name.Contains(vm.Name));
            }
            if (!string.IsNullOrWhiteSpace(vm.LookupId))
            {
                pred = pred.And(p => p.LookupId.Contains(vm.LookupId));
            }
            if (!string.IsNullOrWhiteSpace(vm.FinderNumber))
            {
                pred = pred.And(p => p.FinderNumber.StartsWith(vm.FinderNumber));
            }
            if (!string.IsNullOrWhiteSpace(vm.Street))
            {
                pred = pred.And(p => p.Street.StartsWith(vm.Street));
            }
            if (!string.IsNullOrWhiteSpace(vm.Street2))
            {
                pred = pred.And(p => p.Street2.StartsWith(vm.Street2));
            }
            if (!string.IsNullOrWhiteSpace(vm.City))
            {
                pred = pred.And(p => p.City.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.StartsWith(vm.Email));
            }
            if (!string.IsNullOrWhiteSpace(vm.Phone))
            {
                pred = pred.And(p => p.Phone.StartsWith(vm.Phone));
            }
            //if (!string.IsNullOrWhiteSpace(vm.Source)) pred = pred.And(p => p.Source.Equals(vm.Source));

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

            var totalCount  = context.DemographicChanges.Count();
            var filterCount = context.DemographicChanges.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));
        }