public async Task <ViewResult> Boards(PagingParams pagingParams)
{
var boardModels = await Mediator.Send(new GetBoardsWithPaginationQuery(pagingParams));
var viewModel = new HomeBoardsViewModel {
BoardPage = new FrontendPage <GetBoardModel>(boardModels)
};
return(View(viewModel));
}
public ActionResult Index(PagingParams args, FilterBarMode? Mode, bool? ShowStatusBar)
{
IList<Conference> conferences = null;
using (var context = new OfficeContext())
{
conferences = context.Conferences.ToList();
}
return conferences.GridJSONActions<Conference>();
}
public PagedList <RoleModel> GetAll(PagingParams pagingParams)
{
DisplayRoles displayRoles = new DisplayRoles();
displayRoles.objUser = this.objUser;
var query = new List <RoleModel>((List <RoleModel>)displayRoles.Display()).AsQueryable();
var filter = query.Where(p => p.role_name.StartsWith(pagingParams.Query ?? String.Empty, StringComparison.InvariantCultureIgnoreCase));
return(new PagedList <RoleModel>(filter, pagingParams.PageNumber, pagingParams.PageSize));
}
public async Task <IActionResult> Index(PagingParams pagingParams)
{
var articles = await Mediator.Send(new GetArticlesWithPaginationQuery(pagingParams));
var viewModel = new HomeIndexViewModel {
ArticlePage = new FrontendPage <GetArticleModel>(articles)
};
return(View(viewModel));
}
public async Task <PagedList <ProductSellListDto> > GetPagedProductsAsync(
PagingParams pagingParams, SortParams sortParams, string filter)
{
var source = _context.Set <ProductSell> ()
.AsNoTracking()
.ProjectToType <ProductSellListDto> ();
switch (sortParams.SortOrder)
{
case "asc":
switch (sortParams.SortColumn)
{
case "productName":
source = source.OrderBy(p => p.ProductName);
break;
case "specification":
source = source.OrderBy(p => p.Specification);
break;
case "categoryName":
source = source.OrderBy(p => p.CategoryName);
break;
}
break;
case "desc":
switch (sortParams.SortColumn)
{
case "productName":
source = source.OrderByDescending(p => p.ProductName);
break;
case "specification":
source = source.OrderByDescending(p => p.Specification);
break;
case "categoryName":
source = source.OrderByDescending(p => p.CategoryName);
break;
}
break;
default:
source = source.OrderBy(c => c.ProductName);
break;
}
if (!string.IsNullOrEmpty(filter))
{
source = source.Where(p => (p.ProductName + p.CategoryName).ToLower().Contains(filter.ToLower()));
}
return(await PagedList <ProductSellListDto> .CreateAsync(source, pagingParams.PageIndex, pagingParams.PageSize));
}
public async Task <PagedList <Supplier> > GetAllPagingAsync(PagingParams pagingParams)
{
IQueryable <Supplier> _query = from u in _context.Suppliers
orderby u.Name
select new Supplier {
Id = u.Id, Name = u.Name, Diachi = u.Diachi, Sdt = u.Sdt
};
// Search
if (pagingParams.SearchValue == "name")
{
if (string.IsNullOrEmpty(pagingParams.SearchKey) == false)
{
_query = _query.Where(o => o.Name.Contains(pagingParams.SearchKey));
}
}
if (pagingParams.SearchValue == "id")
{
if (string.IsNullOrEmpty(pagingParams.SearchKey) == false)
{
int _id = Convert.ToInt32(pagingParams.SearchKey);
_query = _query.Where(o => o.Id == _id);
}
}
//Sort
if (pagingParams.SortKey == "name")
{
if (pagingParams.SortValue == "ascend")
{
_query = _query.OrderBy(o => o.Name);
}
else
{
_query = _query.OrderByDescending(o => o.Name);
}
}
if (pagingParams.SortKey == "id")
{
if (pagingParams.SortValue == "ascend")
{
_query = _query.OrderBy(o => o.Id);
}
else
{
_query = _query.OrderByDescending(o => o.Id);
}
}
return(await PagedList <Supplier>
.CreateAsync(_query, pagingParams.PageNumber, pagingParams.PageSize));
}
public PagedList <Z_Consultant_Comment> GetCommentsByPostId(PagingParams pagingParams, int postId)
{
var query = _commentRepository.TableNoTracking
.Include(c => c.Customer).Include(c => c.Consultant)
.Where(c => c.PostId == postId)
.OrderBy(c => c.DateCreated);
query = query.OrderBy(c => c.DateCreated);
return(new PagedList <Z_Consultant_Comment>(
query, pagingParams.PageNumber, pagingParams.PageSize, true));
}
public async Task <IActionResult> Get([FromQuery] PagingParams pagingParams,
[FromQuery] ContractorsListFilter filter)
{
var query = new GetContractorsListQuery
{
ContractorsListFilter = filter,
PagingParams = pagingParams
};
return(await HandleQueryWithPagingAsync(query));
}
public Threenine.Data.Paging.IPaginate <Enquiry> Booked(int PageNumber = 0, int PageSize = 30)
{
PagingParams pagingParams = new PagingParams();
pagingParams.PageNumber = PageNumber;
pagingParams.PageSize = PageSize;
_reqinfo.UserId = Request.Headers["UserId"].ToString();
_reqinfo.BranchId = Request.Headers["BranchId"].ToString();
_reqinfo.DeviceId = Request.Headers["DeviceId"].ToString();
return(_BookingService.GetAllBooked(pagingParams));
}
public EnquiriesBookingListViewModel()
{
var Scope = Startup.Instance.provider.CreateScope();
_repository = Scope.ServiceProvider.GetRequiredService <IBookingService>();
pagingParams = new PagingParams();
pagingParams.PageNumber = 0;
pagingParams.PageSize = 50;
_enquiries = _repository.GetAllBooked(pagingParams);
WireCommands();
}
public async Task <PagedList <Job> > GetJobsByDate(int userId, PagingParams jobParams, string machType)
{
var jobs = _context.Jobs
.Where(j => j.userId == userId)
.Where(j => j.Active == "Active")
.Where(j => j.MachType == machType);
var jobsForReturn = jobs.OrderBy(j => j.DeliveryDate);
return(await PagedList <Job> .CreateAsync(jobsForReturn, jobParams.PageNumber, jobParams.PageSize));
}
public async Task <IEnumerable <Product> > GetProductsWithTypeAsync(PagingParams pagingParams)
{
var products = _context.Products.Include(t => t.ProductType).AsQueryable();
if (!string.IsNullOrEmpty(pagingParams.ProductType))
{
products = products.Where(p => p.ProductType.Name == pagingParams.ProductType);
}
return(await PagedList <Product> .CreateAsync(products, pagingParams.Number, pagingParams.PageSize));
}
public PagedList(IQueryable<T> source, PagingParams pagingParams)
{
TotalItems = source.Count();
PageNumber = pagingParams.PageNumber;
PageSize = pagingParams.PageSize;
List = source
.ApplyOrderBy(pagingParams.SortProperty, pagingParams.SortType)
.Skip(pagingParams.PageSize * (pagingParams.PageNumber - 1))
.Take(pagingParams.PageSize)
.ToList();
}
public async Task <IEnumerable <Device> > GetDevicesWithTypeAsync(PagingParams pagingParams)
{
var devices = _context.Devices.Include(x => x.DeviceType)
.ThenInclude(x => x.DeviceTypeProperties)
.ThenInclude(x => x.DevicePropertyValue).AsQueryable();
DeviceSearchService deviceSearchService = new DeviceSearchService();
var result = deviceSearchService.GetDevicesByParams(devices, pagingParams);
return(await PagedList <Device> .CreateAsync(result, pagingParams.PageNumber, pagingParams.PageSize));
}
GetSeriesLikedList(Viewer viewer, PagingParams pagingParams)
{
var seriesLikedQuery = _context.SeriesLiked
.Where(sw => sw.ViewerId == viewer.ViewerId)
.ProjectTo <SeriesLikedListDto>(_mapper.ConfigurationProvider);
var pagedList = await PagedList <SeriesLikedListDto>
.CreateAsync(seriesLikedQuery, pagingParams.PageNumber, pagingParams.PageSize);
return(pagedList);
}
public async Task <ActionResult <PagedList <PostDownloadDTO> > > GetPosts([FromQuery] PagingParams pagingParams)
{
var query = _context.Posts
.ProjectTo <PostDownloadDTO>(_mapper.ConfigurationProvider)
.OrderByDescending(x => x.CreatedAt)
.AsQueryable();
return(HandlePagedResult <PostDownloadDTO>(
await PagedList <PostDownloadDTO> .CreateAsync(query, pagingParams.PageNumber, pagingParams.PageSize)
));
}
public async Task <PagedList <EmployeeListDto> > GetPagedEmployeeAsync(PagingParams pagingParams, SortParams sortParams, string filter)
{
var source = _repository
.AsNoTracking()
.ProjectToType <EmployeeListDto>();
switch (sortParams.SortOrder)
{
case "asc":
switch (sortParams.SortColumn)
{
case "fullName":
source = source.OrderBy(e => e.FullName);
break;
case "dateOfBirth":
source = source.OrderBy(e => e.DateOfBirth);
break;
case "countryName":
source = source.OrderBy(e => e.CountryName);
break;
}
break;
case "desc":
switch (sortParams.SortColumn)
{
case "fullName":
source = source.OrderByDescending(e => e.FullName);
break;
case "dateOfBirth":
source = source.OrderByDescending(e => e.DateOfBirth);
break;
case "countryName":
source = source.OrderByDescending(e => e.CountryName);
break;
}
break;
default:
source = source.OrderBy(e => e.FullName);
break;
}
if (!string.IsNullOrEmpty(filter))
{
source = source.Where(s => s.FullName.ToLower().Contains(filter.ToLower()));
}
return(await PagedList <EmployeeListDto> .CreateAsync(source, pagingParams.PageIndex, pagingParams.PageSize));
}
public async Task GetDevices_ShouldReturnNotNull()
{
PagingParams pagingParams = new PagingParams()
{
PageSize = 2
};
var result = await _devicesController.GetDevices(pagingParams);
Assert.NotNull(result);
}
public async Task <ActionResult <IEnumerable <ProfileDTO> > > Get([FromQuery] PagingParams pagingParams)
{
var query = _context.Users
.OrderByDescending(user => user.CreatedAt)
.ProjectTo <ProfileDTO>(_mapper.ConfigurationProvider)
.AsQueryable();
return(HandlePagedResult <ProfileDTO>(
await PagedList <ProfileDTO> .CreateAsync(query, pagingParams.PageNumber, pagingParams.PageSize)
));
}
public async Task <IActionResult> GetBlockchainProposals([FromQuery] PagingParams pagingParams)
{
var result = await this.BlockchainService.GetPagedProposals(pagingParams);
if (result == null)
{
return(BadRequest());
}
Response.AddPagination(result.CurrentPage, result.PageSize, result.TotalCount, result.TotalPages);
return(Ok(result));
}
public ActionResult Index(PagingParams args, FilterBarMode?Mode, bool?ShowStatusBar)
{
IList <Conference> conferences = null;
using (var context = new OfficeContext())
{
conferences = context.Conferences.ToList();
}
return(conferences.GridJSONActions <Conference>());
}
public List <Z_Harag_Post> GetLatestPosts(PagingParams pagingParams)
{
return(_postRepository.TableNoTracking
.Include(m => m.Category)
.Include(m => m.Customer)
.Include(m => m.City)
.Include(m => m.Z_Harag_Photo)
.Include(m => m.Z_Harag_Comment).Where(m => m.IsDeleted == false).OrderByDescending(r => r.DateCreated)
.OrderByDescending(mbox => mbox.DateUpdated).OrderByDescending(mbox => mbox.IsFeatured).Skip(pagingParams.PageNumber * pagingParams.PageSize)
.Take(pagingParams.PageSize).ToList());
}
public async Task <PaginationResult <City> > GetAllCitiesAsync(PagingParams pagingParams,
string sortColumn = null,
string sortOrder = null,
string filterColumn = null,
string filterQuery = null)
{
var queryableCity = _worldDbContext.Cities.AsQueryable();
return(await queryableCity.Include(c => c.Country).GetPagedResultAsync(pagingParams.PageNumber,
pagingParams.PageSize, sortColumn, sortOrder, filterColumn, filterQuery));
}
public async Task <IActionResult> GetProposalPayments([FromQuery] PagingParams pagingParams)
{
var result = await this.ProposalPaymentsService.GetPaged(pagingParams);
if (result == null)
{
return(NotFound());
}
Response.AddPagination(result.CurrentPage, result.PageSize, result.TotalCount, result.TotalPages);
return(Ok(result));
}
public PagedList <CategoryModel> GetAllCategoryParent(PagingParams pagingParams)
{
DisplayCategory category = new DisplayCategory();
category.objUser = this.objUser;
var query = new List <CategoryModel>((List <CategoryModel>)category.DisplayCategoryParent()).AsQueryable();
IQueryable <CategoryModel> filter;
filter = query.Where(p => p.category_name.StartsWith(pagingParams.Query ?? string.Empty, StringComparison.InvariantCultureIgnoreCase));
return(new PagedList <CategoryModel>(filter, pagingParams.PageNumber, pagingParams.PageSize));
}
ListSeriesReviews(int seriesId, [FromQuery] PagingParams pagingParams)
{
var series = await _reviewService.GetSeries(seriesId);
if (series is Series)
{
var reviews = await _reviewService.GetSeriesReviews(series, pagingParams);
return(Ok(reviews));
}
return(NotFound());
}
public async Task <PaginationResult <Country> > GetCountriesAsync(
PagingParams pagingParams,
string sortColumn = null,
string sortOrder = null,
string filterColumn = null,
string filterQuery = null)
{
var querableCountry = _contect.Countries.AsQueryable();
return(await querableCountry.GetPagedResultAsync(pagingParams.PageNumber, pagingParams.PageSize, sortColumn, sortOrder, filterColumn
, filterQuery));
}
public void GetDevicesByParams_ShouldReturnNotEqual()
{
PagingParams pagingParams = new PagingParams()
{
DeviceType = "Laptop"
};
var deviceSearchService = new DeviceSearchService();
var devices = deviceSearchService.GetDevicesByParams(_devicesList.AsQueryable(), pagingParams);
Assert.NotEqual(2, devices.Count());
}
public async Task <LimitV1> GetOneByUserIdAsync(string correlationId, string userId)
{
var filter = new FilterParams();
var paging = new PagingParams();
filter.Add("user_id", userId);
var result = await GetPageByFilterAsync(correlationId, ComposeFilter(filter), paging);
var data = result.Data.ConvertAll <LimitV1>(x => ToPublic(x));
return(data[0]);
}
public async Task <IActionResult> GetFiltered([FromBody] UserFilterAdminDto filter)
{
// Check if valid user
var currentUser = await _identityService.GetCurrentPersonIdentityAsync();
if (currentUser == null)
{
return(BadRequest(new RequestMessageResponse()
{
Success = false, Message = "Forbidden"
}));
}
// Create pager
PagingParams pager = new PagingParams();
pager.PageNumber = filter.PageNumber;
pager.PageSize = filter.PageSize;
// Get filtered list from dB
var usersList = _userService.GetAllUsersPagedList(pager, filter.Email, filter.UserName, filter.Firstname, filter.Lastname);
// Get roles
var rolesList = await _userService.GetAllRolesAsync();
// Map entitites to dto
IList <UserSmallAdminDto> userSmallDtos = new List <UserSmallAdminDto>();
foreach (var user in usersList.List)
{
UserSmallAdminDto smallModel = new UserSmallAdminDto()
{
Id = user.Id,
Email = user.Email,
EmailConfirmed = user.EmailConfirmed,
Firstname = user.Firstname,
Lastname = user.Lastname,
CreatedOnUtc = user.CreatedOnUtc.ToShortDateString(),
Role = rolesList[user.UserRoles[0].RoleId].Name
};
userSmallDtos.Add(smallModel);
}
// Initialize result
PagedListDto <UserSmallAdminDto> returnDto = new PagedListDto <UserSmallAdminDto>();
returnDto.PagingHeader = usersList.GetHeader();
returnDto.List = userSmallDtos;
// Return result
return(new OkObjectResult(returnDto));
}
public List <Z_Harag_Post> GetUserPosts(int userId, PagingParams pagingParams)
{
var query = _postRepository.TableNoTracking
.Include(m => m.Category)
.Include(m => m.Customer)
.Include(m => m.City)
.Include(m => m.Z_Harag_Photo)
.Include(m => m.Z_Harag_Comment)
.Where(c => c.CustomerId == userId && c.IsDeleted == false).OrderByDescending(mbox => mbox.DateUpdated).Skip(pagingParams.PageNumber * pagingParams.PageSize)
.Take(pagingParams.PageSize).ToList();
return(query);
}
