private TransactionList GetTransactions(DateTime startDate, 
                                                DateTime endDate, 
                                                string msisdn, 
                                                string gameTitle, 
                                                int portalId, 
                                                int? page)
        {
            if (page == null) page = 0;

            TransactionRepository transactionRepository = new TransactionRepository();
            var transactions = transactionRepository.GetTransactions(startDate,
                                                                     endDate,
                                                                     msisdn,
                                                                     gameTitle,
                                                                     portalId);

            var paginatedTransactions = new PaginatedList<Transaction>(transactions,
                                                                       (int)page,
                                                                       Settings.PageSize);

            // Khoa.Nguyen: Get GetInstallLastNotify in Store Procedure
            //foreach (Transaction trx in paginatedTransactions)
            //    trx.InstallStatus = transactionRepository.GetInstallLastNotify(trx.ID);

            var model = new TransactionList(paginatedTransactions,
                                            startDate,
                                            endDate,
                                            msisdn,
                                            gameTitle);
            model.PortalId = portalId;
            //return
            return model;
        }

        public ActionResult @New(int? page, string domainname, string ext, string sortingmode)
        {
            //sortingmode: new, contraversial, hot, etc
            ViewBag.SortingMode = sortingmode;

            if (!sortingmode.Equals("new")) return RedirectToAction("Index", "Home");
            ViewBag.SelectedSubverse = "domains";
            ViewBag.SelectedDomain = domainname + "." + ext;

            const int pageSize = 25;
            int pageNumber = (page ?? 0);

            if (pageNumber < 0)
            {
                return View("~/Views/Errors/Error_404.cshtml");
            }

            //check if at least one submission for given domain was found, if not, send to a page not found error
            //IQueryable<Message> submissions = _db.Messages
            //    .Where(x => x.Name != "deleted" & x.Type == 2 & x.MessageContent.ToLower().Contains(domainname + "." + ext))
            //    .OrderByDescending(s => s.Date);

            IQueryable<Message> submissions = (from m in _db.Messages
                                               join s in _db.Subverses on m.Subverse equals s.name
                                               where !s.admin_disabled.Value && !m.IsDeleted & m.Type == 2 & m.MessageContent.ToLower().Contains(domainname + "." + ext)
                                               orderby m.Date descending
                                               select m);

            var paginatedSubmissions = new PaginatedList<Message>(submissions, page ?? 0, pageSize);

            ViewBag.Title = "Showing all newest submissions which link to " + domainname;
            return View("Index", paginatedSubmissions);
        }

        // GET: Domains
        // GET: all submissions which link to given domain
        public ActionResult Index(int? page, string domainname, string ext, string sortingmode)
        {
            const int pageSize = 25;
            int pageNumber = (page ?? 0);

            if (pageNumber < 0)
            {
                return View("~/Views/Errors/Error_404.cshtml");
            }

            ViewBag.SelectedSubverse = "domains";
            ViewBag.SelectedDomain = domainname + "." + ext;

            // check if at least one submission for given domain was found, if not, send to a page not found error
            //IQueryable<Message> submissions = 
            //    _db.Messages
            //    .Where(
            //        x => x.Name != "deleted" & x.Type == 2 & x.MessageContent.ToLower().Contains(domainname + "." + ext))
            //    .OrderByDescending(s => s.Rank)
            //    .ThenByDescending(s => s.Date);

            //restrict disabled subs from result list
            IQueryable<Submission> submissions = (from m in _db.Submissions
                                                  join s in _db.Subverses on m.Subverse equals s.Name
                                               where !s.IsAdminDisabled.Value && !m.IsDeleted & m.Type == 2 & m.Content.ToLower().Contains(domainname + "." + ext)
                                               orderby m.Rank descending, m.CreationDate descending
                                               select m);

            var paginatedSubmissions = new PaginatedList<Submission>(submissions, page ?? 0, pageSize);

            ViewBag.Title = "Showing all submissions which link to " + domainname;
            return View("Index", paginatedSubmissions);
        }

 public List<AccountInformation> BankAccountInformationList(int pageIndex, int pageSize, string sortName, string sortOrder, ref int totalRows, int investorId)
 {
     using (DeepBlueEntities context = new DeepBlueEntities()) {
         IQueryable<AccountInformation> query = (from account in context.InvestorAccountsTable
                                                 where account.InvestorID == investorId
                                                 select new AccountInformation {
                                                     ABANumber = account.Routing,
                                                     AccountNumber = account.Account,
                                                     Attention = account.Attention,
                                                     AccountOf = account.AccountOf,
                                                     BankName = account.BankName,
                                                     ByOrderOf = account.ByOrderOf,
                                                     FFC = account.FFC,
                                                     FFCNumber = account.FFCNumber,
                                                     AccountId = account.InvestorAccountID,
                                                     IBAN = account.IBAN,
                                                     Reference = account.Reference,
                                                     Swift = account.SWIFT,
                                                     InvestorId = account.InvestorID
                                                 });
         query = query.OrderBy(sortName, (sortOrder == "asc"));
         PaginatedList<AccountInformation> paginatedList = new PaginatedList<AccountInformation>(query, pageIndex, pageSize);
         totalRows = paginatedList.TotalCount;
         return paginatedList;
     }
 }

        /// <summary>
        /// Get the certificate data with its documents paginated
        /// </summary>
        /// <param name="certificateId">Certificate id</param>
        /// <param name="searchHeader">Flag to know if it is required to get the certificate information or only the documents</param>
        public void GetCertificateDetail(int certificateId, bool searchHeader)
        {
            PaginatedList<Document> result = new PaginatedList<Document>();
            using (VocEntities db = new VocEntities())
            {
                //Get the certificate data detail
                if (searchHeader)
                {
                    Certificate =
                    (from certificate in db.Certificates.Include("EntryPoint")
                     where certificate.CertificateId == certificateId
                     select certificate).FirstOrDefault();
                }

                //Get the documents related to the certificate
                var querydocs = (from documents in db.Documents
                                 where documents.CertificateId == certificateId && documents.IsDeleted == false
                                 orderby documents.Certificate.IssuanceDate descending
                                 select documents);

                result.TotalCount = querydocs.Count();

                var supportDocument = querydocs.Where(doc => doc.DocumentType == DocumentTypeEnum.SupportingDocument).ToList();
                var releaseNotes = querydocs.Where(doc => doc.DocumentType == DocumentTypeEnum.ReleaseNote).ToList();
                supportDocument.AddRange(releaseNotes);

                var certificatDoc = querydocs.Where(doc => doc.DocumentType == DocumentTypeEnum.Certificate).FirstOrDefault();
                if (certificatDoc != null) supportDocument.Insert(0, certificatDoc);

                result.Collection = supportDocument;

                Documents = result;

            }
        }

        //
        // GET: /QuocGia/
        public ActionResult Index(int? page, string TuNgaySearch, string DenNgaySearch, string tenTaiKhoan)
        {
            int currentPageIndex = page.HasValue ? page.Value : 0;

            const int pageSize = 10;
            IFormatProvider provider = new System.Globalization.CultureInfo("en-CA", true);
            String datetime = TuNgaySearch;
            DateTime tn = new DateTime(1975, 1, 1);

            DateTime dn = DateTime.Now;
            if (TuNgaySearch != null && TuNgaySearch != "")
            {
                tn = DateTime.Parse(datetime, provider, System.Globalization.DateTimeStyles.NoCurrentDateDefault);
                //tnStr = tn.ToString("MM/dd/yyyy");
            }
            datetime = DenNgaySearch;
            if (DenNgaySearch != null && DenNgaySearch != "")
            {
                dn = DateTime.Parse(datetime, provider, System.Globalization.DateTimeStyles.NoCurrentDateDefault);
                //dnStr = dn.ToString("MM/dd/yyyy");
            }

            var objs = HistoryRes.FindAll(tenTaiKhoan, tn, dn);
            var paginatedAccounts = new PaginatedList<Histories>(objs, currentPageIndex, pageSize);

            return View(paginatedAccounts);
        }

        public ActionResult BookList(int? pageIndex)
        {
            IQueryable<Book> books = unitOfWork.BookRepository.Get(orderBy: q => q.OrderBy(d => d.BookId));

            var bookList = new PaginatedList<Book>(books, pageIndex ?? 0, PAGESIZE);
            return View("BookList", bookList);
        }

        public PaginatedList<Common.User> SearchUsers(string query, int pageNumber, int pageSize)
        {
            var finalQuery = (from u in this.context.Users
                         select u);

            if (!string.IsNullOrWhiteSpace(query))
            {
                finalQuery = (from u in finalQuery
                              where u.Username.Contains(query) ||
                              u.Email.Contains(query) ||
                              u.FirstName.Contains(query) ||
                              u.LastName.Contains(query)
                              orderby u.CreateDateUtc descending
                              select u);
            }
            else
            {
                finalQuery = (from u in finalQuery
                              orderby u.CreateDateUtc descending
                              select u);
            }

            // convert to business paginated list with entity framework
            var list1 = new PaginatedList<User>(finalQuery, pageNumber, pageSize);
            var move = (from m in list1 select m.ToBusinessUser()).AsQueryable();
            return new PaginatedList<Common.User>(move, pageNumber, pageSize, list1.TotalCount);
        }

 public CatalogueValueSearchModel()
 {
     CatalogueSelectedName = string.Empty;
     BusinessApplicatioName = string.Empty;
     CatalogueSelectedId = Guid.Empty;
     SearchResult = new PaginatedList<CatalogueValue>();
 }

        // GET: /Dinners/
        public ActionResult Index(int? page)
        {
            const int pageSize = 3;

            var upcomingDinners = dinnerRepository.FindUpcomingDinners();
            var paginatedDinners = new PaginatedList<Dinner>(upcomingDinners, page ?? 0, pageSize);
            return View("Index", paginatedDinners);
        }

 public SubscriptionList(PaginatedList<SubscriptionActivity> paginatedList, 
                         string msisdn, 
                         List<Subscriber> subscriber)
 {
     Msisdn = msisdn;
     PaginatedList = paginatedList;
     Subscriber = subscriber;
 }

        /// <summary>
        /// Gets all the topics from the parent category
        /// </summary>
        private void GetTopicsFromCategory()
        {
            // Before anything see if the category has been marked as private, if so make sure user is loggged in
            var currentCategory = Mapper.MapForumCategory(CurrentNode);
            var userHasAccess = true;
            if (MembershipHelper.IsAuthenticated())
            {
                // Member is logged in so it doesn't matter if forum is private or not,
                // now check they have enough karma to view this category and hide if not
                if (CurrentMember.MemberKarmaAmount < currentCategory.KarmaAccessAmount)
                {
                    userHasAccess = false;
                }
            }
            else
            {
                if (currentCategory.IsPrivate)
                {
                    userHasAccess = false;
                }
            }

            // Check to see if user has access
            if(!userHasAccess)
            {
                Response.Redirect(string.Concat(Settings.Url, "?m=", library.GetDictionaryItem("NoPermissionToViewPage")));
            }

            // Get the paging variable
            int? p = null;
            if (Request.QueryString["p"] != null)
                p = Convert.ToInt32(Request.QueryString["p"]);

            // Set cache variables
            var useNodeFactory = Request.QueryString["nf"] != null;
            var maintopics = from t in Factory.ReturnAllTopicsInCategory(CurrentNode.Id, true, useNodeFactory)
                             where !t.IsSticky
                             select t;

            if(!ShowAll)
            {
                maintopics = maintopics.Take(2);
                btnShowAll.Visible = true;
            }

            // Pass to my pager helper
            var pagedResults = new PaginatedList<ForumTopic>(maintopics, p ?? 0, Convert.ToInt32(Settings.TopicsPerPage));

            // Decide whether to show pager or not
            if (pagedResults.TotalPages > 1)
            {
                litPager.Text = pagedResults.ReturnPager();
            }

            // Now bind
            rptTopicList.DataSource = pagedResults;
            rptTopicList.DataBind();
        }

        public ViewResult FindAll(int? page)
        {
            const int howManyRowsPerPage = 8;

            var petsSubset = _petRepository.FindAll().AsQueryable();
            var paginatedPets = new PaginatedList<Pet>(petsSubset, page ?? 0, howManyRowsPerPage);

            return View(paginatedPets);
        }

        public ActionResult UserSubmissions(string id, int? page, string whattodisplay)
        {
                var userSubmissions = from b in _db.Submissions.OrderByDescending(s => s.CreationDate)
                                      where (b.UserName.Equals(id) && b.IsAnonymized == false) && (b.UserName.Equals(id) && b.Subverse1.IsAnonymized == false)
                                      select b;

                PaginatedList<Submission> paginatedUserSubmissions = new PaginatedList<Submission>(userSubmissions, page ?? 0, pageSize);

                return View("~/Views/Home/UserSubmitted.cshtml", paginatedUserSubmissions);
        }

        public ActionResult UserComments(string id, int? page, string whattodisplay)
        {
                var userComments = from c in _db.Comments.OrderByDescending(c => c.CreationDate)
                                   where (c.UserName.Equals(id) && c.Submission.IsAnonymized == false) && (c.UserName.Equals(id) && c.Submission.Subverse1.IsAnonymized == false)
                                   select c;

                PaginatedList<Comment> paginatedUserComments = new PaginatedList<Comment>(userComments, page ?? 0, pageSize);

                return View("~/Views/Home/UserComments.cshtml", paginatedUserComments);
        }

        public PaginatedList<BlogPreview> GetPagedBlogPreviews(int page = 1, int pageSize = 5)
        {
            PaginatedList<BlogPreview> previews = new PaginatedList<BlogPreview>();
            var blogItems = this._contentService.GetContentOfContentType(_blogContentType.Id).ToList();
            previews.TotalItems = blogItems.Count();
            previews.Items = this.GetBlogPreviews(page - 1, pageSize).ToList();
            previews.ItemsPerPage = pageSize;
            previews.CurrentPage = page;

            return previews;
        }

        public async Task<ActionResult> List(int? page)
        {
            await MenuManager.InitAsync(RouteName.News);

            var model = new PaginatedList<Article>(page ?? 0, 5);
            var source = Repository.Articles
                .Where(x => x.Type != ArticleType.History)
                .OrderByDescending(x => x.Created);
            await model.SetSourceAsync(source);
            return View(model);
        }

        public ActionResult Index(int page = 0)
        {
            var posty = from posts in blogDB.Post
                        where posts.status==0
                        orderby posts.data_dodania descending
                        select posts;

            var strPosty = new PaginatedList<Post>(posty, page, pageSize);

            return View(strPosty);
        }

        public PaginatedList<Common.ReportedListing> GetReported(int pageNumber, int pageSize)
        {
            var query = (from u in this.context.Buildings
                         where u.IsReported && !u.IsRemovedByAdmin && !u.IsDeleted && u.IsActive
                         orderby u.CreateDateUtc
                         select u);

            // convert to business paginated list with entity framework
            var list1 = new PaginatedList<Building>(query, pageNumber, pageSize);
            var move = (from m in list1 select m.ToReportedListing()).AsQueryable();
            return new PaginatedList<Common.ReportedListing>(move, pageNumber, pageSize, list1.TotalCount);
        }

 public TransactionList(PaginatedList<Transaction> paginatedList, 
                        DateTime startDate, 
                        DateTime endDate, 
                        string msisdn, 
                        string gameTitle)
 {
     StartDate = startDate;
     EndDate = endDate;
     Msisdn = msisdn;
     GameTitle = gameTitle;
     PaginatedList = paginatedList;
 }