public void GenericPagingTest()
{
var query = Persons.AsQueryable();
var vm = new SortingFilterModel {
PageSize = 3
};
var filterService = new FilterService(new ExpressionBuilder(), new SortingService(new ExpressionBuilder()));
var resultSet = filterService.GenericPaging(query, vm.AsSortingFilterModel);
//assert the page total
Assert.IsTrue(vm.PageTotal == 4, "page totle calculation is incorrect");
//assert the content within page 1, no need to default orderby since it only do take no skip
Assert.IsTrue(resultSet.Select(x => x.Name).Contains("joe"), "the paging result contains incorrect elment");
Assert.IsTrue(resultSet.Select(x => x.Name).Contains("kelly"), "the paging result contains incorrect elment");
Assert.IsTrue(resultSet.Select(x => x.Name).Contains("nancy"), "the paging result contains incorrect elment");
//set pageindex other than 1, run the function again, test if orderby + skip + take returns the correct resultset
vm.PageIndex = 3;
vm.SortingColumnCurrent = "BornDate";
vm.SortingOrderCurrent = SortingOrder.Ascending;
resultSet = filterService.GenericPaging(query, vm.AsSortingFilterModel);
var compareList = Persons.OrderByDescending(x => x.BornDate).Skip(6).Take(3).ToList();
Assert.IsTrue(resultSet.ToList()[0].PersonID == compareList[0].PersonID);
Assert.IsTrue(resultSet.ToList()[1].PersonID == compareList[1].PersonID);
Assert.IsTrue(resultSet.ToList()[2].PersonID == compareList[2].PersonID);
}
public IQueryable <T> GenericPaging <T>(IQueryable <T> queryableData, SortingFilterModel Model)
{
//always recalculate the count
var count = queryableData.Count();
Model.PageTotal = count / Model.PageSize + (count % Model.PageSize == 0 ? 0 : 1);
//if submit index is 0, do take no skip
IQueryable <T> results = null;
if (Model.ShouldResetPageIndex || Model.PageIndex > Model.PageTotal)
{
Model.PageIndex = 1;
}
//if query contains no order by, perform it on the default column
if (!Model.HasBeenSorted)
{
queryableData = SortingService.SortQueryDefaultColumn(queryableData, Model);
}
if (Model.PageIndex == 1)
{
results = queryableData.Take(Model.PageSize);
}
else
{
results = queryableData.Skip((Model.PageIndex - 1) * Model.PageSize).Take(Model.PageSize);
}
Model.ShouldResetPageIndex = false;
ReCaculateSinglePageDatas(Model);
return(results);
}
public void GenericContainTest()
{
var vm = new SortingFilterModel();
var filterService = new FilterService(new ExpressionBuilder(), new SortingService(new ExpressionBuilder()));
var query = Persons.AsQueryable();
query = filterService.AppendQueryWithContains <Person>("PhoneNr", "12345", query, vm.AsSortingFilterModel);
Assert.IsTrue(query.Count() == 4);
}
public void GenericPagingSinglePageDatasCalculationTest()
{
//setup view model
var filterSerivce = new FilterService(new ExpressionBuilder(), new SortingService(new ExpressionBuilder()));
var vm = new SortingFilterModel();
vm.PageSize = 20;
//test senario 1, total as 900, index 1, should return 5 singlepagedata, with the page1 as selected
vm.PageTotal = 900;
vm.PageIndex = 1;
filterSerivce.ReCaculateSinglePageDatas(vm);
var singlePageDatas = vm.SinglePageDatas;
Assert.IsTrue(singlePageDatas.FirstOrDefault() != null && singlePageDatas.FirstOrDefault().IsCurrentPageSelected == true, "the first page is not selected");
Assert.IsTrue(singlePageDatas.Where(x => x.IsCurrentPageSelected == true).Count() == 1, "only one page is selected");
Assert.IsTrue(singlePageDatas.Count() == 5, "total 5 pages as output");
//test senario 2, set the pageindex to 6, then 4,5,6,7,8 should be presented
vm.PageIndex = 6;
filterSerivce.ReCaculateSinglePageDatas(vm);
singlePageDatas = vm.SinglePageDatas;
Assert.IsTrue(singlePageDatas.Count() == 5, "total 5 pages as output");
Assert.IsTrue(singlePageDatas.IndexOf(singlePageDatas.FirstOrDefault(x => x.IsCurrentPageSelected)) == 2, "incorrect page is seleted");
//test senario 3, move to last page, then 896, 897, 898, 899, 900 should be presented
vm.PageIndex = 900;
filterSerivce.ReCaculateSinglePageDatas(vm);
singlePageDatas = vm.SinglePageDatas;
Assert.IsTrue(singlePageDatas.Count() == 5, "total 5 pages as output");
var index = singlePageDatas.IndexOf(singlePageDatas.FirstOrDefault(x => x.IsCurrentPageSelected));
Assert.IsTrue(index == 4, "incorrect page is seleted");
}
public void GenericPagingWhereMixTest()
{
//setup view model
var vm = new SortingFilterModel();
vm.SortingColumnCurrent = "BornDate";
vm.SortingOrderCurrent = SortingOrder.Ascending;
var filterService = new FilterService(new ExpressionBuilder(), new SortingService(new ExpressionBuilder()));
var query = Persons.AsQueryable();
//total 10, 4 pages, set index to 4
vm.PageIndex = 4;
query = query.Where(x => x.HasSupernaturalAbility == true);
var resultSet = filterService.GenericPaging(query, vm.AsSortingFilterModel);
//test1 the pageindex should have been resetted to 1
Assert.IsTrue(vm.PageIndex == 1, "the where clause will make pagetotal 2, page index should be resetted to 1");
//test2 navigate to page 2
vm.PageIndex = 2;
resultSet = filterService.GenericPaging(query, vm.AsSortingFilterModel);
Assert.IsTrue(vm.PageIndex == 2);
}
public void ReCaculateSinglePageDatas(SortingFilterModel Model)
{
Model.SinglePageDatas.Clear();
var SinglePageDatasTmp = new List <SinglePageData>();
//fake list, LeftRightBuffer times 4
int total = Model.LeftRightBuffer * 4 + 1;
//real list, LeftRightBuffer times 2
var total1 = Model.LeftRightBuffer * 2 + 1;
var startindex = Model.PageIndex - Model.LeftRightBuffer * 2;
var availableLeft = 0;
var availableRight = 0;
for (var i = startindex; i < total + startindex; i++)
{
//if the 2 pages left, 2 pages right are out side of the index, dont add it
if (i > 0 && i <= Model.PageTotal)
{
if (i < Model.PageIndex)
{
availableLeft++;
}
else if (i > Model.PageIndex)
{
availableRight++;
}
var tmp = new SinglePageData {
PageLabel = i.ToString(), PageId = "singlepagedata" + i.ToString(), PageCssClass = "spd"
};
SinglePageDatasTmp.Add(tmp);
if (i == Model.PageIndex)
{
tmp.IsCurrentPageSelected = true;
tmp.PageCssClass += " spdcurrent";
}
}
}
//4 conditions
if (availableLeft <= Model.LeftRightBuffer && availableRight <= Model.LeftRightBuffer)
{
Model.SinglePageDatas.AddRange(SinglePageDatasTmp);
}
else if (availableLeft > Model.LeftRightBuffer && availableRight > Model.LeftRightBuffer)
{
var toBeAddedElements = SinglePageDatasTmp.Skip(availableLeft - Model.LeftRightBuffer).Take(total1);
Model.SinglePageDatas.AddRange(toBeAddedElements);
}
else if (availableLeft <= Model.LeftRightBuffer)
{
Model.SinglePageDatas.AddRange(SinglePageDatasTmp.Take(total1));
}
else if (availableRight <= Model.LeftRightBuffer)
{
SinglePageDatasTmp.Reverse();
var toBeAddedElements = SinglePageDatasTmp.Take(total1).Reverse();
Model.SinglePageDatas.AddRange(toBeAddedElements);
}
}
protected void ResetPageIndex(SortingFilterModel Model)
{
Model.PageIndex = 1;
Model.ShouldResetPageIndex = false;
}
/// <summary>
/// suppose to generate query like this
/// Where(x => x.propertyA.ToLower().Contains(TargetValue.ToLower()));
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="MemberName"></param>
/// <param name="TargetValue"></param>
/// <returns></returns>
public IQueryable <T> AppendQueryWithContains <T>(string MemberName, string TargetValue, IQueryable <T> queryableData, SortingFilterModel Model)
{
//create chainedrules at two-level deep, tolower as level1 and contains as level2
var root = new ChainedRule(MemberName, Operator.ToLower, null);
root.ChildRule = new ChainedRule(MemberName, Operator.Contains, TargetValue.ToLower());
ParameterExpression p = Expression.Parameter(typeof(T), "x");
Expression right = ExpBuilder.EvaluateChainedRule <T>(root, p);
var whereExp = Expression.Lambda <Func <T, bool> >(right, new ParameterExpression[] { p });
var whereMethodExpression = ExpBuilder.BuildMethodExpression(queryableData, Where, whereExp, typeArguments: new Type[] { queryableData.ElementType });
IQueryable <T> results = queryableData.EvalQueryMethodCallExpression(whereMethodExpression);
//ShouldResetPageIndex value is set at the front end, when freetext search is triggered, always get the content from pageindex1
if (Model.ShouldResetPageIndex)
{
ResetPageIndex(Model);
}
return(results);
}
