public static (int beginIndex, int endIndex) ConvertPageParametersToIndices(IPagingParameters pagingParameters)
{
var beginIndex = (pagingParameters.Page - 1) * pagingParameters.PageSize;
var endIndex = beginIndex + pagingParameters.PageSize;
return(beginIndex, endIndex);
}
public virtual IReadItemsByPathRequest DeepCopyGetItemByPathRequest()
{
ISessionConfig connection = null;
IItemSource itemSrc = null;
IQueryParameters payload = null;
IPagingParameters pagingSettings = null;
if (null != this.SessionSettings)
{
connection = this.SessionSettings.SessionConfigShallowCopy();
}
if (null != this.ItemSource)
{
itemSrc = this.ItemSource.ShallowCopy();
}
if (null != this.QueryParameters)
{
payload = this.QueryParameters.DeepCopy();
}
if (null != this.PagingSettings)
{
pagingSettings = this.PagingSettings.PagingParametersCopy();
}
return(new ReadItemByPathParameters(connection, itemSrc, payload, pagingSettings, this.ItemPath));
}
/// <summary>
/// Gets the paged list of <see cref="IProjectUserPoco"/> models.
/// </summary>
/// <param name="pagingParameters">The paging parameters.</param>
/// <param name="filter">The filter expression.</param>
/// <param name="orderBy">The order by.</param>
/// <param name="includeProperties">The include properties.</param>
/// <returns>Paged list of <see cref="IProjectUserPoco"/> models.</returns>
public virtual IPagedList <IProjectUserPoco> GetPaged(IPagingParameters pagingParameters, Expression <Func <IProjectUserPoco, bool> > filter = null, ISortingParameters orderBy = null, params string[] includeProperties)
{
var count = genericRepository.GetCount();
var entities = genericRepository.Get(pagingParameters, filter, orderBy, includeProperties);
return(new StaticPagedList <IProjectUserPoco>(mapper.Map <IEnumerable <IProjectUserPoco> >(entities), pagingParameters.PageNumber, pagingParameters.PageSize, count));
}
public virtual ISitecoreSearchRequest DeepCopySitecoreSearchRequest()
{
ISessionConfig connection = null;
IItemSource itemSrc = null;
IQueryParameters payload = null;
IPagingParameters pagingSettings = null;
if (null != this.SessionSettings)
{
connection = this.SessionSettings.SessionConfigShallowCopy();
}
if (null != this.ItemSource)
{
itemSrc = this.ItemSource.ShallowCopy();
}
if (null != this.QueryParameters)
{
payload = this.QueryParameters.DeepCopy();
}
if (null != this.PagingSettings)
{
pagingSettings = this.PagingSettings.PagingParametersCopy();
}
return(new SitecoreSearchParameters(connection, itemSrc, payload, pagingSettings, this.SortParameters, this.IncludeStandardTemplateFields, this.Term));
}
protected BaseSpecification(IPagingParameters pagingParameters)
{
if (pagingParameters.DisablePaging != true)
{
ApplyPaging(pagingParameters.GetSkipValue(), pagingParameters.GetTakeValue());
}
}
private async Task <ProjectsViewModel> GetProjectsViewModelAsync(IPagingParameters pagingParameters)
{
var sortingParameter = new SortingParameters();
sortingParameter.Add(new SortingPair(nameof(IProjectPoco.DateCreated), false));
var statuses = lookupService.GetAllTaskStatus();
var domainList = await projectService.GetProjectsPagedAsync(pagingParameters, p => p.CompanyId == this.CompanyId, sortingParameter,
this.ToNavPropertyString(nameof(IProjectPoco.Tasks)), this.ToNavPropertyString(nameof(IProjectPoco.ProjectUsers), nameof(IProjectUserPoco.User)));
var vmProjects = new StaticPagedList <ProjectPreviewViewModel>(Mapper.Map <IEnumerable <ProjectPreviewViewModel> >(domainList.ToList()), pagingParameters.PageNumber, pagingParameters.PageSize, domainList.TotalItemCount);
foreach (var project in vmProjects)
{
var tasks = domainList.First(p => p.Id == project.Id).Tasks;
var team = Mapper.Map <IEnumerable <UserPreviewViewModel> >(domainList.First(p => p.Id == project.Id).ProjectUsers.Select(d => d.User));
project.TaskCount = tasks.Count();
project.CompletedTaskCount = tasks.Where(d => d.StatusId == statuses.First(s => s.Abrv == "CLOSED").Id).Count();
project.LateTaskCount = tasks.Where(p => p.DueDate <= DateTime.UtcNow).Count();
project.TeamMembers = team;
}
var vm = new ProjectsViewModel()
{
Projects = vmProjects
};
return(vm);
}
/// <summary>
/// Get the list of all <see cref="TEntity"/>.
/// </summary>
/// <param name="pagingParameters">The paging parameters.</param>
/// <param name="orderBy">The order by.</param>
/// <param name="includeProperties">The include properties.</param>
/// <returns>List of all <see cref="TEntity"/>.</returns>
public virtual IEnumerable <TEntity> GetAll(
IPagingParameters pagingParameters,
ISortingParameters orderBy = null,
params string[] includeProperties)
{
return(GetQueryable(pagingParameters, null, orderBy, includeProperties).ToList());
}
/// <summary>
/// Gets the paged list of <see cref="IUserPoco"/> models asynchronous.
/// </summary>
/// <param name="pagingParameters">The paging parameters.</param>
/// <param name="filter">The filter expression.</param>
/// <param name="orderBy">The order by.</param>
/// <param name="includeProperties">The include properties.</param>
/// <returns>Paged list of <see cref="IUserPoco"/> models asynchronous.</returns>
public virtual async Task<IPagedList<IUserPoco>> GetPagedAsync(IPagingParameters pagingParameters, Expression<Func<IUserPoco, bool>> filter = null, ISortingParameters orderBy = null, params string[] includeProperties)
{
var count = await genericRepository.GetCountAsync(filter);
var entities = await genericRepository.GetAsync(pagingParameters, filter, orderBy, includeProperties);
return new StaticPagedList<IUserPoco>(mapper.Map<IEnumerable<IUserPoco>>(entities), pagingParameters.PageNumber, pagingParameters.PageSize, count);
}
/// <summary>
/// Gets a paged list of all <see cref="IUserPoco"/> models.
/// </summary>
/// <param name="pagingParameters">The paging parameters.</param>
/// <param name="orderBy">The order by.</param>
/// <param name="includeProperties">The include properties.</param>
/// <returns>Paged list of all <see cref="IUserPoco"/> models.</returns>
public virtual IPagedList<IUserPoco> GetAllPaged(IPagingParameters pagingParameters, ISortingParameters orderBy = null, params string[] includeProperties)
{
int count = genericRepository.GetCount();
var entities = genericRepository.GetAll(pagingParameters, orderBy, includeProperties);
return new StaticPagedList<IUserPoco>(mapper.Map<IEnumerable<IUserPoco>>(entities), pagingParameters.PageNumber, pagingParameters.PageSize, count);
}
/// <summary>
/// Gets the list of all <see cref="TEntity"/> asynchronous.
/// </summary>
/// <param name="pagingParameters">The paging parameters.</param>
/// <param name="orderBy">The order by.</param>
/// <param name="includeProperties">The include properties.</param>
/// <returns>List of all <see cref="TEntity"/> asynchronous.</returns>
public virtual async Task <IEnumerable <TEntity> > GetAllAsync(
IPagingParameters pagingParameters,
ISortingParameters orderBy = null,
params string[] includeProperties)
{
return(await GetQueryable(pagingParameters, null, orderBy, includeProperties).ToListAsync());
}
public void TestReadItemByIdCopiesSessionSettings()
{
var defaultSource = new MutableItemSource("master", "en", 33);
var sessionSettings = new MutableSessionConfig("localhost", "/sitecore/shell", "v100500");
ScopeParameters scope = new ScopeParameters();
scope.AddScope(ScopeType.Parent);
scope.AddScope(ScopeType.Self);
string[] fields = { "Ukraine", "is", "Europe" };
var queryParameters = new QueryParameters(PayloadType.Content, scope, fields);
IPagingParameters pagingSettings = null;
ReadItemsByIdParameters request = new ReadItemsByIdParameters(
sessionSettings,
defaultSource,
queryParameters,
pagingSettings,
"{aaaa-aa-bb}");
var otherRequest = request.DeepCopyGetItemByIdRequest();
{
sessionSettings.SetInstanceUrl("paappaa");
Assert.AreEqual("localhost", otherRequest.SessionSettings.InstanceUrl);
Assert.AreNotSame(request.SessionSettings, otherRequest.SessionSettings);
Assert.AreNotSame(request.ItemSource, otherRequest.ItemSource);
Assert.AreNotSame(request.QueryParameters, otherRequest.QueryParameters);
}
}
/// <summary>
/// Gets the list of <see cref="TEntity"/> asynchronous.
/// </summary>
/// <param name="pagingParameters">The paging parameters.</param>
/// <param name="filter">The filter expression.</param>
/// <param name="orderBy">The order by.</param>
/// <param name="includeProperties">The include properties.</param>
/// <returns>List of <see cref="TEntity"/> asynchronous.</returns>
public virtual async Task <IEnumerable <TEntity> > GetAsync(
IPagingParameters pagingParameters,
Expression <Func <TModel, bool> > filter = null,
ISortingParameters orderBy = null,
params string[] includeProperties)
{
return(await GetQueryable(pagingParameters, filter, orderBy, includeProperties).ToListAsync());
}
/// <summary>
/// Gets a paged list of all <see cref="IProjectUserPoco"/> models asynchronously.
/// </summary>
/// <param name="pagingParameters">The paging parameters.</param>
/// <param name="orderBy">The order by.</param>
/// <param name="includeProperties">The include properties.</param>
/// <returns>Paged list of all <see cref="IProjectUserPoco"/> models asynchronously.</returns>
public virtual async Task <IPagedList <IProjectUserPoco> > GetAllPagedAsync(IPagingParameters pagingParameters, ISortingParameters orderBy = null, params string[] includeProperties)
{
int count = await genericRepository.GetCountAsync();
var entities = await genericRepository.GetAllAsync(pagingParameters, orderBy, includeProperties);
return(new StaticPagedList <IProjectUserPoco>(mapper.Map <IEnumerable <IProjectUserPoco> >(entities), pagingParameters.PageNumber, pagingParameters.PageSize, count));
}
public static IPagedList <T> FetchPaged <T>(this IQueryable <T> query, IPagingParameters pagingParameters)
{
if (pagingParameters != null)
{
return(query.FetchPaged(pagingParameters.PageNumber, pagingParameters.PageSize));
}
return(query.FetchPaged(new PagingParameters()));
}
/// <summary>
/// Asynchronously gets a range of counties, sorted according to the sorting options provided. An optional filter can also be applied.
/// </summary>
/// <param name="filter">Instance of type <see cref="IFilter"/>.</param>
/// <param name="paging">An instance of type <see cref="IPagingParameters"/>, holds paging data.</param>
/// <param name="sorting">Sorting options</param>
/// <returns>Returns <see cref="Task{IPagedList{ICounty}}"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="paging"/> is null.</exception>
public Task<IPagedList<ICounty>> GetAsync(IPagingParameters paging, ISortingParameters sorting, IFilter filter)
{
if (paging == null)
{
throw new ArgumentNullException("paging");
}
return repository.GetAsync(paging, sorting, filter);
}
/// <summary>
/// Gets all or filtered vehicleModels.
/// </summary>
/// <param name="filter"></param>
/// <returns>StaticPagedList if filter != null, if filter == null returns list of all VehicleModel.</returns>
public virtual async Task<IEnumerable<IVehicleModel>> GetAsync(IPagingParameters pagingParameters, ISortingParameters sortingParameters, IFilter filter)
{
var db = ApplicationDbContext.Create();
var vehicleModels = from s in db.VehicleModels select s;
string sortExpression = sortingParameters.Sorters.First().GetSortExpression();
switch (sortExpression)
{
case "name_asc":
vehicleModels = vehicleModels.OrderBy(s => s.Name);
break;
case "name_dsc":
vehicleModels = vehicleModels.OrderByDescending(s => s.Name);
break;
case "abrv_asc":
vehicleModels = vehicleModels.OrderBy(s => s.Abrv);
break;
case "abrv_dsc":
vehicleModels = vehicleModels.OrderByDescending(s => s.Abrv);
break;
case "vehicleMake_asc":
vehicleModels = vehicleModels.OrderBy(s => s.VehicleMake.Name);
break;
case "vehicleMake_dsc":
vehicleModels = vehicleModels.OrderByDescending(s => s.VehicleMake.Name);
break;
default :
vehicleModels = vehicleModels.OrderBy(s => s.Name);
break;
}
if (!string.IsNullOrWhiteSpace(filter.SearchString))
{
vehicleModels = vehicleModels.Where(s => s.Name.ToUpper()
.Contains(filter.SearchString.ToUpper())
|| s.Abrv.ToUpper()
.Contains(filter.SearchString.ToUpper())
|| s.VehicleMake.Name.ToUpper()
.Contains(filter.SearchString.ToUpper()));
}
if (pagingParameters == null)
{
var list = vehicleModels.ToList();
var mappedList = Mapper.Map<IEnumerable<VehicleModelPoco>>(list);
return mappedList;
}
var paged = await vehicleModels.ToPagedListAsync(pagingParameters.PageNumber, pagingParameters.PageSize);
var mapped = Mapper.Map<IEnumerable<VehicleModelPoco>>(paged);
var vehicleModelsPagedList = new StaticPagedList<VehicleModelPoco>(mapped, paged.GetMetaData());
return vehicleModelsPagedList;
}
public void TestPagingCanBeOmittedForId()
{
IPagingParameters paging = null;
var request = new ReadItemsByIdParameters(this.sessionConfig, this.defaultSource, null, paging, "{item-id}");
string result = this.builderForId.GetUrlForRequest(request);
string expected = "http://tumba.yumba/-/item/v1?sc_itemid=%7bitem-id%7d";
Assert.AreEqual(expected, result);
}
public void TestPagingCanBeOmittedForQuery()
{
IPagingParameters paging = null;
var request = new ReadItemByQueryParameters(this.sessionConfig, this.defaultSource, null, paging, "/root");
string result = this.builderForQuery.GetUrlForRequest(request);
string expected = "http://tumba.yumba/-/item/v1?query=%2froot";
Assert.AreEqual(expected, result);
}
public ReadItemsByIdParameters(
ISessionConfig sessionSettings,
IItemSource itemSource,
IQueryParameters queryParameters,
IPagingParameters pagingSettings,
string itemId)
{
this.SessionSettings = sessionSettings;
this.ItemSource = itemSource;
this.ItemId = itemId;
this.QueryParameters = queryParameters;
this.PagingSettings = pagingSettings;
}
public override IReadItemsByIdRequest Build()
{
IPagingParameters pagingSettings = this.AccumulatedPagingParameters;
ReadItemsByIdParameters result = new ReadItemsByIdParameters(
null,
this.itemSourceAccumulator,
this.queryParameters,
this.icludeStanderdTemplateFields,
this.itemId);
return(result);
}
public ReadItemByQueryParameters(
ISessionConfig sessionSettings,
IItemSource itemSource,
IQueryParameters queryParameters,
IPagingParameters pagingSettings,
string sitecoreQuery)
{
this.SessionSettings = sessionSettings;
this.ItemSource = itemSource;
this.SitecoreQuery = sitecoreQuery;
this.QueryParameters = queryParameters;
this.PagingSettings = pagingSettings;
}
public ReadItemByQueryParameters(
ISessionConfig sessionSettings,
IItemSource itemSource,
IQueryParameters queryParameters,
IPagingParameters pagingSettings,
string sitecoreQuery)
{
this.SessionSettings = sessionSettings;
this.ItemSource = itemSource;
this.SitecoreQuery = sitecoreQuery;
this.QueryParameters = queryParameters;
this.PagingSettings = pagingSettings;
}
private async Task <IPagedList <TaskDTO> > GetTasksListPaged(IPagingParameters pagingParameters, Guid projectId)
{
var sortingParameters = new SortingParameters();
sortingParameters.Add("DateUpdated", false);
var tasks = await taskService.GetTasksPagedAsync(pagingParameters, p => p.ProjectId == projectId, sortingParameters,
this.ToNavPropertyString(nameof(ITaskPoco.AssignedToUser)),
this.ToNavPropertyString(nameof(ITaskPoco.TaskComments)));
var vm = new StaticPagedList <TaskDTO>(Mapper.Map <IEnumerable <TaskDTO> >(tasks.ToList()), pagingParameters.PageNumber, pagingParameters.PageSize, tasks.TotalItemCount);
return(vm);
}
public ReadItemByPathParameters(
ISessionConfig sessionSettings,
IItemSource itemSource,
IQueryParameters queryParameters,
IPagingParameters pagingSettings,
string itemPath)
{
this.SessionSettings = sessionSettings;
this.ItemSource = itemSource;
this.ItemPath = itemPath;
this.QueryParameters = queryParameters;
this.PagingSettings = pagingSettings;
}
public static IPagingParameters FillPagingParameters(this IPagingParameters destination, IPagingResults parameters)
{
if (destination == null)
{
destination = new PagingParameters();
}
destination.PageNumber = parameters.PageNumber;
destination.PageSize = parameters.PageSize;
destination.TotalItems = parameters.TotalItems;
destination.TotalPages = parameters.TotalPages;
return(destination);
}
public override IReadItemsByPathRequest Build()
{
IPagingParameters pagingSettings = this.AccumulatedPagingParameters;
ISessionConfig sessionSettings = null;
var result = new ReadItemByPathParameters(
sessionSettings,
this.itemSourceAccumulator,
this.queryParameters,
pagingSettings,
this.itemPath);
return(result);
}
public IReadItemsByQueryRequest FillReadItemByQueryGaps(IReadItemsByQueryRequest userRequest)
{
IItemSource mergedSource = this.ItemSourceMerger.FillItemSourceGaps(userRequest.ItemSource);
ISessionConfig mergedSessionConfig = this.SessionConfigMerger.FillSessionConfigGaps(userRequest.SessionSettings);
IPagingParameters pagingSettings = userRequest.PagingSettings;
return(new ReadItemByQueryParameters(
mergedSessionConfig,
mergedSource,
userRequest.QueryParameters,
pagingSettings,
userRequest.SitecoreQuery));
}
/// <summary>
/// Gets the <see cref="TEntity"/> queryable.
/// </summary>
/// <param name="pagingParameters">The paging parameters.</param>
/// <param name="filter">The filter expression.</param>
/// <param name="orderBy">The order by.</param>
/// <param name="includeProperties">The include properties.</param>
/// <returns>A query.</returns>
protected virtual IQueryable <TEntity> GetQueryable(
IPagingParameters pagingParameters,
Expression <Func <TModel, bool> > filter = null,
ISortingParameters orderBy = null,
params string[] includeProperties)
{
// AsNoTracking - disable loading of all navigation properties automatically.
IQueryable <TEntity> query = context.Set <TEntity>().AsNoTracking();
// Filtering using Dynamic Linq.
if (filter != null)
{
query = query.Where(DynamicExpressionHandler.GetDynamicQueryString(filter.Body));
}
// Include properties.
if (includeProperties != null && includeProperties.Length > 0)
{
foreach (var item in includeProperties)
{
query = query.Include(item);
}
}
// Order by.
if (orderBy != null && orderBy.Sorters.Count > 0)
{
foreach (var item in orderBy.Sorters)
{
if (item.IsAscending)
{
query = query.OrderBy(item.OrderBy);
}
else
{
query = query.OrderBy(item.OrderBy + " descending");
}
}
}
// Paging.
if (pagingParameters != null)
{
query = query.Skip(pagingParameters.Skip);
query = query.Take(pagingParameters.PageSize);
}
return(query);
}
public override SitecoreSearchParameters Build()
{
IPagingParameters pagingSettings = this.AccumulatedPagingParameters;
//
SitecoreSearchParameters result = new SitecoreSearchParameters(
null,
this.itemSourceAccumulator,
this.queryParameters,
pagingSettings,
null,
this.icludeStanderdTemplateFields,
this.sitecoreQuery);
return(result);
}
// Gets vehicles.
// <param name="paging">Paging.</param>
// <param name="filterVehicle">Filter vehicle.</param>
// <param name="sorting">Sorting.</param>
// <returns>Vehicles.</returns>
public async Task <IEnumerable <IVehicleModel> > GetVehiclesAsync(IPagingParameters paging, IVehicleFilter filterVehicle, ISortingParameters sorting)
{
var listOfVehicles = await vehicleContext.VehicleModels.ToListAsync();
var filteredListOfVehicles = listOfVehicles
.Where(item => String.IsNullOrEmpty(filterVehicle.FindVehicle) ? item != null : item.Name.Contains(filterVehicle.FindVehicle))
.Where(item => filterVehicle.MakeId == Guid.Empty ? item != null : item.VehicleMakeId == filterVehicle.MakeId);
var sortedList = filteredListOfVehicles.OrderBy(sorting.SortField + " " + sorting.SortOrder);
var mappedList = mapper.Map <List <VehicleModelPoco> >(sortedList);
var pagedList = mappedList.ToPagedList(paging.PageNumber, paging.PageSize);
var pagedListOfVehicles = new StaticPagedList <VehicleModelPoco>(pagedList, pagedList.GetMetaData());
return(pagedListOfVehicles);
}
/// <summary>
/// Gets the paged list of <see cref="TEntity" /> asynchronous.
/// </summary>
/// <param name="filter">The filter.</param>
/// <param name="sortingParameters">The sorting parameters.</param>
/// <param name="pagingParameters">The paging parameters.</param>
/// <param name="includeProperties">The include properties.</param>
/// <returns>
/// The paged list of <see cref="!:TEntity" /> paged asynchronous.
/// </returns>
public async Task <IPagedCollection <TEntity> > GetPagedAsync(
Expression <Func <TEntity, bool> > filter = null,
ISortingParameters sortingParameters = null,
IPagingParameters pagingParameters = null,
params string[] includeProperties)
{
_logger.LogDebug("{Method}, {SortingParameters}, {PagingParameters}, {IncludeProperties}", nameof(Repository <TEntity> .GetPagedAsync), sortingParameters, pagingParameters, includeProperties);
// NOTE: EF Core does not support multiple parallel operations being run on the same context instance.
var totalCount = await GetCountAsync();
var result = await GetQueryable(filter, sortingParameters, pagingParameters, includeProperties).ToListAsync();
return(new PagedCollection <TEntity>(result, totalCount, pagingParameters.PageNumber, pagingParameters.PageSize));
}
public ISitecoreSearchRequest FillSitecoreSearchGaps(ISitecoreSearchRequest userRequest)
{
IItemSource mergedSource = this.ItemSourceMerger.FillItemSourceGaps(userRequest.ItemSource);
ISessionConfig mergedSessionConfig = this.SessionConfigMerger.FillSessionConfigGaps(userRequest.SessionSettings);
IPagingParameters pagingSettings = userRequest.PagingSettings;
return(new SitecoreSearchParameters(
mergedSessionConfig,
mergedSource,
userRequest.QueryParameters,
pagingSettings,
userRequest.SortParameters,
userRequest.IncludeStandardTemplateFields,
userRequest.Term));
}
public override ISitecoreStoredSearchRequest Build()
{
IPagingParameters pagingSettings = this.AccumulatedPagingParameters;
StoredSearchParameters result = new StoredSearchParameters(
null,
this.itemSourceAccumulator,
this.queryParameters,
this.AccumulatedPagingParameters,
this.itemId,
this.icludeStanderdTemplateFields,
null);
return(result);
}
private string CreateMatchUrl(string accountId, IPagingParameters parameters, ResourceUriType uriType)
{
var paramsObject = new
{
accountId,
pageSize = parameters.PageSize,
page = uriType switch
{
ResourceUriType.PrevPage => parameters.Page - 1,
ResourceUriType.NextPage => parameters.Page + 1,
_ => parameters.Page
}
};
return(Url.Link("GetMatchesByAccount", paramsObject));
}
public string BuildUrlQueryString(IPagingParameters pagingParameters)
{
if (null == pagingParameters)
{
return null;
}
var invariangCulture = CultureInfo.InvariantCulture;
string strPerPage = pagingParameters.ItemsPerPageCount.ToString(invariangCulture);
string strPageNumber = pagingParameters.PageNumber.ToString(invariangCulture);
string result =
this.webApiGrammar.PageNumberParameterName + this.restGrammar.KeyValuePairSeparator + strPageNumber +
this.restGrammar.FieldSeparator +
this.webApiGrammar.ItemsPerPageParameterName + this.restGrammar.KeyValuePairSeparator + strPerPage;
return result;
}
/// <summary>
/// Asynchronously gets a range of locations.
/// </summary>
/// <param name="paging">A class instance that implements <see cref="IPagingParameters"/>, holds paging data.</param>
/// <returns>Returns <see cref="Task{IPagedList{ILocation}}"/></returns>
public static Task<IPagedList<ILocation>> GetAsync(this ILocationService locationService, IPagingParameters paging)
{
return locationService.GetAsync(paging, null, null);
}
/// <summary>
/// Gets all or filtered vehicleMakes.
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
public virtual async Task<IEnumerable<IVehicleMake>> GetAsync(IPagingParameters pagingParameters, ISortingParameters sortingParameters, IFilter filter)
{
return await Repository.GetAsync(pagingParameters, sortingParameters, filter);
}
/// <summary>
/// Asynchronously gets a range of locations which names contain the string given by the filter object.
/// </summary>
/// <param name="filter">Filter instance of type <see cref="IFilter"/></param>
/// <param name="paging">A class instance that implements <see cref="IPagingParameters"/>, holds paging data.</param>
/// <returns>Returns <see cref="Task{IPagedList{ILocation}}"/></returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="paging"/> is null.</exception>
public async Task<IPagedList<ILocation>> GetAsync(IPagingParameters paging, ISortingParameters sorting, IFilter filter)
{
if (paging == null)
{
throw new ArgumentNullException("paging");
}
if (sorting == null)
{
IList<ISortingPair> sortPair = new List<ISortingPair>()
{
new SortingPair("Name")
};
sorting = new SortingParameters(sortPair);
}
var query = repository.GetAll<LocationEntity>()
.OrderBy(sorting.GetJoinedSortExpressions());
if(filter != null && !string.IsNullOrEmpty(filter.SearchString))
{
query = query.Where(e => e.Name.ToLower().Contains(filter.SearchString.ToLower()));
}
return Mapper.Map<IPagedList<ILocation>>(await query.ToPagedListAsync(paging.PageNumber, paging.PageSize));
}
/// <summary>
/// Asynchronously gets a list of locations.
/// </summary>
/// <param name="paging">An instance of <see cref="IPagingParameters"/>, provides paging options.</param>
/// <returns>Returns <see cref="Task{IEnumerable{ILocation}}"/></returns>
public static Task<IPagedList<ILocation>> GetAsync(this ILocationRepository repository, IPagingParameters paging)
{
return repository.GetAsync(paging, null, null);
}