public List<MonthlyUserStatisticData> GetPageFromMonthlyStats(int pageNumber, int pageSize, int month, int year)
        {
            var filter = new BaseFilter() { CurrentPage = pageNumber, ItemsPerPage = pageSize };
            List<MonthlyUserStatisticData> items = GetItemsByFilterCM(filter, SortBy.Descending("score"), month, year);

            //DateTime previousPeriod = new DateTime(year, month, 1).AddDays(-1);

            return items;
        }

 /// <summary>
 /// This is a shared function that can be used to get a DataTable to bound with a data bound control using a where clause.
 /// </summary>
 public static System.Data.DataTable GetDataTable(BaseFilter join, string where)
 {
     ReportEstimateRecord[] recs = GetRecords(join, where);
     return  ReportEstimateTable.Instance.CreateDataTable(recs, null);
 }

        public static String[] GetValues(
		BaseColumn col,
		BaseFilter join,
		WhereClause where,
		OrderBy orderBy,
		int maxItems)
        {
            // Create the filter list.
            SqlBuilderColumnSelection retCol = new SqlBuilderColumnSelection(false, true);
            retCol.AddColumn(col);

            return UsersTable.Instance.GetColumnValues(retCol, join, where.GetFilter(), null, orderBy, BaseTable.MIN_PAGE_NUMBER, maxItems);
        }

        public static UsersRecord[] GetRecords(
        BaseFilter join,
		WhereClause where,
		OrderBy orderBy,
		int pageIndex,
		int pageSize,
		ref int totalRecords)
        {
            ArrayList recList = UsersTable.Instance.GetRecordList(join, where.GetFilter(), null, orderBy, pageIndex, pageSize, ref totalRecords);

            return (UsersRecord[])recList.ToArray(Type.GetType("FPCEstimate.Business.UsersRecord"));
        }

        /// <summary>
        /// This is a shared function that can be used to get total number of records that will be returned using the where clause.
        /// </summary>
        public static int GetRecordCount(BaseFilter join, string where)
        {
            SqlFilter whereFilter = null;
            if (where != null && where.Trim() != "")
            {
               whereFilter = new SqlFilter(where);
            }

            return (int)UsersTable.Instance.GetRecordListCount(join, whereFilter, null, null);
        }

 /// <summary>
 /// This is a shared function that can be used to get a UsersRecord record using a where clause.
 /// </summary>
 public static UsersRecord GetRecord(BaseFilter join, string where)
 {
     OrderBy orderBy = null;
     return GetRecord(join, where, orderBy);
 }

 /// <summary>
 /// This is a shared function that can be used to get a DataTable to bound with a data bound control using a where clause.
 /// </summary>
 public static System.Data.DataTable GetDataTable(BaseFilter join, string where)
 {
     UsersRecord[] recs = GetRecords(join, where);
     return  UsersTable.Instance.CreateDataTable(recs, null);
 }

 public void GetByFilterShouldUseDefaultIfPageSizeIfItIsIncorrect()
 {
     ISelpConfiguration configuration = new InMemoryConfiguration();
     configuration.DefaultPageSize = 11;
     InitRepositoryParams(true, configuration);
     int total;
     var filter = new BaseFilter
     {
         PageSize = -55
     };
     List<FakeEntity> list = repository.GetByFilter(filter, out total);
     Assert.IsNotNull(list, "Result is null");
     Assert.AreEqual(11, list.Count, "Result count is wrong");
     Assert.AreEqual(11, filter.PageSize, "Filter hasn't been normalized");
     Assert.AreEqual(100, total, "Total is incorrect");
     Assert.AreEqual(11, filter.PageSize, "Returned PageSize incorrect");
 }

 public void GetByFilterShouldThrowIfSortFieldNotFound()
 {
     InitRepositoryParams(true);
     int total;
     BaseFilter filter = new BaseFilter
     {
         SortDirection = ListSortDirection.Descending,
         SortField = "dsadsadsada"
     };
     List<FakeEntity> list = repository.GetByFilter(filter, out total);
 }

 public void GetByFilterShouldReturnEmptyListWhenNoEntitiesFound()
 {
     InitRepositoryParams(false);
     int total;
     BaseFilter filter = new BaseFilter
     {
         Page = 100,
         PageSize = 200
     };
     List<FakeEntity> list = repository.GetByFilter(filter, out total);
     Assert.IsNotNull(list, "Result is null");
     Assert.AreEqual(0, list.Count, "Result is not empty");
     Assert.AreEqual(150, total, "Total incorrect");
     Assert.AreEqual(100, filter.Page, "Page incorrect");
     Assert.AreEqual(200, filter.PageSize, "PageSize incorrect");
 }

 public void GetByFilterShouldHaveCorrectOrderWhenItIsSpecifiedDescending()
 {
     InitRepositoryParams(true);
     int total;
     BaseFilter filter = new BaseFilter
     {
         PageSize = 20,
         Page = 3,
         SortDirection = ListSortDirection.Descending,
         SortField = "Id"
     };
     List<FakeEntity> list = repository.GetByFilter(filter, out total);
     Assert.IsNotNull(list, "Result is null");
     Assert.AreEqual(60, list[0].Id, "First item id is wrong");
     Assert.AreEqual(3, filter.Page, "Page incorrect");
     Assert.AreEqual(20, filter.PageSize, "PageSize incorrect");
 }

 public void GetByFilterShouldHaveCorrectOffsetWhenPageIsSpecified()
 {
     InitRepositoryParams(true);
     int total;
     BaseFilter filter = new BaseFilter
     {
         PageSize = 20,
         Page = 2
     };
     List<FakeEntity> list = repository.GetByFilter(filter, out total);
     Assert.IsNotNull(list, "Result is null");
     Assert.AreEqual(21, list.Min(d => d.Id), "Minimal ID is wrong");
     Assert.AreEqual(2, filter.Page, "Page incorrect");
     Assert.AreEqual(20, filter.PageSize, "PageSize incorrect");
 }

        public void GetByFilterShouldHaveCorrectCountWhenPageSizeIsSpecified()
        {
            InitRepositoryParams(true);
            int total;
            BaseFilter filter = new BaseFilter
            {
                PageSize = 20
            };
            List<FakeEntity> list = repository.GetByFilter(filter, out total);

            Assert.IsNotNull(list, "Result is null");
            Assert.AreEqual(20, list.Count, "Result count is wrong");
            Assert.AreEqual(100, total, "Result total is wrong");
            Assert.AreEqual(20, filter.PageSize, "PageSize incorrect");
        }

 /// <summary>
 /// This is a shared function that can be used to get a ReportEstimateRecord record using a where clause.
 /// </summary>
 public static ReportEstimateRecord GetRecord(BaseFilter join, string where)
 {
     OrderBy orderBy = null;
     return GetRecord(join, where, orderBy);
 }

        public static EstimateRecord[] GetRecords(
        BaseFilter join,
		WhereClause where,
		OrderBy orderBy,
		int pageIndex,
		int pageSize)
        {
            ArrayList recList = EstimateTable.Instance.GetRecordList(join, where.GetFilter(), null, orderBy, pageIndex, pageSize);

            return (EstimateRecord[])recList.ToArray(Type.GetType("FPCEstimate.Business.EstimateRecord"));
        }

 public DumpInputPin(string _name, BaseFilter _filter)
     :base(_name,_filter)
 {
 }

 public void GetByFilterShouldUseFirstPageIfItIsIncorrect()
 {
     InitRepositoryParams(true);
     int total;
     var filter = new BaseFilter
     {
         Page = -5,
         PageSize = 20
     };
     List<FakeEntity> list = repository.GetByFilter(filter, out total);
     Assert.IsNotNull(list, "Result is null");
     Assert.AreEqual(1, list.Min(d => d.Id), "Minimal ID is incorrect");
     Assert.AreEqual(1, filter.Page, "Filter hasn't been normalized");
     Assert.AreEqual(20, filter.PageSize, "Returned PageSize incorrect");
 }

 public void GetByFilterShouldFilterEntitiesByName()
 {
     InitRepositoryParams(false);
     int total;
     var filter = new BaseFilter
     {
         Search = "Entity 10"
     };
     List<FakeEntity> list = repository.GetByFilter(filter, out total);
     Assert.IsNotNull(list, "Result is null");
     Assert.AreEqual(11, total, "Count is incorrect");
 }

 public void GetByFilterShouldFilterEntitiesByNameNotIncludedDeleted()
 {
     InitRepositoryParams(true);
     int total;
     var filter = new BaseFilter
     {
         Search = "125"
     };
     List<FakeEntity> list = repository.GetByFilter(filter, out total);
     Assert.IsNotNull(list, "Result is null");
     Assert.AreEqual(0, total, "Count is incorrect");
 }

 public DataForExport(BaseTable tbl, WhereClause wc, OrderBy orderBy, BaseColumn[] columns, BaseFilter join)
 {
     this.DBTable = tbl;
     this.SelectWhereClause = wc;
     this.SelectOrderBy = orderBy;
     this.SelectJoin = join;
     if (columns != null)
         ColumnList.AddRange(columns);
 }