public async Task<IEnumerable<IQuestion>> GetRangeAsync(Guid fieldId, GenericFilter filter)
        {
            try
            {
                if (filter != null)
                {
                    //Get all questions from a field with matching id
                    //var questions = AutoMapper.Mapper.Map<IEnumerable<IQuestion>>(await Repository.GetAsync<QuestionEntity>(q => q.Field.Id.Equals(fieldId)));
                    var questions = AutoMapper.Mapper.Map<IEnumerable<IQuestion>>(await Repository.GetWhere<QuestionEntity>().Where(q => q.FieldId.Equals(fieldId)).ToListAsync());

                    if (!string.IsNullOrWhiteSpace(filter.SearchString))
                    {
                        questions = questions.Where(q => q.Title.ToLower().Contains(filter.SearchString.ToLower())).ToList();
                    }

                    var page = questions.ToPagedList(filter.PageNumber, filter.PageSize);
                    var questionPagedList = new StaticPagedList<IQuestion>(page, page.GetMetaData());
                    return questionPagedList;
                }
                else
                {
                    //If filter is null, return all questions from field
                    return AutoMapper.Mapper.Map<IEnumerable<IQuestion>>(await Repository.GetAsync<QuestionEntity>(q => q.Field.Id.Equals(fieldId))).ToList();
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// Get all lost person from red cross
        /// </summary>
        /// <param name="redCrossId"></param>
        /// <returns></returns>
        public async Task<IEnumerable<ILostPerson>> GetAllAsync(Guid redCrossId, GenericFilter filter)
        {
            try
            {
                if (filter != null)
                {
                    var lp = AutoMapper.Mapper.Map<IEnumerable<ILostPerson>>(await Repository.GetEverything<LostPersonEntity>()).OrderBy(l => l.LastName).ToList();

                    if (redCrossId != null)
                    {
                        lp = lp.Where(l => l.RedCrossId.Equals(redCrossId)).ToList();
                    }

                    var page = lp.ToPagedList(filter.pageNumber, filter.pageSize);
                    var lpPage = new StaticPagedList<ILostPerson>(page, page.GetMetaData());
                    return lpPage;
                }
                else
                {
                    return AutoMapper.Mapper.Map<IEnumerable<ILostPerson>>(await Repository.GetAllAsync<LostPersonEntity>(l => l.RedCrossId.Equals(redCrossId))).OrderBy(l => l.ReportDate).ToList();
                }

                //return AutoMapper.Mapper.Map<IEnumerable<ILostPerson>>(await Repository.GetAllAsync<LostPersonEntity>(l => l.RedCrossEntityId.Equals(redCrossId))).OrderBy(l => l.LastName); //Destination ILostPerson; Source: LostPersonEntity
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// Get all
        /// </summary>
        /// <returns></returns>
        public async Task<IEnumerable<IRedCross>> GetAsync(GenericFilter filter)
        {
            
            try
            {
                if (filter != null)
                {
                    var rc = AutoMapper.Mapper.Map<IEnumerable<IRedCross>>(await Repository.GetEverything<RedCrossEntity>()).OrderBy(r => r.Name).ToList();

                    if (!string.IsNullOrWhiteSpace(filter.searchString))
                    {
                        rc = rc.Where(r =>
                            r.Name.ToLower().Contains(filter.searchString.ToLower()) ||
                            r.Country.ToLower().Contains(filter.searchString.ToLower())
                        ).ToList();
                    }

                    var page = rc.ToPagedList(filter.pageNumber, filter.pageSize);
                    var rcPage = new StaticPagedList<IRedCross>(page, page.GetMetaData());
                    return rcPage;
                }
                else
                {
                    return AutoMapper.Mapper.Map<IEnumerable<IRedCross>>(await Repository.GetEverything<RedCrossEntity>()).OrderBy(r => r.Name).ToList();
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

 public ActionResult Index(int page = 1,int State=3)
 {
     List<Demand> demands = new List<Demand>();
     List<vDemand> vdemands = new List<vDemand>();
     string whereStr = "";
     if(State==0||State==1||State==2)
     {
         whereStr = "State="+ State;
     }
     var query = bllSession.IDemandBLL.GetList(whereStr);
     int state_num_1 = bllSession.IDemandBLL.GetList("State=0").Count();
     int state_num_2 = bllSession.IDemandBLL.GetList("State=1").Count();
     int state_num_3 = bllSession.IDemandBLL.GetList("State=2").Count();
     int totalCount = 0;
     PagerHelper.DoPage(ref query, page, 20, ref totalCount);
     foreach (var item in query)
     {
         vdemands.Add(new vDemand(item));
     }
     ViewBag.StateNum = state_num_1 + state_num_2 + state_num_3;
     ViewBag.StateNum1 = state_num_1;
     ViewBag.StateNum2 = state_num_2;
     ViewBag.StateNum3 = state_num_3;
     var demandAsIPagedList = new StaticPagedList<vDemand>(vdemands, page, 20, totalCount);
     return View(demandAsIPagedList);
 }

        // GET: Blog
        public ActionResult Index(int page = 1, string Category = "", string Date = "")
        {
            bool result = false;
            string attachUrl = "";
            List<vArticle> articles = new List<vArticle>();
            string whereStr = "";
            if (!string.IsNullOrEmpty(Category))
            {
                attachUrl = "Category = " + Category;
                whereStr = whereStr + "Category = '" + Category + "'";
            }
            if (!string.IsNullOrEmpty(Date))
            {
                attachUrl = "Date = " + Date;
                whereStr = whereStr + " DATE_FORMAT(a.Time,'%Y-%m') = '" + Date + "'";
            }
            var query = bllSession.IArticleBLL.GetList(whereStr);
            int totalCount = 0;
            PagerHelper.DoPage(ref query, page, 5, ref totalCount);
            foreach (var item in query.ToTextFilter(out result))
            {
                articles.Add(new vArticle(item));
            }
            var articleAsIPagedList = new StaticPagedList<vArticle>(articles, page, 5, totalCount);//.ToTextFilter(out result);

            object Categories = CacheHelper.GetCacheValue("ArticleCategories");
            object Calendars = CacheHelper.GetCacheValue("ArticleCalendars");

            ViewBag.Categories = Categories;
            ViewBag.Calendars = Calendars;
            ViewBag.AttachUrl = attachUrl;
            return View(articleAsIPagedList);
        }

		public PagedSortedList<DeployCredentialsMasked> GetMaskedCredentialList(ListOptions listOptions)
		{
			var list = _credentialsRepository.GetCredentialsList(listOptions);
			var mappedList = list.Items.Select(i=>AutoMapper.Mapper.Map(i, new DeployCredentialsMasked())).ToList();
			var pagedList = new StaticPagedList<DeployCredentialsMasked>(mappedList, list.PageNumber, list.PageSize, list.TotalItemCount);
			return new PagedSortedList<DeployCredentialsMasked>(pagedList, list.SortField, list.SortAscending);
		}

		public PagedSortedList<DeployBatchStatus> GetDeployBatchStatusList(ListOptions listOptions)
		{
            var requestList = _deployRepository.GetBatchRequestList(listOptions);
            var returnListItems = requestList.Items.Select(i => BuildDeployBatchStatus(i)).ToList();
            var pagedList = new StaticPagedList<DeployBatchStatus>(returnListItems, requestList.PageNumber, requestList.PageSize, requestList.TotalItemCount);
            return new PagedSortedList<DeployBatchStatus>(pagedList, listOptions.SortField, listOptions.SortAscending.Value);
		}

        public async Task<IEnumerable<IAnswer>> GetAsync(GenericFilter filter)
        {
            try
            {
                if (filter != null)
                {
                    var answers = AutoMapper.Mapper.Map<IEnumerable<IAnswer>>(await Repository.GetRangeAsync<AnswerEntity>()).ToList();

                    if (!string.IsNullOrWhiteSpace(filter.SearchString))
                    {
                        answers = answers.Where(a => a.Date.ToShortDateString().Contains(filter.SearchString)).ToList();
                    }

                    var page = answers.ToPagedList(filter.PageNumber, filter.PageSize);
                    var answerPagedList = new StaticPagedList<IAnswer>(page, page.GetMetaData());
                    return answerPagedList;
                }
                else
                {
                    return AutoMapper.Mapper.Map<IEnumerable<IAnswer>>(await Repository.GetRangeAsync<AnswerEntity>()).ToList();
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public ActionResult Index(string sortOrder, string currentFilter, string search, int page = 1)
        {
            ViewBag.CurrentSort = sortOrder;
            ViewBag.IDSortParm = "id_asc";
            ViewBag.DescripcionSortParm = String.IsNullOrEmpty(sortOrder) ? "descripcion_asc" : "";
            ViewBag.CantSensoresSortParm = String.IsNullOrEmpty(sortOrder) ? "cantsensores_asc" : "";

            if (Session["user"] == null)
                return RedirectToAction("Login", "Account");

            if (search != null)
                page = 1;
            else
                search = currentFilter;

            ViewBag.CurrentFilter = search;

            // Setup base query - not evaluated
            IQueryable<EquipoTipo> equipos = servicio.ObtenerTodos();

            if (!String.IsNullOrEmpty(search))
            {
                equipos = equipos.Where(s => s.descripcion.Contains(search));
            }

            switch (sortOrder)
            {
                case "id_asc":
                    equipos = equipos.OrderBy(s => s.idEquipoTipo);
                    break;
                case "descripcion_asc":
                    equipos = equipos.OrderBy(s => s.descripcion);
                    break;
                case "cantsensores_asc":
                    equipos = equipos.OrderBy(s => s.cantSensores);
                    break;
                default:
                    equipos = equipos.OrderBy(s => s.idEquipoTipo);
                    break;
            }

            var pageSize = 20;

            // Count of all matching records (hits database, but count is relatively quick)
            var equiposCount = equipos.Count();
            // List of current page of 20 records (hits database again, pulls only 20 records, though)
            var equiposList = equipos.Skip((page - 1) * pageSize).Take(pageSize).ToList();

            // Map just the 20 records to view models
            var viewModelEquipoTipos = Mapper.Map<IEnumerable<EquipoTipo>, IEnumerable<EquipoTipoViewModel>>(equiposList);

            // Create StaticPagedList instance to page with
            var model = new StaticPagedList<EquipoTipoViewModel>(viewModelEquipoTipos, page, pageSize, equiposCount);

            return View(model); 
        }

        public void UserController_Index_ShouldReturnTheResultOfServiceCallAsViewData()
        {
            var users = new StaticPagedList<User>(new List<User>(), 1, 1, 0);
            var userSearchQuery = new UserSearchQuery();
            A.CallTo(() => _userSearchService.GetUsersPaged(userSearchQuery)).Returns(users);

            ActionResult actionResult = _userController.Index(userSearchQuery);

            _userController.ViewData["users"].Should().Be(users);
        }

        public ActionResult Index(int? page)
        {
            int pageIndex = (page ?? 1) - 1;
            int pagesize=10;
            var result = _F41010Manager.GetData(pageIndex, pagesize);
            var ItemAsIPagedList = new StaticPagedList<F41010Model>(result, pageIndex+1, pagesize, int.Parse(_F41010Manager.GetDataCount().ToString()));

            ViewBag.onePageList = ItemAsIPagedList;

            return View(result);
        }

        public IPagedList<MembershipUser> FindByEmail(string emailAddressToMatch, int pageNumber, int pageSize)
		{
			// get one page of users
			int totalUserCount;
            var usersCollection = _membershipProvider.FindUsersByEmail(emailAddressToMatch, pageNumber - 1, pageSize, out totalUserCount);

			// convert from MembershipUserColletion to PagedList<MembershipUser> and return
			var converter = new EnumerableToEnumerableTConverter<MembershipUserCollection, MembershipUser>();
			var usersList = converter.ConvertTo<IEnumerable<MembershipUser>>(usersCollection);
            var usersPagedList = new StaticPagedList<MembershipUser>(usersList, pageNumber, pageSize, totalUserCount);
			return usersPagedList;
		}

        public ArtistIndex(PartialFindResult<ArtistWithAdditionalNamesContract> result, string filter,
            ArtistType artistType, bool? draftsOnly, ArtistSortRule sort, int? page, IndexRouteParams routeParams)
        {
            Artists = new StaticPagedList<ArtistWithAdditionalNamesContract>(result.Items, page ?? 1, 30, result.TotalCount);
            DraftsOnly = draftsOnly ?? false;
            Filter = filter;
            ArtistType = artistType;
            Sort = sort;
            RouteParams = routeParams;

            FilterableArtistTypes = EnumVal<ArtistType>.Values.ToDictionary(a => a, Translate.ArtistTypeName);
        }

        public IPagedList<MembershipUser> FindAll(int pageIndex, int pageSize)
        {
            // get one page of users
            int totalUserCount;
            var usersCollection = _membershipProvider.GetAllUsers(pageIndex, pageSize, out totalUserCount);

            // convert from MembershipUserColletion to PagedList<MembershipUser> and return
            var converter = new EnumerableToEnumerableTConverter<MembershipUserCollection, MembershipUser>();
            var usersList = converter.ConvertTo<IEnumerable<MembershipUser>>(usersCollection);
            var usersPagedList = new StaticPagedList<MembershipUser>(usersList, pageIndex, pageSize, totalUserCount);
            return usersPagedList;
        }

		public void StaticPagedList_uses_supplied_totalItemCount_to_determine_subsets_position_within_superset(int pageNumber, bool shouldBeFirstPage, bool shouldBeLastPage)
		{
			//arrange
			var subset = new[] {1, 1, 1};

			//act
			var list = new StaticPagedList<int>(subset, pageNumber, 3, 9);

			//assert
			Assert.Equal(pageNumber, list.PageNumber);
			Assert.Equal(shouldBeFirstPage, list.IsFirstPage);
			Assert.Equal(shouldBeLastPage, list.IsLastPage);
		}

 public Index(PartialFindResult<AlbumContract> result, string filter, DiscType discType, 
     AlbumSortRule sortRule, EntryViewMode view, int? page, bool? draftsOnly, IndexRouteParams routeParams)
 {
     Page = page ?? 1;
     Albums = new StaticPagedList<AlbumContract>(result.Items,
         Page, 30, result.TotalCount);
     DiscType = discType;
     DraftsOnly = draftsOnly ?? false;
     Filter = filter;
     Sort = sortRule;
     View = view;
     RouteParams = routeParams;
 }

        public ViewResult IndexPaged(int? page, string searchString)
        {
            int pageSize = 50;
            int pageNumber = (page ?? 1);

            ViewBag.SearchTerm = searchString;

            int totalRows = 0;
            var students = unitOfWork.StudentRepo.GetStudentByPage(pageNumber, pageSize, out totalRows, searchString);

            IPagedList<Student> pStud = new StaticPagedList<Student>(students, pageNumber, pageSize, totalRows);
            return View(pStud);
        }

		public ActionResult Index(int? page)
		{
			Mapper.CreateMap<Order, OrderViewModel>(); // create mapping between Order and OrderViewModel
			const int pageSize = 2;

			var orders = GetAllOrdersFromDatabase();
			var pagedOrders = orders.ToPagedList(page ?? 1, pageSize);

			var viewmodel = Mapper.Map<IEnumerable<Order>, IEnumerable<OrderViewModel>>(pagedOrders.ToArray()); // convert all the Orders in the paged list into viewmodels
			var pagedViewmodel = new StaticPagedList<OrderViewModel>(viewmodel, pagedOrders.GetMetaData()); // reconsitute a new IPagedList containing the viewmodels

			return View(pagedViewmodel);
		}

     //   [ResourceAuthorize("Read", "ExpenseGroup")]
        public async Task<ActionResult> Index(int? page = 1)
        {
         
            var client = ExpenseTrackerHttpClient.GetClient();

            var model = new ExpenseGroupsViewModel();

            HttpResponseMessage egsResponse = await client.GetAsync("api/expensegroupstatusses");
           
            if (egsResponse.IsSuccessStatusCode)
            {
                string egsContent = await egsResponse.Content.ReadAsStringAsync();
                var lstExpenseGroupStatusses = JsonConvert.DeserializeObject<IEnumerable<ExpenseGroupStatus>>(egsContent);
                model.ExpenseGroupStatusses = lstExpenseGroupStatusses;
            }
            else
            {
                return Content("An error occurred.");
            }

            string userId = (this.User.Identity as ClaimsIdentity).FindFirst("unique_user_key").Value;

            HttpResponseMessage response = await client.GetAsync("api/expensegroups?sort=expensegroupstatusid"
                + ",title&page=" + page + "&pagesize=5&userid=" + userId);


            if (response.IsSuccessStatusCode)
            {
                string content = await response.Content.ReadAsStringAsync();

                // get the paging info from the header
                var pagingInfo = HeaderParser.FindAndParsePagingInfo(response.Headers);

                var lstExpenseGroups = JsonConvert.DeserializeObject<IEnumerable<ExpenseGroup>>(content);

                var pagedExpenseGroupsList = new StaticPagedList<ExpenseGroup>(lstExpenseGroups, pagingInfo.CurrentPage, 
                    pagingInfo.PageSize, pagingInfo.TotalCount);
                
                model.ExpenseGroups = pagedExpenseGroupsList;
                model.PagingInfo = pagingInfo;
            }
            else
            {
                return Content("An error occurred.");
            }


            return View(model);

        }

        public ActionResult Index(int? page)
        {
            int pageIndex = (page ?? 1) - 1;
            int pagesize=10;
            var resultModel = _salesManager.getAllSalesInfo(pageIndex, pagesize);

            //var resultModel = _salesManager.getSalesInfoByFilter("SO","2011040001");
            var SaleInfoAsIPagedList = new StaticPagedList<SalesDetailInfoModel>(resultModel, pageIndex + 1, pagesize, int.Parse(_salesManager.getSalesinfoCount().ToString()));

            ViewBag.onePageList = SaleInfoAsIPagedList;
            ViewBag.recCount = SaleInfoAsIPagedList.TotalItemCount;

            return View(resultModel);
        }