public virtual ActionResult List(GridSortOptions gridSortOptions, int? page = null, int? itemsPerPage = null, string search = null)
        {
            if (gridSortOptions.Column == null)
            {
                gridSortOptions.Column = "Id";
            }

            var entitiesperPage = !itemsPerPage.HasValue ? PagedEntityListFilterDto.DefaultItemsPerPage : itemsPerPage.Value;
            var currentPage = !page.HasValue? 1 : page.Value;

            var userFilter = new PagedEntityListFilterDto
            {
                AscendingOrder = gridSortOptions.Direction == SortDirection.Ascending,
                Column = gridSortOptions.Column,
                StartPage = currentPage,
                ItemsPerPage = entitiesperPage,
                SearchText = search
            };

            var users = userService.GetPage(userFilter);

            var userEntitiesViewModel = EntityToViewModelMapper.Mapper.Map(users.Entities, new List<UserViewModel>());

            var pagination = new CustomPagination<UserViewModel>(userEntitiesViewModel, users.Page, entitiesperPage, users.Count);

            var usersViewModel = new UserListViewModel
            {
                Users = pagination,
                GridSortOptions = gridSortOptions,
                Page = currentPage,
                Search = search
            };

            return View(usersViewModel);
        }
        private static IQueryOver<User, User> AddSortingCriterias(PagedEntityListFilterDto filter, IQueryOver<User, User> query)
        {
            IQueryOverOrderBuilder<User, User> builder = null;

            switch (filter.Column)
            {
                case "Id":
                    builder = query.OrderBy(x => x.Id);
                    break;
                case "UserName":
                    builder = query.OrderBy(x => x.UserName);
                    break;
                case "LastName":
                    builder = query.OrderBy(x => x.LastName);
                    break;
                case "LastLogin":
                    builder = query.OrderBy(x => x.LastLogin);
                    break;
            }

            if (builder != null)
            {
                query = filter.AscendingOrder ? builder.Asc : builder.Desc;
            }

            return query;
        }
        public PagedEntityListDto<User> GetPage(PagedEntityListFilterDto filter)
        {
            try
            {
                int count;

                var query = repository.AsQueryOver<User>().Where(f => f.DeletedOn == null);

                if (filter != null)
                {
                    query = AddSortingCriterias(filter,query);
                }

                if (!string.IsNullOrEmpty(filter.SearchText))
                {
                    query = AddSearchCriterias(filter.SearchText, query);
                }

                var entities = query
                    .Skip((filter.StartPage - 1) * filter.ItemsPerPage)
                    .Take(filter.ItemsPerPage)
                    .Future<User>();

                var rowCount = CriteriaTransformer
                    .TransformToRowCount(query.UnderlyingCriteria)
                    .Future<int>();
                count = rowCount.FirstOrDefault();
                var entitiesList = entities.ToList();

                var pagedList = new PagedEntityListDto<User>(entitiesList, count);

                pagedList.Page = filter.StartPage;

                return pagedList;

            }
            catch (Exception ex)
            {
                throw new UserException("Failed to retrieve Users list.", ex);
            }
        }
        private static IQueryOver<Item, Item> AddSortingCriterias(PagedEntityListFilterDto filter, IQueryOver<Item, Item> query)
        {
            IQueryOverOrderBuilder<Item, Item> builder = null;

            switch (filter.Column)
            {
                case "Id":
                    builder = query.OrderBy(x => x.Id);
                    break;
                case "Name":
                    builder = query.OrderBy(x => x.Name);
                    break;
                case "SerialNumber":
                    builder = query.OrderBy(x => x.SerialNumber);
                    break;
                case "CreatedOn":
                    builder = query.OrderBy(x => x.CreatedOn);
                    break;
                case "ModifiedOn":
                    builder = query.OrderBy(x => x.ModifiedOn);
                    break;
            }

            if (builder != null)
            {
                query = filter.AscendingOrder ? builder.Asc : builder.Desc;
            }

            return query;
        }