private static void ApplySorting(CollectionRequestModel model, SearchQuery <UserEntity> query)
{
if (!string.IsNullOrEmpty(model.Sort))
{
query.AddSortCriteria(FiltrationHelper.GetSorting <UserEntity>(model.Sort));
}
else
{
query.AddSortCriteria(new FieldSortOrder <UserEntity>("Name", SortDirection.Ascending));
}
}
public Task <DataResult <IPagedListResult <DTOCustomerExchange> > > GetCustomersLookupWithPagingAsync(List <Expression <Func <CustomerExchange, bool> > > searchTerm,
string sortName, string sortDirection, int pageIndex, int pageSize,
CancellationToken cancellationToken = default(CancellationToken))
{
return(Task.Run(() =>
{
var searchQuery = new SearchQuery <CustomerExchange>();
searchQuery.CurrentPage = pageIndex;
searchQuery.Skip = pageSize * (pageIndex - 1);
searchQuery.Take = pageSize;
searchQuery.IncludeProperties = "Car,Customer";
var sort = new FieldSortCriteria <CustomerExchange>(sortName, (SortDirection)Enum.Parse(typeof(SortDirection), sortDirection));
searchQuery.AddSortCriteria(sort);
foreach (var searchCondition in searchTerm)
{
searchQuery.AddFilter(searchCondition);
}
var pagedCustomerWithCar = customerExchangeRepository.Search(searchQuery);
var pagedCustomerWithCarDTOs = GetDefaultPagingDtoResult <DTOCustomerExchange, CustomerExchange>(_mapper, pagedCustomerWithCar);
// Mapping customer, car and quotations to DTO
pagedCustomerWithCarDTOs.DTOs = MappingCustomerAndCarDTO(pagedCustomerWithCar.DTOs.ToList(), pagedCustomerWithCarDTOs.DTOs.ToList());
return new DataResult <IPagedListResult <DTOCustomerExchange> >
{
Errors = new List <ErrorDescriber>(),
Target = pagedCustomerWithCarDTOs
};
}, cancellationToken));
}
public Task <DataResult <IPagedListResult <DTOCustomer> > > GetCustomersWithPagingAsync(string searchTerm, string sortName, string sortDirection, int pageIndex, int pageSize,
CancellationToken cancellationToken = default(CancellationToken))
{
return(Task.Run(() => {
var searchQuery = new SearchQuery <Customer>();
searchQuery.CurrentPage = pageIndex;
searchQuery.Skip = pageSize * (pageIndex - 1);
searchQuery.Take = pageSize;
searchQuery.IncludeProperties = "Branch,CustomerType";
var sort = new FieldSortCriteria <Customer>(sortName, (SortDirection)Enum.Parse(typeof(SortDirection), sortDirection));
searchQuery.AddSortCriteria(sort);
if (!string.IsNullOrEmpty(searchTerm))
{
searchQuery.AddFilter(x => x.Name.Contains(searchTerm) ||
x.Phone.Contains(searchTerm) ||
x.Id.Contains(searchTerm));
}
var pagedCustomers = customerRepository.Search(searchQuery);
return new DataResult <IPagedListResult <DTOCustomer> >
{
Errors = new List <ErrorDescriber>(),
Target = GetDefaultPagingDtoResult <DTOCustomer, Customer>(_mapper, pagedCustomers)
};
}, cancellationToken));
}
public Task <DataResult <IPagedListResult <DTOQuotationItem> > > GetQuotationItemsWithPagingAsync(string quotationId, string searchTerm, string sortName, string sortDirection, int pageIndex, int pageSize,
CancellationToken cancellationToken = default(CancellationToken))
{
return(Task.Run(() =>
{
var searchQuery = new SearchQuery <QuotationItem>();
searchQuery.CurrentPage = pageIndex;
searchQuery.Skip = pageSize * (pageIndex - 1);
searchQuery.Take = pageSize;
searchQuery.IncludeProperties = "Quotation,Accessary,Accessary.Unit,Service,Service.Unit,Employee";
var sort = new FieldSortCriteria <QuotationItem>(sortName, (SortDirection)Enum.Parse(typeof(SortDirection), sortDirection));
searchQuery.AddSortCriteria(sort);
searchQuery.AddFilter(x => x.QuotationId == quotationId);
if (!string.IsNullOrEmpty(searchTerm))
{
searchQuery.AddFilter(x => x.Service.Name.Contains(searchTerm) || x.Accessary.Name.Contains(searchTerm));
}
var pagedQuotationItems = _unitOfWork.GetRepository <QuotationItem>().Search(searchQuery);
return new DataResult <IPagedListResult <DTOQuotationItem> >
{
Errors = new List <ErrorDescriber>(),
Target = GetDefaultPagingDtoResult <DTOQuotationItem, QuotationItem>(_mapper, pagedQuotationItems)
};
}, cancellationToken));
}
public Task <DataResult <IPagedListResult <DTOManufacturer> > > GetManufacturersWithPagingAsync(string searchTerm, string sortName, string sortDirection, int pageIndex, int pageSize, CancellationToken cancellationToken = default(CancellationToken))
{
return(Task.Run(() => {
var searchQuery = new SearchQuery <Manufacturer>();
searchQuery.CurrentPage = pageIndex;
searchQuery.Skip = pageSize * (pageIndex - 1);
searchQuery.Take = pageSize;
var sort = new FieldSortCriteria <Manufacturer>(sortName, (SortDirection)Enum.Parse(typeof(SortDirection), sortDirection));
searchQuery.AddSortCriteria(sort);
if (!string.IsNullOrEmpty(searchTerm))
{
searchQuery.AddFilter(x => x.Name.Contains(searchTerm) || x.Description.Contains(searchTerm));
}
var pagedManufacturers = _unitOfWork.GetRepository <Manufacturer>().Search(searchQuery);
return new DataResult <IPagedListResult <DTOManufacturer> >
{
Errors = new List <ErrorDescriber>(),
Target = GetDefaultPagingDtoResult <DTOManufacturer, Manufacturer>(_mapper, pagedManufacturers)
};
}, cancellationToken));
}
public Task <DataResult <IPagedListResult <DTOQuotation> > > GetQuotationsLookupWithPagingAsync(List <Expression <Func <Quotation, bool> > > searchTerm,
string sortName, string sortDirection, int pageIndex, int pageSize,
CancellationToken cancellationToken = default(CancellationToken))
{
return(Task.Run(() =>
{
var searchQuery = new SearchQuery <Quotation>();
searchQuery.CurrentPage = pageIndex;
searchQuery.Skip = pageSize * (pageIndex - 1);
searchQuery.Take = pageSize;
searchQuery.IncludeProperties = "Branch,Status,CustomerExchange,CustomerExchange.Customer,CustomerExchange.Car";
var sort = new FieldSortCriteria <Quotation>(sortName, (SortDirection)Enum.Parse(typeof(SortDirection), sortDirection));
searchQuery.AddSortCriteria(sort);
foreach (var searchCondition in searchTerm)
{
searchQuery.AddFilter(searchCondition);
}
var pagedQuotations = _unitOfWork.GetRepository <Quotation>().Search(searchQuery);
return new DataResult <IPagedListResult <DTOQuotation> >
{
Errors = new List <ErrorDescriber>(),
Target = GetDefaultPagingDtoResult <DTOQuotation, Quotation>(_mapper, pagedQuotations)
};
}, cancellationToken));
}
public Task <DataResult <IPagedListResult <DTOPaySlipBill> > > GetPayslipsWithPagingAsync(string searchTerm, string sortName, string sortDirection, int pageIndex, int pageSize,
CancellationToken cancellationToken = default(CancellationToken))
{
return(Task.Run(() => {
var searchQuery = new SearchQuery <PaySlipBill>();
searchQuery.CurrentPage = pageIndex;
searchQuery.Skip = pageSize * (pageIndex - 1);
searchQuery.Take = pageSize;
searchQuery.IncludeProperties = "Quotation";
var sort = new FieldSortCriteria <PaySlipBill>(sortName, (SortDirection)Enum.Parse(typeof(SortDirection), sortDirection));
searchQuery.AddSortCriteria(sort);
if (!string.IsNullOrEmpty(searchTerm))
{
searchQuery.AddFilter(x => x.Id == int.Parse(searchTerm) || x.QuotationId == searchTerm);
}
var pagedPayslips = paySlipBillRepository.Search(searchQuery);
return new DataResult <IPagedListResult <DTOPaySlipBill> >
{
Errors = new List <ErrorDescriber>(),
Target = GetDefaultPagingDtoResult <DTOPaySlipBill, PaySlipBill>(_mapper, pagedPayslips)
};
}, cancellationToken));
}
public PagedListResult <KnowledgeArea> Search(string term, string searchFieldName, int page)
{
var repo = new GenericRepository <KnowledgeArea>(_context);
var query = new SearchQuery <KnowledgeArea>();
query.AddFilter(a => searchFieldName == Resource.KnowledgeAreaNameFieldName && a.Name.Contains(term) ||
searchFieldName == "Id" && a.Id.ToString().Contains(term) ||
string.IsNullOrEmpty(searchFieldName));
query.AddSortCriteria(new DynamicFieldSortCriteria <KnowledgeArea>("Order"));
query.Take = 8;
query.Skip = (page - 1) * 8;
return(repo.Search(query));
}
public PagedListResult <Classroom> Search(string term, string searchFieldName, int page)
{
var repo = new GenericRepository <Classroom>(_context);
var query = new SearchQuery <Classroom>();
query.AddFilter(a => searchFieldName == Resource.ClassroomNameFieldName && a.Name.Contains(term) ||
searchFieldName == Resource.CourseName &&
a.Courses.Any(c => c.Course.Name.Contains(term)) ||
string.IsNullOrEmpty(searchFieldName));
query.AddSortCriteria(new DynamicFieldSortCriteria <Classroom>("Name"));
query.Take = 8;
query.Skip = (page - 1) * 8;
return(repo.Search(query));
}
public PagedListResult <Teacher> ListTeachers(string term, string searchFieldName, int page)
{
var repo = new GenericRepository <Teacher>(_context);
var query = new SearchQuery <Teacher>();
query.AddFilter(a => searchFieldName == Resource.TeacherNameFieldName && a.Name.Contains(term) ||
searchFieldName == Resource.TeacherEmailFieldName && a.Email.Contains(term) ||
searchFieldName == "Id" && a.Id.ToString().Contains(term) ||
string.IsNullOrEmpty(searchFieldName));
query.AddSortCriteria(new DynamicFieldSortCriteria <Teacher>("Name"));
query.Take = 8;
query.Skip = (page - 1) * 8;
return(repo.Search(query));
}
public StaticPagedList<ProductModel> getProducts(int? pageNo)
{
//create the query
var query = new SearchQuery<ProductModel>();
// query.AddFilter(product => product.UserName =="");
//this is the same as the following
query.AddFilter(c => c.IsDelete == false);
query.AddSortCriteria(new FieldSortCriteria<ProductModel>("LastUpdate", SortDirection.Descending));
var pageNumber = pageNo ?? 1;
query.Take = 10;
query.Skip = pageNumber - 1;
var result = unitOfWork.ProductRepository.Search(query);
return new StaticPagedList<ProductModel>(result.Entities, pageNumber, query.Take, result.Count);
}
public virtual SearchQuery <TEntity> GenerateQuery(TableFilter tableFilter, string includeProperties = null)
{
var query = new SearchQuery <TEntity>
{
Skip = tableFilter.Start,
Take = tableFilter.Length
};
if (!string.IsNullOrEmpty(includeProperties))
{
query.IncludeProperties = includeProperties;
}
query.AddSortCriteria(new FieldSortOrder <TEntity>(tableFilter.ColumnName, tableFilter.OrderType));
return(query);
}
