public override async Task <DataTablesResult <ProductType> > SearchAsync(SearchRequest searchRequest, bool activeOnly = false)
{
//Get searchable properties
List <string> stringProperties = new List <string> ()
{
"Name", "ProductTypeCode"
};
Expression <Func <ProductType, bool> > predicate = DataTableHelper.ConstructFilter <ProductType> (searchRequest.Query, stringProperties, activeOnly);
if (string.IsNullOrEmpty(searchRequest.Query))
{
predicate = null;
}
//submodule type and submodule filter
if (searchRequest.SubmoduleTypeCode != null)
{
Expression <Func <ProductType, bool> > submoduleTypeExpression = x => x.SubmoduleType.SubmoduleTypeCode == searchRequest.SubmoduleTypeCode;
predicate = predicate != null?submoduleTypeExpression.AndAlso(predicate) : submoduleTypeExpression;
}
;
if (searchRequest.SubmoduleCode != null)
{
Expression <Func <ProductType, bool> > submoduleExpression = x => x.Submodule.SubmoduleCode == searchRequest.SubmoduleCode;
predicate = predicate != null?submoduleExpression.AndAlso(predicate) : submoduleExpression;
}
OrderBy <ProductType> orderBy = new OrderBy <ProductType> (qry => qry.OrderBy(e => e.ID));
var response = await SearchAsync(searchRequest, predicate, orderBy.Expression);
return(response);
}
/// <summary>
/// Suppliers page
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <DataTablesResult <vwSupplier> > GetSupplierPage(IDataTablesRequest request)
{
Expression <Func <vwSupplier, bool> > predicate = DataTableHelper.ConstructFilter <vwSupplier>(request.Search.Value, columns);
OrderBy <vwSupplier> orderBy = new OrderBy <vwSupplier>(qry => qry.OrderBy(e => e.Name));
var response = await _vwSupplierService.GetPageAsync(request, predicate, orderBy.Expression);
return(response);
}
/// <summary>
/// Users page
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <DataTablesResult <vwUser> > GetUserPage(IDataTablesRequest request)
{
Expression <Func <vwUser, bool> > predicate = DataTableHelper.ConstructFilter <vwUser> (request.Search.Value, columns);
var response = await _vwUserService.GetPageAsync(request, predicate, null);
return(response);
}
/// <summary>
/// Search product
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
public async Task <List <vwProduct> > SearchProduct(string query)
{
if (query.Length < 3)
{
return(null);
}
Expression <Func <vwProduct, bool> > predicate = DataTableHelper.ConstructFilter <vwProduct> (query, new List <string> {
"FullItemName", "BrandName"
});
OrderBy <vwProduct> orderBy = new OrderBy <vwProduct> (qry => qry.OrderBy(e => e.FullItemName));
var response = (await _vwProductService.FindByAsync(predicate, orderBy.Expression)).Take(MAX_PRODUCTS).ToList();
return(response.Where(p => p.IsExpired == null || !(bool)p.IsExpired).ToList());
}
public async Task <DataTablesResult <MedicalDeviceMigration> > GetPageAsync(IDataTablesRequest request)
{
Expression <Func <MedicalDeviceHeader, bool> > predicate = DataTableHelper.ConstructFilter <MedicalDeviceHeader> (request.Search.Value, columns);
OrderBy <MedicalDeviceHeader> orderBy = new OrderBy <MedicalDeviceHeader> (qry => qry.OrderBy(e => e.RegistrationDate));
var sortableColumns = request.Columns.Where(c => c.Sort != null);
var result = await base.GetPageAsync(request.Start, request.Length, sortableColumns, predicate, orderBy.Expression);
var pageData = MapMedicalDeviceMigration(result);
var totalRecords = await base.CountAsync(predicate);
var response = new DataTablesResult <MedicalDeviceMigration> (request.Draw, totalRecords, totalRecords, pageData);
return(response);
}
public async Task <DataTablesResult <vwShipment> > GetShipmentPageAsync(IDataTablesRequest request, int?userID = null)
{
Expression <Func <vwShipment, bool> > predicate = DataTableHelper.ConstructFilter <vwShipment> (request.Search.Value,
new List <string> {
"ImportPermitNumber", "ReleaseNumber", "ShipmentStatus", "PerformaInvoiceNumber", "AgentName", "SupplierName"
});
OrderBy <vwShipment> orderBy = new OrderBy <vwShipment> (qry => qry.OrderBy(e => e.ReleaseNumber));
if (string.IsNullOrEmpty(request.Search.Value))
{
predicate = null;
}
var response = await _vwShipmentService.GetPageAsync(request, predicate, orderBy.Expression);
return(response);
}
/// <summary>
/// Search Manufacturer Address
/// </summary>
/// <param name="query"></param>
/// <param name="pageNumber"></param>
/// <param name="pageSize"></param>
/// <returns></returns>
public async Task <DataTablesResult <vwManufacturerAddress> > SearchManufacturerAddress(string query, int pageNumber, int?pageSize = null)
{
Expression <Func <vwManufacturerAddress, bool> > predicate = DataTableHelper.ConstructFilter <vwManufacturerAddress>(query, new List <string> {
"Name", "Country"
});
OrderBy <vwManufacturerAddress> orderBy = new OrderBy <vwManufacturerAddress>(qry => qry.OrderBy(e => e.Name));
if (string.IsNullOrEmpty(query))
{
predicate = null;
}
var totalRecords = await _vwManufacturerAddressService.CountAsync(predicate);
var pageData = await _vwManufacturerAddressService.GetPageAsync(pageNumber *(pageSize.HasValue ? (int)pageSize : PAGE_SIZE), pageSize.HasValue?(int)pageSize : PAGE_SIZE, null, predicate, orderBy.Expression);
var response = new DataTablesResult <vwManufacturerAddress>(pageNumber, totalRecords, totalRecords, pageData);
return(response);
}
/// <summary>
/// Pagination enabled search
/// </summary>
/// <param name="searchRequest"></param>
/// <returns></returns>
public virtual async Task <DataTablesResult <T> > SearchAsync(SearchRequest searchRequest, bool activeOnly = false)
{
//Get searchable properties
List <string> stringProperties = typeof(T).GetProperties(
BindingFlags.FlattenHierarchy |
BindingFlags.Public |
BindingFlags.Instance).Where(p => !p.IsDefined(typeof(NotMappedAttribute), true) && p.PropertyType == typeof(string)).Select(p => p.Name).ToList();
Expression <Func <T, bool> > predicate = DataTableHelper.ConstructFilter <T> (searchRequest.Query, stringProperties, activeOnly);
//submodule type filter
if (typeof(T).GetProperty("SubmoduleType") != null)
{
ParameterExpression argument = Expression.Parameter(typeof(T), "t");
Expression left = Expression.Property(argument, typeof(T).GetProperty("SubmoduleType"));
left = Expression.Property(left, typeof(SubmoduleType).GetProperty("SubmoduleTypeCode"));
Expression right = Expression.Constant(searchRequest.SubmoduleTypeCode, typeof(string));
Expression predicateSubmodule = Expression.Equal(left, right);
Expression <Func <T, bool> > expression = predicateSubmodule != null?Expression.Lambda <Func <T, bool> > (predicateSubmodule, new [] { argument }) : null;
predicate = predicate != null?expression.AndAlso(predicate) : expression;
}
;
OrderBy <T> orderBy = new OrderBy <T> (qry => qry.OrderBy(e => e.ID));
if (string.IsNullOrEmpty(searchRequest.Query))
{
predicate = null;
}
var response = await SearchAsync(searchRequest, predicate, orderBy.Expression);
return(response);
}
