public static Expression <Func <TEntity, bool> > Parse <TEntity>(IDataFilter dataFilter, DataFilterMetaInfo filterInfo, Expression node)
{
ObjectChecker.CheckNotNull(filterInfo);
var filterFields = filterInfo.FilterFields;
if (filterFields.Count == 0)
{
return((Expression <Func <TEntity, bool> >)node);
}
// filter
var body = node;
foreach (var filterField in filterFields)
{
var handler = FilterFieldHandlerFactory.GetHandler(filterField.FilterFieldType);
if (handler != null)
{
// call FilterFieldHandler
body = handler.Handle(body, filterField);
}
}
// 删除 {True}
var optimizer = new ExprTreeOptimizer(body);
body = optimizer.Optimize();
return(body as Expression <Func <TEntity, bool> >);
}
public LoginAppService(
LoginService loginService,
ACodeService aCodeService,
SignInManager <IdentityUser> signInManager,
IDataFilter dataFilter,
IConfiguration configuration,
IHttpClientFactory httpClientFactory,
IUserInfoRepository userInfoRepository,
IWeChatMiniProgramAsyncLocal weChatMiniProgramAsyncLocal,
IMiniProgramUserRepository miniProgramUserRepository,
IMiniProgramLoginNewUserCreator miniProgramLoginNewUserCreator,
IMiniProgramLoginProviderProvider miniProgramLoginProviderProvider,
IDistributedCache <MiniProgramPcLoginAuthorizationCacheItem> pcLoginAuthorizationCache,
IDistributedCache <MiniProgramPcLoginUserLimitCacheItem> pcLoginUserLimitCache,
IOptions <IdentityOptions> identityOptions,
IdentityUserManager identityUserManager,
IMiniProgramRepository miniProgramRepository)
{
_loginService = loginService;
_aCodeService = aCodeService;
_signInManager = signInManager;
_dataFilter = dataFilter;
_configuration = configuration;
_httpClientFactory = httpClientFactory;
_userInfoRepository = userInfoRepository;
_weChatMiniProgramAsyncLocal = weChatMiniProgramAsyncLocal;
_miniProgramUserRepository = miniProgramUserRepository;
_miniProgramLoginNewUserCreator = miniProgramLoginNewUserCreator;
_miniProgramLoginProviderProvider = miniProgramLoginProviderProvider;
_pcLoginAuthorizationCache = pcLoginAuthorizationCache;
_pcLoginUserLimitCache = pcLoginUserLimitCache;
_identityOptions = identityOptions;
_identityUserManager = identityUserManager;
_miniProgramRepository = miniProgramRepository;
}
public DocumentService(IDocumentContext documentContext, IUserManager <GearUser> userManager, IFileManager fileManager, IDataFilter dataFilter)
{
_documentContext = documentContext;
_userManager = userManager;
FileManager = fileManager;
DataFilter = dataFilter;
}
/// <summary>
/// Retrieves all the entities matching the provided filter from the data store.
/// </summary>
/// <param name="filter">The filter to apply to the query.</param>
/// <returns>The entities matching the provided filter.</returns>
public override IEntity[] GetEntities(IDataFilter filter)
{
List <IEntity> entities = new List <IEntity>();
using (LogGroup logGroup = LogGroup.Start("Retrieving entities by type and filter.", NLog.LogLevel.Debug))
{
LogWriter.Debug("Filter type: " + filter.GetType().ToString());
foreach (Type type in filter.Types)
{
LogWriter.Debug("Includes type: " + type.ToString());
entities.AddRange(((Db4oDataStore)GetDataStore(type)).ObjectContainer.Query <IEntity>(delegate(IEntity entity)
{
return(filter.IsMatch(entity));
}));
}
foreach (IEntity entity in entities)
{
using (LogGroup logGroup2 = LogGroup.Start("Entity found.", NLog.LogLevel.Debug))
{
LogWriter.Debug("Entity ID: " + entity.ID);
LogWriter.Debug("Entity .ToString(): " + entity.ToString());
}
}
if (entities.Count == 0)
{
LogWriter.Debug("No entities retrieved.");
}
}
return(Release((IEntity[])entities.ToArray()));
}
public RouteGroupChecker(
IDataFilter dataFilter,
IRouteGroupRepository routeGroupRepository)
{
_dataFilter = dataFilter;
_routeGroupRepository = routeGroupRepository;
}
public bool BuildScript(Table table, IDataWrapper data, IDataFilter filter, out object script)
{
// 有数据
if (data.Read())
{
if (table is MaskingTable)
{
BuildScriptWithMaskSQL(table, data, filter, out script);
}
else if (table.WriteMode == WriteModes.Append)
{
BuildScriptWithDataTable(table, data, filter, out script);
}
else
{
BuildScriptWithMergeSQL(table, data, filter, out script);
}
return(true);
}
else
{
script = null;
return(false);
}
}
public DataFilterMetaInfo(IDataFilter filterInstance, IEnumerable<FilterFieldMetaInfo> filterFieldList)
{
FilterInstance = filterInstance;
FilterType = filterInstance.GetType();
// Exclude SortField<T>
FilterFields = filterFieldList.Where((attr) =>
{
var _attr = attr.FieldAttributes.OfType<DisableFieldExprAttribute>().FirstOrDefault();
return _attr == null || _attr.DisabledMode == DisableFieldExprMode.Sort;
})
.Where(field => field.FilterFieldInstace.FilterSwitch == FilterSwitch.Open &&
!(field.FilterFieldType.GetTypeInfo().IsGenericType && field.FilterFieldType.GetGenericTypeDefinition() == typeof(SortField<>))).ToImmutableList();
// Sort Field List
FilterFiledsOfSort = filterFieldList.Where((attr) =>
{
var _attr = attr.FieldAttributes.OfType<DisableFieldExprAttribute>().FirstOrDefault();
return _attr == null || _attr.DisabledMode == DisableFieldExprMode.Filter;
})
.Where(p => p.FilterFieldType.GetTypeInfo().IsGenericType && ((p.FilterFieldInstace as IHasSortField)?.SortMode != SortMode.Disable))
.Select((filter) =>
{
return new FilterFieldSortMetaInfo(filter.FilterFieldInstace as IHasSortField, filter.FilterFieldType, filter.FilterFieldExprName, filter.FieldAttributes);
}).OrderByDescending(p => p.FilterFieldInstace as _SortField).ToImmutableList();
}
public EfCoreFileStoringContainerRepositoryTest()
{
_currentTenant = GetRequiredService <ICurrentTenant>();
_dataFilter = GetRequiredService <IDataFilter <IMultiTenant> >();
_fileStoringContainerRepository = GetRequiredService <IFileStoringContainerRepository>();
_guidGenerator = GetRequiredService <IGuidGenerator>();
}
public int Count(IDataFilter <Student> filter)
{
Checker.NotNullArgument(filter, nameof(filter));
var sqlWhereClauses = filter.GetObjects()
.Select((o) => GetSqlWhereClause(o, "t"))
.ToList();
var sqlWhere = sqlWhereClauses.Any()
? string.Join(" and ", sqlWhereClauses)
: string.Empty;
using (var cmd = _context.Database.GetDbConnection().CreateCommand())
{
var whereClause = !string.IsNullOrWhiteSpace(sqlWhere)
? $" where {sqlWhere}"
: string.Empty
;
cmd.CommandText = $"select count(*) from {nameof(Student)} t{whereClause}";
using (DbDataReader reader = cmd.ExecuteReader())
{
if (reader.HasRows && reader.Read())
{
return(reader.GetInt32(0));
}
}
}
return(0);
}
/// <summary>
/// Create new instance of <see cref="RepositoryFilter"/> and <see cref="RepositorySorter"/>
/// </summary>
/// <param name="filter">Repository filter.</param>
/// <param name="sorter">Repository sorter.</param>
public StudentsRepository(IDataFilter filter, IDataSorter sorter)
{
this.filter = filter;
this.sorter = sorter;
this.students = new Dictionary <string, IStudent>();
this.courses = new Dictionary <string, ICourse>();
}
public bool BuildScript(Table table, IDataWrapper data, IDataFilter filter, out object script)
{
// DB2BulkCopy 不支持事务，只能使用脚本模式
if (data.Read())
{
if (table is MaskingTable)
{
BuildScriptWithMaskSQL(table, data, filter, out script);
}
else if (table.WriteMode == WriteModes.Append)
{
BuildScriptWithInsertSQL(table, table.DestName, data, filter, out script);
}
else
{
BuildScriptWithMergeSQL(table, data, filter, out script);
}
return(true);
}
else
{
script = null;
return(false);
}
}
/// <summary>
/// 过滤列
/// </summary>
/// <param name="pFilter"></param>
/// <param name="pAllDetailColumns">所有的底层表格列</param>
private void FilterColumns(IDataFilter pFilter, List <JIT.Utility.Web.ComponentModel.ExtJS.Grid.Column.Column> pAllDetailColumns)
{
//获取所有的底层列
if (pAllDetailColumns != null && pAllDetailColumns.Count > 0 && pFilter != null)
{
bool isChangeHidden = false;
foreach (var gridCol in pAllDetailColumns)
{
FilteringColumn fc = new FilteringColumn();
fc.GridColumn = gridCol;
if (this.GridColumnToAnalysisColumnMappings.ContainsKey(gridCol))
{
fc.AnalysisColumn = this.GridColumnToAnalysisColumnMappings[gridCol];
}
ColumnDataRetriever cdr = new ColumnDataRetriever(this.ReportDataes, this.ColumnSummaryValues);
//
if (!pFilter.IsShowColumn(fc, cdr))
{
gridCol.IsHidden = true;//不显示该列
isChangeHidden = true;
}
}
if (isChangeHidden)
{
if (this.Columns != null)
{
foreach (var col in this.Columns)
{
this.HideColumnBecauseAllChildrenIsHidden(col);
}
}
}
}
}
public IEnumerable <TDataModel> Search(IDataFilter <TDataModel> filter,
IDataIncludes includes)
{
Checker.NotNullArgument(filter, nameof(filter));
return(QuerySearch(_query, filter, includes).ToList());
}
private void BuildScriptWithMaskSQL(Table table, IDataWrapper data, IDataFilter filter, out object script)
{
string destTable = ProcessTableName(table.DestName, table.DestSchema);
string tmpTable = $"{ExtractTableName(table.DestName)}_{Guid.NewGuid():N}";
string processedTmpTable = ProcessTableName(tmpTable, table.DestSchema);
StringBuilder sb = new StringBuilder();
string[] fields = ExcludeFields(table.DestFields, table.KeyFields, table.SkipFields);
string field = ProcessFieldName(fields[0]);
sb.Append($"UPDATE {destTable} SET {field} = B.{field}");
for (int i = 1; i < fields.Length; i++)
{
field = ProcessFieldName(fields[i]);
sb.Append($", {field} = B.{field}");
}
field = ProcessFieldName(table.KeyFields[0]);
sb.Append($" FROM {processedTmpTable} B WHERE {destTable}.{field} = B.{field}");
for (int i = 1; i < table.KeyFields.Length; i++)
{
field = ProcessFieldName(table.KeyFields[i]);
sb.Append($" AND {destTable}.{field} = B.{field}");
}
BuildScriptWithInsertSQL(table, tmpTable, data, filter, out script);
script = new MergeScript()
{
TableName = tmpTable,
PrepareSQL = $"CREATE TABLE {processedTmpTable} AS"
+ $" (SELECT {ProcessFieldNames(table.DestFields)} FROM {destTable} WHERE 1 = 0) WITH NO DATA",
InsertSQL = script.ToString(),
MergeSQL = sb.ToString(),
CleanSQL = $"DROP TABLE {processedTmpTable}"
};
}
private void SetCatalogData()
{
List <IDataIdentifier> ids = null;
try
{
IDataFilter filter = SearchConditionSelector1.DataFilter;
foreach (DataFilterParameter parameter in filter.Parameters)
{
filter.SetCondition(SearchConditionSelector1[parameter.Name]);
}
ids = GINProcessBLL.SearchGINProcess(filter);
}
catch
{
ids = new List <IDataIdentifier>();
}
string buffer = string.Empty;
foreach (IDataIdentifier identifier in ids)
{
buffer += identifier.Preview.DocumentElement.InnerXml;
}
string ginProcessSet = "<?xml version=\"1.0\" encoding=\"utf-8\"?> <Catalog>" + buffer + "</Catalog>";
xdsGINProcessSource.Data = ginProcessSet;
gvPickupNotice.DataBind();
}
public PaginatedResult <TSelect> LimitedSearch <TGroup, TSelect>(
IDataFilter <TDataModel> filter,
IDataLimiter <TDataModel> limiter,
IDataProjection <TDataModel, TGroup, TSelect> projection)
{
Checker.NotNullArgument(filter, nameof(filter));
Checker.NotNullArgument(limiter, nameof(limiter));
Checker.NotNullArgument(projection, nameof(projection));
Checker.NotNullObject(projection.Group,
$"{nameof(projection)}.{nameof(projection.Group)}");
Checker.NotNullObject(projection.Select,
$"{nameof(projection)}.{nameof(projection.Select)}");
var query = QuerySearch(_query, filter, projection);
// A projeção já foi aplicada em QuerySearch(),
// por isso não precisa ser repassada aqui
var(offset, limit, total, result) = QueryPreLimitResult(query, limiter, null);
return(new PaginatedResult <TSelect>(
result.GroupBy(projection.Group).Select(projection.Select).ToList(),
offset,
limit,
total
));
}
public MyBookService(
IDataFilter dataFilter,
IRepository <Book, Guid> bookRepository)
{
_dataFilter = dataFilter;
_bookRepository = bookRepository;
}
public DemoProductAppService(
IRepository <DemoProduct, Guid> productRepository,
IDataFilter dataFilter)
{
_ProductRepository = productRepository;
_dataFilter = dataFilter;
}
public PrivateMessageSenderSideManager(
IDataFilter dataFilter,
IPrivateMessageRepository repository)
{
_dataFilter = dataFilter;
_repository = repository;
}
public static FilterFieldMetaInfo[] GetFilterFields(IDataFilter filter)
{
var filterUniqueName = TypeHelper.GetGenericTypeUniqueName(filter.GetType());
var propExprMappings = FieldExprNameMappingFactory.Get(filterUniqueName, () =>
{
return(InternalExprNameMappingUtil.CreateFilterExprNameMappings(filter).ToList());
});
var exprNames = propExprMappings.Select(p => p.Property.Name);
var properties = GetFieldPropertiesFromFilter(filter).Where(p => exprNames.Contains(p.Name));
var fieldFilterIndex = 0;
var FilterFieldMetaInfos = new FilterFieldMetaInfo[properties.Count()];
foreach (var property in properties)
{
var map = propExprMappings.FirstOrDefault(p => p.Property.Name == property.Name);
var objValue = property.GetValue(filter, null);
var sortValue = objValue as IHasSortField;
if (sortValue != null && sortValue.SortMode == SortMode.Disable)
{
if (map.ExprNameAttribute != null)
{
sortValue.SortMode = map.ExprNameAttribute.SortMode;
sortValue.SortPriority = map.ExprNameAttribute.SortPriority;
}
objValue = sortValue;
}
FilterFieldMetaInfos[fieldFilterIndex++] = CreateFilterFieldMetaInfoByType(
property.PropertyType, objValue, map.ExprName, property.GetCustomAttributes <Attribute>(true));
}
return(FilterFieldMetaInfos);
}
public ContainerAppServiceTest()
{
_currentTenant = GetRequiredService <ICurrentTenant>();
_dataFilter = GetRequiredService <IDataFilter <IMultiTenant> >();
_containerAppService = GetRequiredService <IContainerAppService>();
_fileContainerFactory = GetRequiredService <IFileContainerFactory>();
}
/// <summary>
/// 过滤行
/// </summary>
/// <param name="pFilter"></param>
/// <param name="pDataes"></param>
private void FilterRow(IDataFilter pFilter, DataTable pDataes)
{
if (pFilter != null && pDataes != null && pDataes.Rows.Count > 0)
{
List <int> needRemovedRowIndex = new List <int>();
for (var i = 0; i < pDataes.Rows.Count; i++)
{
var dr = pDataes.Rows[i];
RowDataRetriever rdr = new RowDataRetriever(dr, this.DataTableColumnToAnalysisColumnMappings);
if (!pFilter.IsShowRow(i, rdr))
{
needRemovedRowIndex.Add(i);
}
}
//移除列
if (needRemovedRowIndex != null && needRemovedRowIndex.Count > 0)
{
int removedCount = 0;
foreach (var item in needRemovedRowIndex)
{
var index = item - removedCount;
pDataes.Rows.RemoveAt(index);
removedCount++;
}
//
pDataes.AcceptChanges();
}
}
}
/// <inheritdoc />
public IEnumerable <TViewData> Execute <TDataFilter>(IDataFilter <TDataFilter, TData> filter, IDbConnection connection) where TDataFilter : IDataFilter <TDataFilter, TData>
{
if (!_compiled)
{
Compile();
}
var parameters = new Dictionary <string, object>();
var transaction = default(IDbTransaction);
var buffered = true;
int?commandTimeout = null;
var filterPredicate = _predicateFactory.GetPredicate <TDataFilter, TData>(filter);
var filterSql = _predicateQueryBuilderFactory
.GetQueryBuilder(filterPredicate, this)
.GetSql(filterPredicate, parameters);
var dynamicParameters = new DynamicParameters();
foreach (var parameter in parameters)
{
dynamicParameters.Add(parameter.Key, parameter.Value);
}
return(connection.Query <TViewData>($"{_query} WHERE {filterSql}", dynamicParameters, transaction, buffered, commandTimeout, CommandType.Text));
}
public TSelect GetFirst <TSelect>(IDataFilter <TDataModel> filter,
IDataProjection <TDataModel, TSelect> projection)
{
Checker.NotNullArgument(projection, nameof(projection));
Checker.NotNullObject(projection.Select, () => projection.Select);
return(QuerySearch(_query, filter, projection).Select(projection.Select).FirstOrDefault());
}
// protected IDataFilter DataFilter { get; }
public RiderCoverageRepository(
IDataFilter dataFilter,
IDbContextProvider <SpeedwaveDbContext> provider)
: base(provider)
{
// this.DataFilter = dataFilter;
//DataFilter
}
/// <summary>
///
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <returns></returns>
public Expression <Func <TEntity, bool> > BuildFilterExpression <TEntity>(IDataFilter dataFilter, IFilterContext context) where TEntity : class
{
FilterContext = context;
var filterexpression = BuildFilterExpression <TEntity>(context);
var expression = filterexpression.Or(filterexpression.Equal(expr2 => dataFilter.IsEnabled(FilterType)));
return(expression);
}
public System.Xml.XmlDocument OpenData(IDataIdentifier id, IDataFilter filter)
{
//TODO - Review this later.
string dataFilterTemplate = dataXPathTemplate[filter.TemplateName].Template;
string selection = dataFilterTemplate.Replace(SelectionPlaceholder, ((GuidIdentifier)id).ID.ToString());
return(GetXmlDocument(GetXml(filter.GetFilterExpression(selection))));
}
public IEnumerable <TDataModel> BulkUpdate <TUpdated>(IDataFilter <TDataModel> filter,
TUpdated updated)
{
Checker.NotNullArgument(filter, nameof(filter));
Checker.NotNullArgument(updated, nameof(updated));
return(BulkUpdate(filter, _ => updated));
}
public static Expression <Func <TEntity, bool> > Parse <TEntity>(IDataFilter dataFilter, DataFilterMetaInfo filterInfo, string paramName)
{
var body = Expression.Constant(true, typeof(bool));
var parameter = paramName.IsEmpty() ? PredicateBuilder.Paramter <TEntity>() : PredicateBuilder.Paramter <TEntity>(paramName);
var lambdaExpr = Expression.Lambda <Func <TEntity, bool> >(body, parameter);
return(Parse <TEntity>(dataFilter, filterInfo, lambdaExpr));
}
public TenantUpdateEventHandler(
IDataFilter dataFilter,
ITenantRepository tenantRepository,
IDistributedCache <TenantConfigurationCacheItem> cache)
{
_cache = cache;
_dataFilter = dataFilter;
_tenantRepository = tenantRepository;
}
public void Add(IDataFilter filter)
{
if (filter == null)
throw new ArgumentNullException("filter");
List<IDataFilter> list = (filters == null ? new List<IDataFilter>() : new List<IDataFilter>(filters));
list.Add(filter);
filters = (IDataFilter[])list.ToArray();
}
private static bool CheckFilters(AFValue afValue, IDataFilter[] dataFilters)
{
if (dataFilters == null)
return false;
var isFiltered = false;
foreach (var filter in dataFilters)
{
isFiltered = filter.IsFiltered(afValue);
if (isFiltered)
{
break;
}
}
return isFiltered;
}
public StudentsRepository(IDataSorter sorter, IDataFilter filter)
{
this.filter = filter;
this.sorter = sorter;
}
