public IEnumerable <Employee> Filter(FilterModel model, string[] includes = null) { Expression <Func <Employee, bool> > FilterExpression(FilterModel _model) { Expression <Func <Employee, bool> > expression = null; if (_model == null) { return(null); } if (!String.IsNullOrEmpty(_model.Name)) { expression = x => x.Name.Contains(_model.Name.ToString()); } if (!String.IsNullOrEmpty(_model.Position)) { expression = ExpressionCombiner.And <Employee>(expression, x => x.Position.Contains(_model.Position.ToString())); } return(expression); } var result = base.Filter(FilterExpression(model), includes); return(result); }
public void WillThrowOnIncompatibleExpressions() { var combiner = new ExpressionCombiner <Foo, Bar>(); Expression <Func <Foo, Bar> > source = (x) => new Bar { A = x.A }; Expression <Func <Foo, Bar> > target = (x) => null; Assert.Throws <ArgumentException>(() => { combiner.CombineIntoMapperWithConstructor(source, target); }); var existing = new Bar(); Expression <Func <Foo, Bar> > source2 = (x) => existing; Expression <Func <Foo, Bar> > target2 = (x) => new Bar { B = x.B }; Assert.Throws <ArgumentException>(() => { combiner.CombineIntoMapperWithConstructor(source, target); }); }
public void CanMergeTwoBasciMemberInitLambdas() { var combiner = new ExpressionCombiner <Foo, Bar>(); Expression <Func <Foo, Bar> > source = (x) => new Bar { A = x.A }; Expression <Func <Foo, Bar> > target = (x) => new Bar { B = x.B }; var combined = combiner.CombineIntoMapperWithConstructor(source, target); Assert.AreEqual(combined.ToString(), "x => new Bar() {A = x.A, B = x.B}"); Expression <Func <Foo, Bar> > source2 = (x) => new Bar() { A = x.A }; Expression <Func <Foo, Bar> > target2 = (x) => new Bar() { B = x.B }; var combined2 = combiner.CombineIntoMapperWithConstructor(source2, target2); Assert.AreEqual(combined.ToString(), "x => new Bar() {A = x.A, B = x.B}"); }
public void CanProduceMapperExpressionForExistingClasses() { var combiner = new ExpressionCombiner <Foo, Bar>(); Expression <Func <Foo, Bar> > a = (x) => new Bar { A = x.A, E = new Bar { A = 1 } }; Expression <Func <Foo, Bar> > b = (x) => new Bar { B = x.B }; var combined = combiner.CombineIntoMapperForExisting(a, b); var foo = new Foo() { A = 5, B = 10 }; var bar = new Bar(); combined.Compile().Invoke(foo, bar); Assert.AreEqual(bar.A, 5); Assert.AreEqual(bar.B, 10); Assert.NotNull(bar.E); Assert.AreEqual(bar.E.A, 1); }
private Expression <Func <Gig, bool> > _getMyAttendingGigFilterExpression(GigFilterParams filter) { Expression <Func <Gig, bool> > filterExpression = g => g.DateTime > DateTime.Now; return(string.IsNullOrWhiteSpace(filter.SearchTerm) ? filterExpression : ExpressionCombiner.And(filterExpression, getSeachFilter(filter))); }
private Expression <Func <Gig, bool> > _getGigFilterExpression(GigFilterParams filter) { Expression <Func <Gig, bool> > filterExpression = g => g.DateTime > DateTime.Now && g.Artist.Activated && !g.IsCancelled; return(string.IsNullOrWhiteSpace(filter.SearchTerm) ? filterExpression : ExpressionCombiner.And(filterExpression, getSeachFilter(filter))); }
public void DoesNotThrowOnEmptyInitializers() { var combiner = new ExpressionCombiner <Foo, Bar>(); Expression <Func <Foo, Bar> > source = (x) => new Bar { }; Expression <Func <Foo, Bar> > target = (x) => new Bar { }; var combined = combiner.CombineIntoMapperWithConstructor(source, target); Assert.AreEqual(combined.ToString(), "x => new Bar() {}"); }
/// <summary> /// Deletes all matching entities permanently for given predicate /// </summary> /// <typeparam name="TEntity">Entity type</typeparam> /// <typeparam name="TPrimaryKey">Primary key type</typeparam> /// <param name="repository">Repository</param> /// <param name="predicate">Predicate to filter entities</param> /// <returns></returns> public static async Task <int> BatchDeleteAsync <TEntity, TPrimaryKey>([NotNull] this IRepository <TEntity, TPrimaryKey> repository, [NotNull] Expression <Func <TEntity, bool> > predicate) where TEntity : Entity <TPrimaryKey> { Check.NotNull(repository, nameof(repository)); Check.NotNull(predicate, nameof(predicate)); var query = repository.GetAll().IgnoreQueryFilters(); var abpFilterExpression = GetFilterExpressionOrNull <TEntity, TPrimaryKey>(repository.GetIocResolver()); var filterExpression = ExpressionCombiner.Combine(predicate, abpFilterExpression); query = query.Where(filterExpression); return(await query.DeleteAsync()); }
public void CanMergeTwoAdvancedMemberInitLambdas() { var combiner = new ExpressionCombiner <Foo, Bar>(); Expression <Func <Foo, Bar> > source = (x) => new Bar { E = new Bar { A = 1 } }; Expression <Func <Foo, Bar> > target = (x) => new Bar { A = x.D.FirstOrDefault() }; var combined = combiner.CombineIntoMapperWithConstructor(source, target); Assert.AreEqual(combined.ToString(), "x => new Bar() {E = new Bar() {A = 1}, A = x.D.FirstOrDefault()}"); }
private static Expression <Func <TEntity, bool> > GetFilterExpressionOrNull <TEntity, TPrimaryKey>(IIocResolver iocResolver) where TEntity : Entity <TPrimaryKey> { Expression <Func <TEntity, bool> > expression = null; using (var scope = iocResolver.CreateScope()) { var currentUnitOfWorkProvider = scope.Resolve <ICurrentUnitOfWorkProvider>(); if (typeof(ISoftDelete).IsAssignableFrom(typeof(TEntity))) { var isSoftDeleteFilterEnabled = currentUnitOfWorkProvider.Current?.IsFilterEnabled(AbpDataFilters.SoftDelete) == true; if (isSoftDeleteFilterEnabled) { Expression <Func <TEntity, bool> > softDeleteFilter = e => !((ISoftDelete)e).IsDeleted; expression = softDeleteFilter; } } if (typeof(IMayHaveTenant).IsAssignableFrom(typeof(TEntity))) { var isMayHaveTenantFilterEnabled = currentUnitOfWorkProvider.Current?.IsFilterEnabled(AbpDataFilters.MayHaveTenant) == true; var currentTenantId = GetCurrentTenantIdOrNull(iocResolver); if (isMayHaveTenantFilterEnabled) { Expression <Func <TEntity, bool> > mayHaveTenantFilter = e => ((IMayHaveTenant)e).TenantId == currentTenantId; expression = expression == null ? mayHaveTenantFilter : ExpressionCombiner.Combine(expression, mayHaveTenantFilter); } } if (typeof(IMustHaveTenant).IsAssignableFrom(typeof(TEntity))) { var isMustHaveTenantFilterEnabled = currentUnitOfWorkProvider.Current?.IsFilterEnabled(AbpDataFilters.MustHaveTenant) == true; var currentTenantId = GetCurrentTenantIdOrNull(iocResolver); if (isMustHaveTenantFilterEnabled) { Expression <Func <TEntity, bool> > mustHaveTenantFilter = e => ((IMustHaveTenant)e).TenantId == currentTenantId; expression = expression == null ? mustHaveTenantFilter : ExpressionCombiner.Combine(expression, mustHaveTenantFilter); } } } return(expression); }
public void WillThrowOnConstructorsWithArguments() { var combiner = new ExpressionCombiner <Foo, Bar>(); Expression <Func <Foo, Bar> > source = (x) => new Bar(1) { B = x.B }; Expression <Func <Foo, Bar> > target = (x) => new Bar() { C = x.C }; Assert.Throws <ArgumentException>(() => { combiner.CombineIntoMapperWithConstructor(source, target); }); }
public Expression <Func <T, bool> > ToExpression <T>() where T : class { if (Filters.Count == 0) { return(x => true); } if (Filters.Count == 1) { return(Filters.First().ToExpression <T>()); } Expression <Func <T, bool> > expression = Filters.First().ToExpression <T>(); expression = Filters.ToList() .Skip(1) .Aggregate(expression, (current, filter) => Logic == FilterLogic.And ? ExpressionCombiner.And(current, filter.ToExpression <T>()) : ExpressionCombiner.Or(current, filter.ToExpression <T>())); return(expression); }
public IEnumerable <ApplicationUser> GetUsersByRoleId(string roleId, string query = null) { Expression <Func <ApplicationUser, bool> > filterExpression = u => u.Activated && u.Roles.Any(r => r.RoleId == roleId); if (query == null) { return(_context.Users .Where(filterExpression) .OrderBy(u => u.Name).ToList()); } { Expression <Func <ApplicationUser, bool> > nameFilter = u => u.Name.Contains(query); filterExpression = ExpressionCombiner.And(filterExpression, nameFilter); } return(_context.Users .Where(filterExpression) .OrderBy(u => u.Name).ToList()); }
protected virtual Expression <Func <T, bool> > CombineExpressions <T>(Expression <Func <T, bool> > expression1, Expression <Func <T, bool> > expression2) { return(ExpressionCombiner.Combine(expression1, expression2)); }
/// <summary> /// 合并表达式 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="expression1"></param> /// <param name="expression2"></param> /// <returns></returns> public static Expression <Func <T, bool> > CombineExpressions <T>(this Expression <Func <T, bool> > expression1, Expression <Func <T, bool> > expression2) { return(ExpressionCombiner.Combine(expression1, expression2)); }