/// <summary> /// 根据前台传递的参数,对"字典"数据进行分页,搜索 /// </summary> /// <param name="pageNumber">页码</param> /// <param name="pageSize">页大小</param> /// <param name="number">返回的total总数</param> /// <param name="sort">排序字段</param> /// <param name="sortOrder">排序标识asc或desc</param> /// <param name="search">搜索的字符串</param> /// <returns></returns> public List <T_Sys_Dict> GetDictPages(int pageNumber, int pageSize, out long number, string sort = null, string sortOrder = null, string search = null) { //List < T_Sys_Dict > dicts =dao.GetPageList<T_Sys_Dict>(pageNumber,pageSize,out number).ToList(); //创建谓词 IFieldPredicate predicate = null; if (!string.IsNullOrEmpty(search)) { predicate = Predicates.Field <T_Sys_Dict>(f => f.DICT_NAME, Operator.Like, "%" + search + "%"); } IList <ISort> sorts = new List <ISort>(); //创建排序 if (sort == null) { sorts.Add(new Sort { PropertyName = "DICT_CODE", Ascending = sortOrder == "asc" ? true : false }); } else { sorts.Add(new Sort { PropertyName = sort, Ascending = sortOrder == "asc"?true:false }); } List <T_Sys_Dict> dicts = dao.GetPageList <T_Sys_Dict>(pageNumber, pageSize, out number, predicate, sorts).ToList(); return(dicts); }
private string GetSql(IFieldPredicate predicate, IDictionary <string, object> parameters) { var columnName = _sqlBuilder.GetColumnName(predicate.EntityType, predicate.PropertyName, false); if (predicate.Value == null) { return($"({columnName} IS {(predicate.Negate ? "NOT " : string.Empty)}NULL)"); } if (predicate.Value is IEnumerable enumerable && !(enumerable is string)) { if (predicate.Operator != Operator.Eq) { throw new ArgumentException("Operator must be set to Eq for Enumerable types"); } var @params = new List <string>(); foreach (var value in enumerable) { var valueParameterName = parameters.SetParameterName(predicate.PropertyName, value, _sqlBuilder.Dialect.ParameterPrefix); @params.Add(valueParameterName); } var paramStrings = @params.Aggregate(new StringBuilder(), (sb, s) => sb.Append((sb.Length != 0 ? ", " : string.Empty) + s), sb => sb.ToString()); return($"({columnName} {(predicate.Negate ? "NOT " : string.Empty)}IN ({paramStrings}))"); } var parameterName = parameters.SetParameterName(predicate.PropertyName, predicate.Value, _sqlBuilder.Dialect.ParameterPrefix); return($"({columnName} {GetOperatorString(predicate)} {parameterName})"); }
private IPredicate GetEntityPredicate(IClassMapper classMap, object entity) { Type predicateType = typeof(FieldPredicate <>).MakeGenericType(classMap.EntityType); IList <IPredicate> predicates = new List <IPredicate>(); foreach (KeyValuePair <string, object> kvp in ReflectionHelper.GetObjectValues(entity, classMap.Properties)) { IFieldPredicate fieldPredicate = Activator.CreateInstance(predicateType) as IFieldPredicate; if (fieldPredicate == null) { throw new NullReferenceException("Unable to create instance of IFieldPredicate"); } fieldPredicate.Not = false; fieldPredicate.Operator = Operator.Eq; fieldPredicate.PropertyName = kvp.Key; fieldPredicate.Value = kvp.Value; predicates.Add(fieldPredicate); } return(predicates.Count == 1 ? predicates[0] : new PredicateGroup { Operator = GroupOperator.And, Predicates = predicates }); }
public StatusValuePair <List <ArchiveEntities> > GetListArchiveElements() { IFieldPredicate p = Predicates.Field <ArchiveEntities>(f => f.IsArchiveElement, Operator.Eq, true); StatusValuePair <List <ArchiveEntities> > result = GetList <ArchiveEntities>(p); return(result); }
public static Expression <Func <T, bool> > Parse(IPredicate predicate) { IFieldPredicate fieldPredicate = (IFieldPredicate)predicate; ParameterExpression parameterExpression = Expression.Parameter(typeof(T), "p"); MemberExpression memberExpression = Expression.PropertyOrField(parameterExpression, fieldPredicate.PropertyName); UnaryExpression propertyValue = Expression.Convert(Expression.Constant(fieldPredicate.Value), memberExpression.Type); var operatorMatrix = new Dictionary <KeyValuePair <Operator, bool>, Func <Expression> > { { new KeyValuePair <Operator, bool>(Operator.Like, false), () => LikeExpression.Like(memberExpression, propertyValue) }, { new KeyValuePair <Operator, bool>(Operator.Eq, false), () => Expression.Equal(memberExpression, propertyValue) }, { new KeyValuePair <Operator, bool>(Operator.Gt, false), () => Expression.GreaterThan(memberExpression, propertyValue) }, { new KeyValuePair <Operator, bool>(Operator.Ge, false), () => Expression.GreaterThanOrEqual(memberExpression, propertyValue) }, { new KeyValuePair <Operator, bool>(Operator.Lt, false), () => Expression.LessThan(memberExpression, propertyValue) }, { new KeyValuePair <Operator, bool>(Operator.Le, false), () => Expression.LessThanOrEqual(memberExpression, propertyValue) }, { new KeyValuePair <Operator, bool>(Operator.Like, true), () => LikeExpression.NotLike(memberExpression, propertyValue) }, { new KeyValuePair <Operator, bool>(Operator.Eq, true), () => Expression.NotEqual(memberExpression, propertyValue) }, { new KeyValuePair <Operator, bool>(Operator.Gt, true), () => Expression.LessThan(memberExpression, propertyValue) }, { new KeyValuePair <Operator, bool>(Operator.Ge, true), () => Expression.LessThanOrEqual(memberExpression, propertyValue) }, { new KeyValuePair <Operator, bool>(Operator.Lt, true), () => Expression.GreaterThan(memberExpression, propertyValue) }, { new KeyValuePair <Operator, bool>(Operator.Le, true), () => Expression.GreaterThanOrEqual(memberExpression, propertyValue) }, }; var body = operatorMatrix[new KeyValuePair <Operator, bool>(fieldPredicate.Operator, fieldPredicate.Not)].Invoke(); return(Expression.Lambda <Func <T, bool> >(body, parameterExpression)); }
protected override Expression VisitBinary(BinaryExpression node) { Expressions.Add(node); ExpressionType nt = node.NodeType; if (nt == ExpressionType.OrElse || nt == ExpressionType.AndAlso) { var pg = new PredicateGroup { Predicates = new List <IPredicate>(), Operator = nt == ExpressionType.OrElse ? GroupOperator.Or : GroupOperator.And }; _pg.Predicates.Add(pg); } Visit(node.Left); if (node.Left is MemberExpression) { IFieldPredicate field = GetLastField(); field.Operator = DetermineOperator(node); if (nt == ExpressionType.NotEqual) { field.Not = true; } } Visit(node.Right); return(node); }
protected IPredicate GetEntityPredicate(IClassMapper classMap, object entity) { Type predicateType = typeof(FieldPredicate <>).MakeGenericType(classMap.EntityType); IList <IPredicate> predicates = new List <IPredicate>(); var notIgnoredColumns = classMap.Properties.Where(p => !p.Ignored); IDictionary <string, object> kvp = new Dictionary <string, object>(); if (entity.GetType() == typeof(IDictionary <string, object>) || entity.GetType() == typeof(Dictionary <string, object>)) { kvp = (IDictionary <string, object>)entity; } else { kvp = ReflectionHelper.GetObjectValues(entity); } foreach (var kv in kvp.Where(property => notIgnoredColumns.Any(c => c.Name.Equals(property.Key, StringComparison.OrdinalIgnoreCase)))) { IFieldPredicate fieldPredicate = Activator.CreateInstance(predicateType) as IFieldPredicate; string keyName = notIgnoredColumns.FirstOrDefault(s => s.Name.Equals(kv.Key, StringComparison.OrdinalIgnoreCase)).Name; fieldPredicate.Not = false; fieldPredicate.Operator = Operator.Eq; fieldPredicate.PropertyName = keyName; fieldPredicate.Value = kv.Value; predicates.Add(fieldPredicate); } return(predicates.Count == 1 ? predicates[0] : new PredicateGroup { Operator = GroupOperator.And, Predicates = predicates }); }
private IPredicate ParseUnaryNot(UnaryExpression expression) { if (expression.NodeType != ExpressionType.Not) { throw new InvalidOperationException(); } var predicate = this.Parse(expression.Operand); return(VisitPredicateTree(predicate, p => { PredicateGroup g = p as PredicateGroup; if (g != null) { g.Operator = g.Operator == GroupOperator.And ? GroupOperator.Or : GroupOperator.And; return true; } IFieldPredicate f = p as IFieldPredicate; if (f != null) { f.Not = !f.Not; return false; } throw new NotImplementedException(); })); }
public FiatSitecoreSerializationProvider(IPredicate predicate, IFieldPredicate fieldPredicate, IFiatDeserializerLogger logger, string rootPath = null, string logName = "UnicornItemSerialization") : base(predicate, rootPath, logName) { Assert.ArgumentNotNull(logger, "logger"); _deserializer = new FiatDeserializer(logger, fieldPredicate); }
public FiatRemotedSerializationProvider(IPredicate predicate, IFieldPredicate fieldPredicate, IFiatDeserializerLogger logger, string remoteUrl = null, string rootPath = null, string logName = "UnicornItemSerialization") : base(predicate, fieldPredicate, logger, rootPath, logName) { Assert.ArgumentNotNull(remoteUrl, "remoteUrl"); RemoteUrl = remoteUrl; }
protected override Expression VisitConstant(ConstantExpression node) { IFieldPredicate field = GetCurrentField(); field.Value = node.Value; return(node); }
public virtual bool Delete(IFieldPredicate predicate) { using (var con = connectionFactory.Connection) { return(con.Delete <TModel>(predicate)); } }
public StatusValuePair <List <ManyToManyEntities> > SearchRight(long rId) { IFieldPredicate p = Predicates.Field <ManyToManyEntities>(entity => entity.RightId, Operator.Eq, rId); StatusValuePair <List <ManyToManyEntities> > result = this.GetList <ManyToManyEntities>(p); return(result); }
public virtual IEnumerable <TModel> GetAll(IFieldPredicate predicate) { using (var con = connectionFactory.Connection) { return(con.GetList <TModel>(predicate)); } }
/// <summary> /// 流程业务记录分页方法 /// </summary> /// <param name="query"></param> /// <param name="count"></param> /// <returns></returns> public List <AppFlowEntity> GetPaged(AppFlowQuery query, out int count) { List <AppFlowEntity> list = null; var conn = SessionFactory.CreateConnection(); try { var sortList = new List <DapperExtensions.ISort>(); sortList.Add(new DapperExtensions.Sort { PropertyName = "ID", Ascending = false }); IFieldPredicate predicate = null; if (!string.IsNullOrEmpty(query.AppInstanceID)) { predicate = Predicates.Field <AppFlowEntity>(f => f.AppInstanceID, DapperExtensions.Operator.Eq, query.AppInstanceID); } count = QuickRepository.Count <AppFlowEntity>(conn, predicate); list = QuickRepository.GetPaged <AppFlowEntity>(conn, query.PageIndex, query.PageSize, predicate, sortList, false).ToList(); return(list); } catch (System.Exception) { throw; } finally { conn.Close(); } }
public FiatSitecoreSerializationFormatter(IFiatFormatterLogger logger, IFieldPredicate fieldPredicate) { Assert.ArgumentNotNull(logger, "logger"); Assert.ArgumentNotNull(fieldPredicate, "fieldPredicate"); _logger = logger; _fieldPredicate = fieldPredicate; }
public SerializedAsMasterEvaluator(ISerializedAsMasterEvaluatorLogger logger, IFieldPredicate fieldPredicate) { Assert.ArgumentNotNull(logger, "logger"); Assert.ArgumentNotNull(fieldPredicate, "fieldPredicate"); _logger = logger; _fieldPredicate = fieldPredicate; }
public FiatDeserializer(IFiatDeserializerLogger logger, IFieldPredicate fieldPredicate) { Assert.ArgumentNotNull(logger, "logger"); Assert.ArgumentNotNull(fieldPredicate, "fieldPredicate"); _logger = logger; _fieldPredicate = fieldPredicate; }
/// <summary> /// Counts the specified predicate. /// </summary> /// <param name="predicate">The predicate.</param> /// <returns>A count.</returns> /// <example> /// Example: /// var predicate = Predicates.Field<Task>(f => f.DateCreated, Operator.Lt, DateTime.UtcNow.AddDays(-5)); /// int count = cn.Count<Task>(predicate); /// https://github.com/tmsmith/Dapper-Extensions /// . /// </example> public int Count(IFieldPredicate predicate) { using (var con = this._connection.Create()) { con.Open(); return con.Count<Task>(predicate); } }
public virtual IEnumerable <Quote> AllQuotesAfter(DateTime afterDate) { using (DbConnection connection = Db.CreateConnection()) { connection.Open(); IFieldPredicate predicate = Predicates.Field <Quote>(x => x.CreateDate, Operator.Gt, afterDate); return(connection.GetList <Quote>(predicate)); } }
public IFieldPredicate ExecuteFilter <TEntity, TPrimaryKey>() where TEntity : class, IEntity <TPrimaryKey> { IFieldPredicate predicate = null; if (typeof(IMustHaveTenant).IsAssignableFrom(typeof(TEntity)) && IsEnabled) { predicate = Predicates.Field <TEntity>(f => (f as IMustHaveTenant).TenantId, Operator.Eq, TenantId); } return(predicate); }
public IFieldPredicate ExecuteFilter <TEntity, TPrimaryKey>() where TEntity : class, IEntity <TPrimaryKey> { IFieldPredicate predicate = null; if (typeof(TEntity).IsInheritsOrImplements(typeof(IMayHaveTenant)) && IsEnabled) { predicate = Predicates.Field <TEntity>(f => (f as IMayHaveTenant).TenantId, Operator.Eq, TenantId); } return(predicate); }
public IFieldPredicate ExecuteFilter <TEntity>() where TEntity : class { IFieldPredicate predicate = null; if (IsFilterable <TEntity>()) { predicate = Predicates.Field <TEntity>(f => (f as ISoftDelete).IsDeleted, Operator.Eq, IsDeleted); } return(predicate); }
/// <summary> /// 分页查询列表 /// </summary> public async Task <IEnumerable <Message> > GetPageAsync(int page = 1, int pageSize = 10) { using (var connection = new SqlConnection(_connectionString)) { connection.Open(); IFieldPredicate predicate = null; var result = await connection.GetPageAsync <Message>(predicate, page : page, resultsPerPage : pageSize); return(result); } }
/// <summary> /// 查询列表 /// </summary> public async Task <IEnumerable <User> > GetListAsync() { using (var connection = new SqlConnection(_connectionString)) { connection.Open(); IFieldPredicate predicate = null; var result = await connection.GetListAsync <User>(predicate); return(result); } }
private void AddField(MemberExpression exp, Operator op = Operator.Eq, object value = null, bool not = false) { PredicateGroup pg = CurrentGroup; // need convert from Expression<Func<T, bool>> to Expression<Func<T, object>> as this is what Predicates.Field() requires Expression <Func <T, object> > fieldExp = Expression.Lambda <Func <T, object> >(Expression.Convert(exp, typeof(object)), exp.Expression as ParameterExpression); IFieldPredicate field = Predicates.Field(fieldExp, op, value, not); pg.Predicates.Add(field); }
private void AddField(MemberExpression exp, Operator op = Operator.Eq, object value = null, bool not = false) { PredicateGroup pg = _currentGroup; //需要从表达式<func<t,bool>>转换为表达式<func<t,object>>,因为这是谓词.field()所需的 Expression <Func <TEntity, object> > fieldExp = Expression.Lambda <Func <TEntity, object> >(Expression.Convert(exp, typeof(object)), exp.Expression as ParameterExpression); IFieldPredicate field = Predicates.Field(fieldExp, op, value, not); pg.Predicates.Add(field); }
public IEnumerable <T> GetPage(IFieldPredicate predicate, IList <ISort> sort, int page, int resultsPerPage) { try { using (Db) return(Db.GetPage <T>(predicate, sort, page, resultsPerPage)); } catch (Exception) { throw; } }
public IEnumerable <T> GetAll(IFieldPredicate predicate) { try { //using (Db) return(Db.GetList <T>(predicate)); } catch (Exception) { throw; } }
public StatusValuePair <ArchiveEntities> GetByBarcode(string barcode) { if (string.IsNullOrWhiteSpace(barcode) || barcode == default(int).ToString(CultureInfo.InvariantCulture)) { return(new StatusValuePair <ArchiveEntities>(null, ErrorCode.UnknownError)); } IFieldPredicate p = Predicates.Field <ArchiveEntities>(f => f.Barcode, Operator.Eq, barcode); StatusValuePair <ArchiveEntities> result = GetSingle <ArchiveEntities>(p); return(result); }
public UnicornDataProvider(ISerializationProvider serializationProvider, IPredicate predicate, IFieldPredicate fieldPredicate, IUnicornDataProviderLogger logger) { Assert.ArgumentNotNull(serializationProvider, "serializationProvider"); Assert.ArgumentNotNull(predicate, "predicate"); Assert.ArgumentNotNull(fieldPredicate, "fieldPredicate"); Assert.ArgumentNotNull(logger, "logger"); _logger = logger; _predicate = predicate; _fieldPredicate = fieldPredicate; _serializationProvider = serializationProvider; }
private IList<FieldDesynchronization> GetFieldSyncStatus(SitecoreSourceItem item, ISerializedItem serializedItem, IFieldPredicate fieldPredicate) { var desyncs = new List<FieldDesynchronization>(); var serializedVersion = serializedItem.Versions.FirstOrDefault(x => x.VersionNumber == item.InnerItem.Version.Number && x.Language == item.InnerItem.Language.Name); if (serializedVersion == null) { desyncs.Add(new FieldDesynchronization("Version")); return desyncs; } item.InnerItem.Fields.ReadAll(); foreach (Field field in item.InnerItem.Fields) { if (field.ID == FieldIDs.Revision || field.ID == FieldIDs.Updated || field.ID == FieldIDs.Created || field.ID == FieldIDs.CreatedBy || field.ID == FieldIDs.UpdatedBy || field.Type.Equals("attachment", StringComparison.OrdinalIgnoreCase) || !fieldPredicate.Includes(field.ID).IsIncluded) continue; // we're doing a data comparison here - revision, created (by), updated (by) don't matter // skipping these fields allows us to ignore spurious saves the template builder makes to unchanged items being conflicts // find the field in the serialized item in either versioned or shared fields string serializedField; if(!serializedVersion.Fields.TryGetValue(field.ID.ToString(), out serializedField)) serializedItem.SharedFields.TryGetValue(field.ID.ToString(), out serializedField); // we ignore if the field doesn't exist in the serialized item. This is because if you added a field to a template, // that does not immediately re-serialize all items based on that template so it's likely innocuous - we're not overwriting anything. if (serializedField == null) continue; if (!serializedField.Equals(field.Value, StringComparison.Ordinal)) { desyncs.Add(new FieldDesynchronization(field.Name)); } } return desyncs; }
/// <summary> /// Lists the specified predicate. /// </summary> /// <param name="predicate">The predicate.</param> /// <returns>A list.</returns> /// <example> /// Example: /// var predicate = Predicates.Field<Task>(f => f.Active, Operator.Eq, true); /// IEnumerable<Task> list = repository.List<Task>(predicate); /// https://github.com/tmsmith/Dapper-Extensions/wiki/Predicates /// . /// </example> public IEnumerable<Task> GetList(IFieldPredicate predicate) { using (var con = this._connection.Create()) { con.Open(); return con.GetList<Task>(predicate).ToList(); } }