public static IQueryable <TEntity> Filter <TEntity>(this DbSet <TEntity> query, params object[] keys) where TEntity : class
#endif
{
var queryFilterQueryable = QueryFilterManager.GetFilterQueryable(query);
var context = queryFilterQueryable != null ? queryFilterQueryable.Context : query.GetDbContext();
var filterContext = QueryFilterManager.AddOrGetFilterContext(context);
return(filterContext.ApplyFilter(query, keys));
}
public static IQueryable <T> Filter <T>(this DbSet <T> query, params object[] keys) where T : class
#endif
{
var queryFilterQueryable = QueryFilterManager.GetFilterQueryable(query);
var nonQueryFilter = queryFilterQueryable != null ? (IQueryable <T>)queryFilterQueryable.OriginalQuery : query;
var context = queryFilterQueryable != null ? queryFilterQueryable.Context : query.GetDbContext();
var filterContext = QueryFilterManager.AddOrGetFilterContext(context);
return(filterContext.ApplyFilter(nonQueryFilter, keys));
}
/// <summary>
/// Creates and return a filter associated with the specified key added for the context.
/// </summary>
/// <typeparam name="T">The type of elements of the query.</typeparam>
/// <param name="context">The context filtered.</param>
/// <param name="key">The filter key associated to the filter.</param>
/// <param name="queryFilter">The query filter to apply to the the context.</param>
/// <param name="isEnabled">true if the filter is enabled.</param>
/// <returns>The filter created and added to the the context.</returns>
public static BaseQueryFilter Filter <T>(this DbContext context, object key, Func <IQueryable <T>, IQueryable <T> > queryFilter, bool isEnabled = true)
{
var filterContext = QueryFilterManager.AddOrGetFilterContext(context);
var filter = filterContext.AddFilter(key, queryFilter);
if (isEnabled)
{
filter.Enable();
}
return(filter);
}
public static IQueryable <T> SetFiltered <T>(this DbContext context) where T : class
{
var filterContext = QueryFilterManager.AddOrGetFilterContext(context);
if (filterContext.FilterSetByType.ContainsKey(typeof(T)))
{
var set = filterContext.FilterSetByType[typeof(T)];
if (set.Count == 1)
{
return((IQueryable <T>)set[0].DbSetProperty.GetValue(context, null));
}
throw new Exception(ExceptionMessage.QueryFilter_SetFilteredManyFound);
}
throw new Exception(ExceptionMessage.QueryFilter_SetFilteredNotFound);
}
/// <summary>
/// Filter the query using context filters associated with specified keys.
/// </summary>
/// <typeparam name="T">The type of elements of the query.</typeparam>
/// <param name="query">The query to filter using context filters associated with specified keys.</param>
/// <param name="keys">
/// A variable-length parameters list containing keys associated to context filters to use to filter the
/// query.
/// </param>
/// <returns>The query filtered using context filters associated with specified keys.</returns>
public static IQueryable <T> Filter <T>(this IDbSet <T> query, params object[] keys) where T : class
{
var filterContext = QueryFilterManager.AddOrGetFilterContext(query.GetDbContext());
var filterHook = QueryFilterManager.EnableFilterById;
var sb = new StringBuilder();
if (keys != null)
{
foreach (var key in keys)
{
var filter = filterContext.GetFilter(key);
if (filter == null)
{
continue;
}
sb.Append(filter.UniqueKey);
sb.Append(";");
}
}
return(QueryFilterManager.HookFilter(query.AsNoFilter(), filterHook + sb));
}
/// <summary>Gets the filter associated with the specified key from the context.</summary>
/// <param name="context">The context filtered.</param>
/// <param name="key">The filter key associated to the filter.</param>
/// <returns>The filter associated with the specified key from the context.</returns>
public static BaseQueryFilter Filter(this DbContext context, object key)
{
var filterContext = QueryFilterManager.AddOrGetFilterContext(context);
return(filterContext.GetFilter(key));
}
/// <summary>
/// This method is called after a new
/// <see cref="T:System.Data.Entity.Core.Common.CommandTrees.DbCommandTree" /> has been created.
/// The tree that is used after interception can be changed by setting
/// <see cref="P:System.Data.Entity.Infrastructure.Interception.DbCommandTreeInterceptionContext.Result" />
/// while intercepting.
/// </summary>
/// <param name="interceptionContext">Contextual information associated with the call.</param>
public void TreeCreated(DbCommandTreeInterceptionContext interceptionContext)
{
var dbQueryCommandTree = interceptionContext.Result as DbQueryCommandTree;
if (dbQueryCommandTree != null && interceptionContext.DbContexts.Count() == 1)
{
var context = interceptionContext.DbContexts.First();
// Visit first to find filter ID && hook
var visitorFilter = new QueryFilterInterceptorDbFilterExpression();
var queryFiltered = dbQueryCommandTree.Query.Accept(visitorFilter);
if (!string.IsNullOrEmpty(visitorFilter.HookID))
{
if (!QueryFilterManager.DbExpressionByHook.ContainsKey(visitorFilter.HookID))
{
QueryFilterManager.DbExpressionByHook.TryAdd(visitorFilter.HookID, queryFiltered);
}
}
else
{
var filterByContext = QueryFilterManager.AddOrGetFilterContext(context);
filterByContext.ClearCacheRequired = true;
var filterQuery = new QueryFilterInterceptorApply
{
InstanceFilters = filterByContext
};
if (visitorFilter.FilterID != null && visitorFilter.FilterID.Count > 0)
{
foreach (var filter in visitorFilter.FilterID)
{
if (filter == QueryFilterManager.DisableAllFilter)
{
// Disable all filter in the context!
filterQuery.ApplyFilterList.Add(interceptorFilter => false);
}
else if (filter.StartsWith(QueryFilterManager.EnableFilterById, StringComparison.InvariantCulture))
{
// Enable all specific filter
var filters = filter.Substring(QueryFilterManager.EnableFilterById.Length).Split(new[] { ";" }, StringSplitOptions.RemoveEmptyEntries);
if (filters.Length == 0)
{
filterQuery.ApplyFilterList.Add(interceptorFilter => false);
}
foreach (var applyFilter in filters)
{
filterQuery.ApplyFilterList.Add(interceptorFilter => interceptorFilter.UniqueKey.ToString() == applyFilter ? true : (bool?)null);
}
}
}
}
// VISIT filter
var visitor = new QueryFilterInterceptorDbScanExpression
{
Context = context,
InstanceFilterContext = filterByContext,
FilterQuery = filterQuery
};
var newQuery = queryFiltered.Accept(visitor);
// CREATE a new Query
interceptionContext.Result = new DbQueryCommandTree(dbQueryCommandTree.MetadataWorkspace, dbQueryCommandTree.DataSpace, newQuery, true);
}
}
}