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; }