public async Task <ActionResult> RegistratedUsers(SortModel model)
{
int pageSize = 15;
var users = await _usersInfoRepository.GetRegistratedUsersPaged(model.Page, pageSize);
var itemsCount = await _usersInfoRepository.GetCountOfRegistratedUsers();
RegistratedUsersViewModel viewModel = new RegistratedUsersViewModel()
{
PageViewModel = new PageViewModel(itemsCount, model.Page, pageSize),
RegistratedUsers = users ?? new List <RegistratedUsersTableModel>()
};
return(View(viewModel));
}
public StaticPagedList <EquipmentDto> GetList(EquipmentFilter filter, SortModel sort, int page, int count)
{
var equipments = _repository.TableNoTracking <Equipment>();
#region Filter
if (filter != null)
{
if (!string.IsNullOrWhiteSpace(filter.Number))
{
equipments = equipments.Where(x => x.Number.Contains(filter.Number));
}
if (filter.Auditories != null && filter.Auditories.Count != 0)
{
equipments = equipments.Where(x => filter.Auditories.Contains(x.AuditoryId));
}
}
var countElement = equipments.Count();
#endregion
#region Order
equipments = sort != null
? equipments.OrderBy($"{sort.Column} {sort.Order}").Skip(count * (page - 1)).Take(count)
: equipments.OrderByDescending(x => x.CreatedAt).Skip(count * (page - 1)).Take(count);
#endregion
#region Convert to dto
var equipmentDtos = equipments.Select(x => new EquipmentDto
{
Name = x.Name,
Id = x.Id,
AuditoryId = x.AuditoryId,
Note = x.Note,
Number = x.Number,
State = x.State
}).ToList();
#endregion
equipmentDtos.ForEach(x => x.Auditory = _dicService.GetDictionaryValues("TaskAuditory").Single(dic => dic.Id == x.AuditoryId).Value);
return(new StaticPagedList <EquipmentDto>(equipmentDtos, page, count, countElement));
}
public async Task <PaginationApiResponse <UserDisplayShortModel> > GetList(int skip, int limit, SortModel sort = null, UserSearchModel search = null)
{
sort = SortModel.Check(sort);
var result = new PaginationApiResponse <UserDisplayShortModel>(skip, limit, 0, new List <UserDisplayShortModel>());
result.Total = (int)await _repositoryUser.Count(x => x.State == MREntityState.Active);
var entities = await _repositoryUser.GetSorted(x => x.State == MREntityState.Active, x => x.CreateTime, true, result.Skip, result.Take);
if (entities != null && entities.Any())
{
result.List = _mapper.Map <List <UserDisplayShortModel> >(entities.ToList());
}
return(result);
}
/// <summary>
/// 异步加载数据
/// </summary>
/// <param name="dRequest"></param>
/// <returns></returns>
public ActionResult Read([DataSourceRequest] DataSourceRequest dRequest)
{
SortModel sort = null;
if (dRequest.Sorts != null && dRequest.Sorts.Count > 0)
{
sort = dRequest.Sorts[0].ToSortModel();
}
var noticeResult = NotificationService.List(dRequest.Page, dRequest.PageSize, sort);
DataSourceResult result = new DataSourceResult()
{
Data = noticeResult.Data,
Total = noticeResult.Total
};
return(Json(result));
}
/// </summary>
/// 显示所有的通告
/// </summary>
/// <returns>显示所有的通告</returns>
public ListResult <AnnouncementModel> List(int pageNo, int pageSize, SortModel sort, FilterModel filter)
{
using (var dbContext = new MissionskyOAEntities())
{
// 1、首先获取所有通告从数据库中
var list = dbContext.Announcements.AsEnumerable();
// 2、判断是否有排序
if (sort != null)
{
switch (sort.Member)
{
case "CreatedTime":
//
if (sort.Direction == SortDirection.Ascending)
{
list = list.OrderBy(item => item.CreatedTime);
}
else
{
list = list.OrderByDescending(item => item.CreatedTime);
}
break;
default:
break;
}
}
//
var count = list.Count();
// 分页
list = list.Skip((pageNo - 1) * pageSize).Take(pageSize).ToList();
ListResult <AnnouncementModel> result = new ListResult <AnnouncementModel>();
result.Data = new List <AnnouncementModel>();
list.ToList().ForEach(item =>
{
result.Data.Add(item.ToModel());
});
result.Total = count;
return(result);
}
}
public async Task <ActionResult> IncomeTransactions(SortModel model)
{
int pageSize = 15;
var incomeTransactions = await _transactionsRepository.GetPagedIncomeTransactions(model.Page, pageSize);
var itemsCount = await _transactionsRepository.GetCountOfIncomeTransactions();
IncomeTransactionsViewModel viewModel = new IncomeTransactionsViewModel()
{
PageViewModel = new PageViewModel(itemsCount, model.Page, pageSize),
IncomeTransactions = incomeTransactions ?? new List <IncomeTransactionTableModel>()
};
return(View(viewModel));
}
/// <summary>
/// 分页获取属性列表
/// </summary>
/// <param name="pageNo"></param>
/// <param name="pageSize"></param>
/// <param name="sort"></param>
/// <param name="filter"></param>
/// <returns></returns>
public ListResult <AssetAttributeModel> List(int pageNo, int pageSize, SortModel sort, FilterModel filter)
{
using (var dbContext = new MissionskyOAEntities())
{
var list = dbContext.AssetAttributes.AsEnumerable();
var count = list.Count();
list = list.OrderBy(it => it.Sort).Skip((pageNo - 1) * pageSize).Take(pageSize).ToList();
ListResult <AssetAttributeModel> result = new ListResult <AssetAttributeModel>();
result.Data = new List <AssetAttributeModel>();
list.ToList().ForEach(item =>
{
result.Data.Add(item.ToModel());
});
result.Total = count;
return(result);
}
}
public PagedResultModel <LpcReportModel> GetLPCReports(LpcReportRequest request)
{
var predicate = PredicateBuilder.True <LpcReport>();
if (!string.IsNullOrEmpty(request.Neighborhood))
{
predicate = predicate.And(x => x.LPCLocation.Neighborhood == request.Neighborhood);
}
if (!string.IsNullOrEmpty(request.Borough))
{
predicate = predicate.And(x => x.Borough == request.Borough);
}
if (!string.IsNullOrEmpty(request.ObjectType))
{
predicate = predicate.And(x => x.ObjectType == request.ObjectType);
}
var sortModel = new SortModel
{
SortColumn = !string.IsNullOrEmpty(request.SortColumn) ? request.SortColumn : null,
SortOrder = !string.IsNullOrEmpty(request.SortOrder) ? request.SortOrder : null
};
var sortingList = new List <SortModel> {
sortModel
};
int totalCount = _lpcReportRepository.GetCount(predicate);
var results = _lpcReportRepository
.GetPage(predicate, request.PageSize * (request.Page - 1), request.PageSize, sortingList).Include(x => x.LPCLocation);
var modelData = Mapper.Map <IEnumerable <LpcReport>, IEnumerable <LpcReportModel> >(results).ToList();
return(new PagedResultModel <LpcReportModel>
{
Total = totalCount,
Page = request.Page,
Limit = request.PageSize,
Results = modelData,
});
}
public static IQueryable <T> GetSorted <T>(this IQueryable <T> query, SortModel sort) where T : class, IVehicle
{
if (sort == null)
{
return(query);
}
return(sort.SortBy switch
{
"Name" => query.OrderBy(s => s.Name),
"Id" => query.OrderBy(s => s.Id),
"Abrv" => query.OrderBy(s => s.Abrv),
"Id_desc" => query.OrderBy(s => s.Id),
"Name_desc" => query.OrderByDescending(s => s.Name),
"Abrv_desc" => query.OrderByDescending(s => s.Abrv),
"Make" => query.OrderBy(s => s.SelectedVehicleMake.Name),
"Make_desc" => query.OrderByDescending(s => s.SelectedVehicleMake.Name),
_ => query.OrderBy(s => s.Name),
});
//[RebelAuthorize(Permissions = new[] { FixedPermissionIds.Sort })]
public virtual JsonResult SortForm(SortModel model)
{
if (!TryValidateModel(model))
{
return(ModelState.ToJsonErrors());
}
EntityPathCollection path;
using (var uow = Hive.Create <IContentStore>())
{
var found = uow.Repositories.Get(model.ParentId);
var exists = uow.Repositories.Exists <TypedEntity>(model.ParentId);
if (!exists)
{
throw new ArgumentException(string.Format("No entity found for id: {0} on action Sort", model.ParentId));
}
var childRelations = uow.Repositories.GetChildRelations(model.ParentId, FixedRelationTypes.DefaultRelationType);
foreach (var item in model.Items)
{
var relation = childRelations.Single(x => x.DestinationId.EqualsIgnoringProviderId(item.Id));
uow.Repositories.ChangeRelation(relation, relation.SourceId, relation.DestinationId, item.SortIndex);
}
path = uow.Repositories.GetEntityPaths(model.ParentId, FixedRelationTypes.DefaultRelationType);
uow.Complete();
}
Notifications.Add(new NotificationMessage(
"Sort.Success.Message".Localize(this),
"Sort.Title".Localize(this), NotificationType.Success));
return(new CustomJsonResult(new
{
success = true,
notifications = Notifications,
msg = "Sort.Success.Message".Localize(this),
path = path.ToJson()
}.ToJsonString));
}
/// <summary>
/// 列出所有签收单
/// </summary>
/// <param name="pageNo"></param>
/// <param name="pageSize"></param>
/// <param name="sort"></param>
/// <param name="filter"></param>
/// <returns></returns>
public ListResult <AcceptProxyModel> List(int pageNo, int pageSize, SortModel sort, FilterModel filter)
{
using (var dbContext = new MissionskyOAEntities())
{
var list = dbContext.AcceptProxies.AsEnumerable();
if (sort != null)
{
switch (sort.Member)
{
case "LastModifyTime":
if (sort.Direction == SortDirection.Ascending)
{
list = list.OrderBy(item => item.LastModifyTime);
}
else
{
list = list.OrderByDescending(item => item.LastModifyTime);
}
break;
default:
break;
}
}
var count = list.Count();
list = list.Skip((pageNo - 1) * pageSize).Take(pageSize).ToList();
ListResult <AcceptProxyModel> result = new ListResult <AcceptProxyModel>();
result.Data = new List <AcceptProxyModel>();
list.ToList().ForEach(item =>
{
result.Data.Add(item.ToModel());
});
result.Total = count;
return(result);
}
}
protected override void OnInitialized()
{
base.OnInitialized();
Sortable = Sortable || SorterMultiple != default || SorterCompare != default || DefaultSortOrder != default || SortDirections?.Any() == true;
if (IsHeader)
{
if (FieldExpression != null)
{
_propertyReflector = PropertyReflector.Create(FieldExpression);
}
if (Sortable)
{
if (_propertyReflector.HasValue)
{
SortModel = new SortModel <TData>(_propertyReflector.Value.PropertyInfo, SorterMultiple, DefaultSortOrder, SorterCompare);
}
else
{
(GetValue, SortModel) = ColumnDataIndexHelper <TData> .GetDataIndexConfig(this);
}
}
}
else if (IsBody)
{
SortModel = Context.HeaderColumns[ColIndex] is IFieldColumn fieldColumn ? fieldColumn.SortModel : null;
(GetValue, _) = ColumnDataIndexHelper <TData> .GetDataIndexConfig(this);
}
SortDirections ??= Table.SortDirections;
Sortable = Sortable || SortModel != null;
_sortDirection = SortModel?.SortDirection ?? DefaultSortOrder ?? SortDirection.None;
ClassMapper
.If("ant-table-column-has-sorters", () => Sortable)
.If($"ant-table-column-sort", () => Sortable && SortModel != null && SortModel.SortDirection.IsIn(SortDirection.Ascending, SortDirection.Descending));
}
public virtual async Task <IResult> GetAllAsync()
{
try
{
var sortCriteria = new List <SortModel>();
var sort = new SortModel();
sortCriteria.Add(sort);
var query = await UnitOfWork.Repository.GetAllAsync(sortCriteria);
var data = Mapper.Map <IEnumerable <T>, IEnumerable <TDto> >(query);
return(ResponseResult.PostResult(data, status: HttpStatusCode.OK,
message: HttpStatusCode.OK.ToString()));
}
catch (Exception e)
{
Result.Message = e.InnerException != null ? e.InnerException.Message : e.Message;
Result = new ResponseResult(null, status: HttpStatusCode.InternalServerError, exception: e,
message: Result.Message);
return(Result);
}
}
public virtual IList <TEntityModel> GetItems(IList <FilterModel> filters, SortModel sortModel, int page = 1, int pageSize = 20)
{
var currentItems = this.genericRepository.All();
if (filters != null)
{
foreach (var item in filters)
{
var condition = (Expression <Func <TEntity, bool> >) this.CreateExpressionForFilter(typeof(TEntity), item);
currentItems = currentItems.Where(condition);
}
}
var filteredItems = this.mapper.ProjectTo <TEntityModel>(currentItems).ToList();
IOrderedEnumerable <TEntityModel> orderedList;
if (sortModel != null)
{
orderedList = this.SortEntities(filteredItems, sortModel);
}
else
{
orderedList = this.SortEntities(filteredItems, new SortModel {
Direction = AscSortingCode, Prop = nameof(BaseDbModel.Id)
});
}
var skipItemsCount = (page - 1) * pageSize;
var pagedItems = pageSize <= 0 ?
orderedList : // get all, because no page size is pecified
orderedList
.Skip(skipItemsCount)
.Take(pageSize);
var result = pagedItems.ToList();
return(result);
}
public void SortingDescProperlyOrdersItemsBasedOnDateCreated()
{
var filters = new List <FilterModel>
{
new FilterModel
{
Prop = "Name",
Comparison = "equals",
Value = "Hello"
}
};
var sorting = new SortModel
{
Prop = "DateCreated",
Direction = "desc"
};
var result = this.dataSerivceUrl.GetItems(filters, sorting, 1, 10);
Assert.IsTrue(result[0].DateCreated > result[1].DateCreated);
}
private IQueryable <GenderModel> sortData(IQueryable <GenderModel> data, SortModel sortModel)
{
if (sortModel == null)
{
sortModel = new SortModel();
}
if (sortModel.SortOrder == "asc")
{
switch (sortModel.SortField)
{
}
}
else
{
switch (sortModel.SortField)
{
}
}
return(data);
}
public async Task <IEnumerable <Wallet> > GetSortedSearch(SortModel data)
{
PropertyInfo propertyInfo = null;
if (!string.IsNullOrEmpty(data.Key))
{
propertyInfo = typeof(Wallet).GetProperty(data.Key);
}
IEnumerable <Wallet> queryable = await GetAll();
if (!string.IsNullOrEmpty(data.Search))
{
queryable = queryable.Where
(c => c.Id.ToString().Equals(data.Search) ||
c.Type.Equals(data.Search) ||
c.Amount.ToString().Equals(data.Search));
//return queryable;
}
var skipped = (data.PagerModel.CurrentPage - 1) * data.PagerModel.PageSize;
queryable = queryable.Skip(skipped).Take(data.PagerModel.PageSize);
if (!string.IsNullOrEmpty(data.Key) && !string.IsNullOrEmpty(data.SortedFilter))
{
if (data.SortedFilter.Contains("asc"))
{
queryable = queryable.OrderByDescending(s => propertyInfo.GetValue(s, null));
}
if (data.SortedFilter.Contains("desc"))
{
queryable = queryable.OrderBy(s => propertyInfo.GetValue(s, null));
}
}
return(queryable);
}
public void PagingProperlyReturnsOneItemForPagesize1()
{
var filters = new List <FilterModel>
{
new FilterModel
{
Prop = "Name",
Comparison = "equals",
Value = "Hello"
}
};
var sorting = new SortModel
{
Prop = "DateCreated",
Direction = "desc"
};
var result = this.dataSerivceUrl.GetItems(filters, sorting, 1, 1);
Assert.IsTrue(result.Count == 1);
}
protected IQueryable <T> GetSorted <T>(IQueryable <T> collection, SortModel sorting)
{
if (sorting is null)
{
return(collection);
}
if (sorting.SortName is null)
{
return(collection);
}
var type = typeof(T);
var sortFieldType = type.GetProperty(sorting.SortName)?.PropertyType;
if (sortFieldType == null)
{
return(collection);
}
if (sortFieldType == typeof(DateTime))
{
return(sorting.SortAscending ?
collection.OrderBy(CreateSelectorExpression <T, DateTime>(sorting.SortName)) :
collection.OrderByDescending(CreateSelectorExpression <T, DateTime>(sorting.SortName)));
}
if (sortFieldType == typeof(Double))
{
return(sorting.SortAscending ?
collection.OrderBy(CreateSelectorExpression <T, Double>(sorting.SortName)) :
collection.OrderByDescending(CreateSelectorExpression <T, Double>(sorting.SortName)));
}
return(sorting.SortAscending ?
collection.OrderBy(CreateSelectorExpression <T, string>(sorting.SortName)) :
collection.OrderByDescending(CreateSelectorExpression <T, string>(sorting.SortName)));
}
public virtual ActionResult Sort(HiveId?id)
{
if (id.IsNullValueOrEmpty())
{
return(HttpNotFound());
}
using (var uow = Hive.Create <IContentStore>())
{
var exists = uow.Repositories.Exists <TypedEntity>(id.Value);
if (!exists)
{
throw new ArgumentException(string.Format("No entity found for id: {0} on action Sort", id));
}
var model = new SortModel {
ParentId = id.Value
};
var items = uow.Repositories.GetLazyChildRelations(id.Value, FixedRelationTypes.DefaultRelationType);
model.Items = items.Select(
x => new SortItem
{
UtcCreated = x.Destination.UtcCreated,
Id = x.Destination.Id,
SortIndex = x.Ordinal,
//TODO: Casting the relation as a TPE here but the item may be related to something else, not a TPE: need a helper method for returning the name
Name =
((TypedEntity)x.Destination).Attributes[NodeNameAttributeDefinition.AliasValue].Values[
"Name"].ToString()
})
.OrderBy(x => x.SortIndex)
.ToArray();
return(View(model));
}
}
public void PagingProperlyReturnsSecondPage()
{
var filters = new List <FilterModel>
{
new FilterModel
{
Prop = "Name",
Comparison = "equals",
Value = "Hello"
}
};
var sorting = new SortModel
{
Prop = "DateCreated",
Direction = "desc"
};
var result = this.dataSerivceUrl.GetItems(filters, sorting, 2, 1);
var wanteObject = MoqDbContext.urls.Where(x => x.Name == "Hello" && x.IsDeleted == false).OrderByDescending(x => x.DateCreated).ToList();
Assert.IsTrue(result[0].Id == wanteObject[1].Id);
}
public async Task <IActionResult> MyRefferals(SortModel model)
{
int pageSize = 15;
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
if (string.IsNullOrEmpty(userId))
{
return(Redirect("/Identity/Account/Login%2FMy%2FEvents"));
}
var reffUsers = await _userRepository.GetUserRefferals_Paged(userId, model.Page, pageSize);
var itemsCount = await _userRepository.GetCountOfRefferrersUser(userId);
UserRefferalViewModel viewModel = new UserRefferalViewModel()
{
PageViewModel = new PageViewModel(itemsCount, model.Page, pageSize),
MyRefferals = reffUsers ?? new List <UserRefferalTableModel>()
};
return(View(viewModel));
}
/// <summary>
/// Set or get current Sort parametrs from session
/// </summary>
/// <param name="model"></param>
private void GetSort(GoodsModel model)
{
SortModel sess = (SortModel)Session["Sort"];
if (sess == null)
{
SortModel sort = new SortModel()
{
RevName = "A-Я",
RevboolName = false,
RevId = "сначала новые",
RevboolId = true,
RevPrice = "сначала дорогие",
RevboolPrice = true
};
Session["Sort"] = sort;
model.Sort = sort;
}
else
{
model.Sort = sess;
}
}
/// <summary>
/// 异步加载数据
/// </summary>
/// <param name="dRequest"></param>
/// <returns></returns>
public ActionResult Read([DataSourceRequest] DataSourceRequest dRequest)
{
SortModel sort = null;
if (dRequest.Sorts != null && dRequest.Sorts.Count > 0)
{
sort = dRequest.Sorts[0].ToSortModel();
}
FilterModel filter = null;
if (dRequest.Filters != null && dRequest.Filters.Count > 0)
{
filter = ((FilterDescriptor)dRequest.Filters[0]).ToSortModel();
}
var noticeResult = RoleService.List(dRequest.Page, dRequest.PageSize, sort, filter);
DataSourceResult result = new DataSourceResult()
{
Data = noticeResult.Data,
Total = noticeResult.Total
};
return(Json(result));
}
public static SortModel ToSortModel(this SortDescriptor sort)
{
SortModel model = new SortModel()
{
Member = sort.Member
};
switch (sort.SortDirection)
{
case System.ComponentModel.ListSortDirection.Ascending:
model.Direction = SortDirection.Ascending;
break;
case System.ComponentModel.ListSortDirection.Descending:
model.Direction = SortDirection.Descending;
break;
default:
break;
}
return(model);
}
public StaticPagedList <Purchase> GetList(PlanPurchaseFilter filter, SortModel sort, int page, int count)
{
var plans = _repository.TableNoTracking <Purchase>();
#region Filter
if (filter != null)
{
if (!string.IsNullOrWhiteSpace(filter.Name))
{
plans = plans.Where(x => x.Name.Contains(filter.Name));
}
if (filter.From != null)
{
plans = plans.Where(x => x.Date >= filter.From);
}
if (filter.To != null)
{
plans = plans.Where(x => x.Date <= filter.To);
}
}
#endregion
var countElement = plans.Count();
#region Order
plans = sort != null
? plans.OrderBy($"{sort.Column} {sort.Order}").Skip(count * (page - 1)).Take(count)
: plans.OrderByDescending(x => x.CreatedAt).Skip(count * (page - 1)).Take(count);
#endregion
return(new StaticPagedList <Purchase>(plans, page, count, countElement));
}
private IQueryable <MovieResponseModel> ApplySorting(SortModel sort, IQueryable <MovieResponseModel> query)
{
if (sort.IsDescending)
{
if (sort.Field.ToLower() == EntityColumnNamesConstants.Id.ToLower())
{
query = query.OrderByDescending(x => x.Id);
}
else if (sort.Field.ToLower() == EntityColumnNamesConstants.Title.ToLower())
{
query = query.OrderByDescending(x => x.Title);
}
else if (sort.Field.ToLower() == EntityColumnNamesConstants.ReleaseDate.ToLower())
{
query = query.OrderByDescending(x => x.ReleaseDate);
}
}
else
{
if (sort.Field.ToLower() == EntityColumnNamesConstants.Id.ToLower())
{
query = query.OrderBy(x => x.Id);
}
else if (sort.Field.ToLower() == EntityColumnNamesConstants.Title.ToLower())
{
query = query.OrderBy(x => x.Title);
}
else if (sort.Field.ToLower() == EntityColumnNamesConstants.ReleaseDate.ToLower())
{
query = query.OrderBy(x => x.ReleaseDate);
}
}
return(query);
}
public async Task <IActionResult> Index(SortModel model)
{
int pageSize = 15;
if (!string.IsNullOrEmpty(model.SearchString))
{
var users = await _userRepository.FindPagedUsersByUsername(model.SearchString, model.Page,
pageSize);
UsersViewModel viewModel = new UsersViewModel()
{
PageViewModel = new PageViewModel(users.Count, model.Page, pageSize),
Users = users
};
return(View("Views/Admin/Users.cshtml", viewModel));
}
else if (!string.IsNullOrEmpty(model.ColumnName))
{
//NOT COMPLETED
return(null);
}
else
{
var users = await _userRepository.GetPagedUsers(model.Page, pageSize);
var usersCount = await _userRepository.GetCountOfUsers();
UsersViewModel viewModel = new UsersViewModel()
{
PageViewModel = new PageViewModel(usersCount, model.Page, pageSize),
Users = users
};
return(View("Views/Admin/Users.cshtml", viewModel));
}
}
public PagedResultModel <LandmarkModel> GetLandmarks(LandmarkRequest request)
{
var predicate = PredicateBuilder.True <Landmark>();
if (!string.IsNullOrEmpty(request.LPCNumber))
{
predicate = predicate.And(x => x.LP_NUMBER == request.LPCNumber);
}
var sortModel = new SortModel
{
SortColumn = !string.IsNullOrEmpty(request.SortColumn) ? request.SortColumn : null,
SortOrder = !string.IsNullOrEmpty(request.SortOrder) ? request.SortOrder : null
};
var sortingList = new List <SortModel>();
sortingList.Add(sortModel);
int totalCount = _landmarktRepository.FindBy(predicate).Count();
var results = _landmarktRepository
.GetPage(predicate, request.PageSize * (request.Page - 1), request.PageSize, sortingList);
var modelData = Mapper.Map <IEnumerable <Landmark>, IEnumerable <LandmarkModel> >(results).ToList();
var pagedResult = new PagedResultModel <LandmarkModel>
{
Total = totalCount,
Page = request.Page,
Limit = request.PageSize,
Results = modelData,
};
return(pagedResult);
}
public void Can_Get_Filtered_Paging_List()
{
var predicate = PredicateBuilder.True <Landmark>();
var request = new LandmarkRequest()
{
PageSize = 20,
Page = 1,
};
var sortModel = new SortModel
{
SortColumn = !string.IsNullOrEmpty(request.SortColumn) ? request.SortColumn : null,
SortOrder = !string.IsNullOrEmpty(request.SortOrder) ? request.SortOrder : null,
};
var sortingList = new List <SortModel>();
sortingList.Add(sortModel);
var results = _landmarkRepository
.GetPage(predicate, request.PageSize * (request.Page - 1), request.PageSize, sortingList);
Assert.NotNull(results);
}