private IEnumerable <T> SortAndReturn <T>(IEnumerable <T> source,
SortingParams sortingParams)
{
return(!string.IsNullOrEmpty(sortingParams.SortBy)
? source.AsQueryable().Sort(sortingParams.SortBy)
: source);
}
public async Task <IActionResult> GetBook(SortingParams sortingParams)
{
var sortingBy = sortingParams.FieldName.Trim().ToLowerInvariant();
if (string.IsNullOrEmpty(sortingBy))
{
return(BadRequest());
}
var field = typeof(Book).GetProperty(sortingBy);
List <Book> books;
if (sortingParams.Ascending)
{
books = await _context.Book.OrderBy(x => field.GetValue(x, null)).ToListAsync();
}
else
{
books = await _context.Book.OrderByDescending(x => field.GetValue(x, null)).ToListAsync();
}
if (books.Count() == 0)
{
return(NotFound());
}
return(Ok(books));
}
public static string ToSortedResult <T>(this string query, SortingParams sortingParams)
{
if (query.Contains("ROW FETCH NEXT"))
{
throw new Exception("Pagination can't applied before sorting");
}
if (query.Contains("ORDER BY"))
{
throw new NotSupportedException("Multiple Sorting Not Supported");
}
if (sortingParams == null || string.IsNullOrWhiteSpace(sortingParams.ColumnName))
{
return(query);
}
PropertyInfo sortColumn = typeof(T).GetProperty(sortingParams.ColumnName);
if (sortColumn == null)
{
throw new Exception($"{sortingParams} not exist in {typeof(T).GetType().Name}");
}
return(new StringBuilder(query)
.Append($"ORDER BY {sortingParams.ColumnName} ")
.Append($"{sortingParams.GetSqlOrderName()}")
.Append("\n")
.ToString());
}
public ActionResult <string> Sort([FromBody] SortingParams sortingParams)
{
string[] strings = sortingParams.Input.Split(',');
List <(int, int)> result = sortingParams.Type == "Integer"
? Bubble(strings.Select(Int64.Parse).ToArray())
: Bubble(strings);
return(JsonConvert.SerializeObject(result));
}
public IActionResult WeatherForecasts(
[FromQuery] int pageNumber,
[FromQuery] int pageSize,
[FromQuery] SortingParams sortingParams,
[FromQuery] string groupExpression)
{
var items = staticRepositoryCollections.Forecasts.Values.AsQueryable();
if (string.IsNullOrEmpty(groupExpression))
{
return(WeatherForecasts(pageNumber, pageSize, sortingParams));
}
else
{
var param = Expression.Parameter(typeof(WeatherForecast));
var property = Expression.PropertyOrField(param, groupExpression);
var keyPropertyConstructors = typeof(KeyProperty).GetConstructors();
var newExpr = Expression.New(keyPropertyConstructors.FirstOrDefault(c => c.GetParameters()[0].ParameterType == property.Type)
, property);
var lambda = Expression.Lambda <Func <WeatherForecast, KeyProperty> >(newExpr, param);
var groupedItemsAfterGrouping = items.GroupBy(lambda)
.Select(grp => new GroupItem <WeatherForecast>(grp.Key.Key, grp.ToList()));
var groupedItemsAfterPaging = groupedItemsAfterGrouping
.Skip(pageSize * pageNumber)
.Take(pageSize);
var groupedItemsAfterSorting = new List <GroupItem <WeatherForecast> >();
var sortExp = sortingParams?.SortExpression;
if (!string.IsNullOrEmpty(sortExp))
{
if (sortingParams.SortDescending)
{
sortExp += " descending";
}
foreach (var groupItem in groupedItemsAfterPaging)
{
groupedItemsAfterSorting.Add(new GroupItem <WeatherForecast>(groupItem.Key,
groupItem.Items.AsQueryable().OrderBy(sortExp)));
}
}
else
{
groupedItemsAfterSorting = groupedItemsAfterPaging.ToList();
}
return(Ok(new
{
Items = groupedItemsAfterSorting.SelectMany(grp => grp.Items),
TotalCount = groupedItemsAfterGrouping.Count()
}));
}
}
public IActionResult Get(SortingParams sortingParams)
{
var model = _service.GetMovies(sortingParams);
var outputModel = new MovieOutputModel
{
Items = model.Select(m => ToMovieInfo(m)).ToList(),
};
return(Ok(outputModel));
}
public List <Movie> GetMovies(SortingParams sortingParams)
{
var query = this.movies.AsQueryable();
if (!string.IsNullOrEmpty(sortingParams.SortBy))
{
query = query.Sort(sortingParams.SortBy);
}
return(query.ToList());
}
public IEnumerable <DocFileSummaryDto> GetDocumentsSummary(SortingParams sortingParams)
{
var documentSummaryList = _fileDBContext.DocFile.Select(f => new DocFileSummaryDto()
{
Filesize = f.Filesize,
Name = f.Name,
Id = f.Id
}).OrderBy(sortingParams.SortBy);
return(documentSummaryList);
}
public async Task <IEnumerable <StudentDto> > GetAllAsync(SortingParams param = null)
{
var result = Enumerable.Empty <StudentDto>();
if (param != null)
{
result = await Sort(param).ToListAsync();
}
else
{
result = await GetQueryable().ToListAsync();
}
return(result);
}
public async Task <IActionResult> GetModels([FromQuery] VehicleParams vehicleModelParams)
{
var page = new PagingParams(vehicleModelParams.PageNumber, vehicleModelParams.PageSize);
var filter = new FilteringParams(vehicleModelParams.Search, vehicleModelParams.MakeId ?? Guid.Empty);
var sort = new SortingParams(vehicleModelParams.SortBy);
var models = await modelService.FindModelAsync(filter, sort, page);
var modelsDto = models.ToMappedPagedList <IVehicleModel, VehicleModelDto>(mapper);
Response.AddPagination(models.PageNumber, models.PageSize, models.TotalItemCount, models.PageCount);
return(Ok(modelsDto));
}
private IQueryable <StudentDto> Sort(SortingParams param)
{
var query = GetQueryable();
ParameterExpression parameter = Expression.Parameter(query.ElementType, "x");
MemberExpression property = Expression.Property(parameter, param.SortBy);
LambdaExpression lambda = Expression.Lambda(property, parameter);
string methodName = param.IsAscending ? "OrderBy" : "OrderByDescending";
Expression methodCallExpression = Expression.Call(typeof(Queryable), methodName,
new Type[] { query.ElementType, property.Type },
query.Expression, Expression.Quote(lambda));
var sqlString = query.ToQueryString();
return(query.Provider.CreateQuery <StudentDto>(methodCallExpression).AsNoTracking());
}
public IActionResult Orders(int customerId, int pageNumber, int pageSize, SortingParams sortingParams)
{
var customerOrders = staticRepositoryCollections.Orders.Where(o => o.CustomerId == customerId);
var pageableCustomerOrders = customerOrders
.Skip(pageSize * pageNumber)
.Take(pageSize)
.ToList();
return(Ok(new
{
Items = pageableCustomerOrders,
TotalCount = customerOrders.Count()
}));
}
public async Task <IActionResult> GetAll(
[FromQuery] UrlQueryParameters urlQueryParameters,
[FromQuery] SortingParams sorting)
{
PaginationViewModel <StudentDto> viewmodel;
if (sorting != null && !string.IsNullOrEmpty(sorting.SortBy))
{
viewmodel = await _studentQueries.PaginationAsync(urlQueryParameters.Limit, urlQueryParameters.Page, CancellationToken.None, sorting);
}
else
{
viewmodel = await _studentQueries.PaginationAsync(urlQueryParameters.Limit, urlQueryParameters.Page, CancellationToken.None);
}
// viewmodel=GeneratePageLinks(urlQueryParameters, viewmodel);
return(Ok(GeneratePageLinks(urlQueryParameters, viewmodel)));
}
public IActionResult WeatherForecasts(int pageNumber, int pageSize, SortingParams sortingParams)
{
var items = staticRepositoryCollections.Forecasts
.Skip(pageSize * pageNumber)
.Take(pageSize);
items = string.IsNullOrEmpty(sortingParams.SortExpression)
? items
: items.AsQueryable().OrderBy(sortingParams.SortExpression).ToList();
return(Ok(
new
{
Items = items,
TotalCount = 100
}));
}
public async Task <IActionResult> GetMakers([FromQuery] VehicleParams vehicleMakeParams)
{
try
{
var page = new PagingParams(vehicleMakeParams.PageNumber, vehicleMakeParams.PageSize);
var filter = new FilteringParams(vehicleMakeParams.Search);
var sort = new SortingParams(vehicleMakeParams.SortBy);
var makers = await makeService.FindMakeAsync(filter, sort, page);
var mapped = mapper.Map <IEnumerable <VehicleMakeDto> >(makers);
Response.AddPagination(makers.PageNumber, makers.PageSize, makers.TotalItemCount, makers.PageCount);
return(Ok(mapped));
}
catch (Exception)
{
return(NotFound());
}
}
public IActionResult WeatherForecasts(int pageNumber, int pageSize, SortingParams sortingParams)
{
var rng = new Random();
var items = Enumerable.Range(1, 100).Skip(pageSize * pageNumber).Take(pageSize).Select(index =>
new WeatherForecast
{
Date = DateTime.Now.AddDays(index),
TemperatureC = rng.Next(-20, 55),
Summary = Summaries[rng.Next(Summaries.Length)]
});
items = string.IsNullOrEmpty(sortingParams.SortExpression)
? items
: items.AsQueryable().OrderBy(sortingParams.SortExpression).ToList();
return(Ok(
new
{
Items = items,
TotalCount = 100
}));
}
public IActionResult WeatherForecasts(
[FromQuery] int pageNumber,
[FromQuery] int pageSize,
[FromQuery] SortingParams sortingParams)
{
var items = staticRepositoryCollections.Forecasts.Values.AsQueryable();
var sortExp = sortingParams?.SortExpression;
if (!string.IsNullOrEmpty(sortExp))
{
if (sortingParams.SortDescending)
{
sortExp += " descending";
}
items = items.OrderBy(sortExp);
}
return(Ok(new
{
Items = items.Skip(pageSize * pageNumber).Take(pageSize),
TotalCount = staticRepositoryCollections.Forecasts.Count
}));
}
public async Task <PaginationViewModel <StudentDto> > PaginationAsync(int limit, int page, CancellationToken cancellationToken, SortingParams param = null)
{
var students = (param == null) ?
await GetQueryable().PaginationAsync(page, limit, cancellationToken) :
await Sort(param).AsNoTracking().PaginationAsync(page, limit, cancellationToken);
return(new PaginationViewModel <StudentDto>()
{
CurrentPage = students.CurrentPage,
TotalPages = students.TotalPages,
TotalItems = students.TotalItems,
Items = students.Items
});
}
public IEnumerable <Game> Get(string username, SortingParams sortingParams = null) => this.SortAndReturn <Game>(_games.Where(x => x.Username == username), sortingParams);
// GET api/games public IEnumerable <Game> Get(SortingParams sortingParams = null) => this.SortAndReturn <Game>(_games, sortingParams);
public IActionResult GetDocuments([FromQuery] SortingParams sortParams)
{
var documents = _documentService.GetDocumentsSummary(sortParams);
return(Ok(documents));
}
