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)); }