private ICollection <WebAPIDto <THeader> > AttachTenantFilter(IEnumerable <WebAPIDto <THeader> > source) { if (FilterExpressions == null || !FilterExpressions.Any(x => x.Key.Contains("TenantModel"))) { return(source.ToList()); } try { foreach (KeyValuePair <string, IFilterExpression> filter in FilterExpressions.Where(x => x.Key.Contains("TenantModel"))) { ParameterExpression param = Expression.Parameter(typeof(WebAPIDto <THeader>), "x"); string[] parts = filter.Value.PropertyName.Replace("Entity.", "").Split('.'); Expression parent = param; foreach (string part in parts) { parent = Expression.Property(parent, part); } ConstantExpression constant = Expression.Constant(filter.Value.FilterValue); Expression expr = Expression.Equal(parent, constant); source = source.AsQueryable().Where(Expression.Lambda <Func <WebAPIDto <THeader>, bool> >(expr, param)); } } catch (Exception ex) { throw new DocSuiteException("Errore filtro", "Espressione di filtro non corretta", ex); } return(source.ToList()); }
/// <summary> /// Filters a sequence of values based on a predicate. /// </summary> /// <param name="predicate">A lambda expression to test each element for a condition.</param> /// <returns>A new query instance containing all specified query parameters.</returns> public IQuery Where(LambdaExpression predicate) { var filterExpressions = FilterExpressions.ToList(); filterExpressions.Add(predicate); var query = new Query(Type, filterExpressions, SortExpressions, SkipValue, TakeValue); return(query); }
public override int GetHashCode() { unchecked { var hashCode = OriginalText.GetHashCode(); hashCode = (hashCode * 397) ^ (Expression != null ? Expression.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (FilterExpressions != null ? FilterExpressions.GetHashCode() : 0); return(hashCode); } }
/// <summary> /// Filters a sequence of values based on a predicate. /// </summary> /// <param name="predicate">A function to test each element for a condition.</param> /// <returns>A new query instance containing all specified query parameters</returns> public IQuery <T> Where(Expression <Func <T, bool> > predicate) { var filter = _expressionTranslator(predicate); var filterExpressions = FilterExpressions.ToList(); filterExpressions.Add(filter); var query = new Query <T>(_dataProvider, _expressionTranslator, filterExpressions, SortExpressions, SkipValue, TakeValue); return(query); }
/// <summary> /// Creates the subscription for service. /// </summary> /// <param name="pubSubChannel">The pub sub channel.</param> /// <param name="p">The p.</param> private void CreateSubscriptionForService(ServiceBusPublishSubscribeChannel pubSubChannel, string serviceName) { //Define a filter to receive only messages that have a specific "To" property var filter = FilterExpressions.GroupOr( FilterExpressions.MatchTo(serviceName), FilterExpressions.MatchTo("ServiceRouter")); //Now we need to create an observer, that will check for new incoming messages modelObserver = Observer.Create <RouteMeModel>(msg => { var exists = CheckIfRoutingEntryExists(msg); if (!exists) { AddNewServiceEntry(msg); } }); pubSubChannel.Subscribe(serviceName, modelObserver, filter); }
protected virtual bool AttachFilterExpressions(ref IODATAQueryManager odataQuery) { if (FilterExpressions == null) { return(false); } try { foreach (KeyValuePair <string, IFilterExpression> filter in FilterExpressions.Where(x => !x.Key.Contains("TenantModel"))) { string expr = GetExpression(filter.Value); odataQuery.Filter(expr); } } catch (Exception ex) { throw new DocSuiteException("Errore filtro", "Espressione di filtro non corretta", ex); } return(true); }
// Constructors public PagedList(IQueryable <T> source, FilterContainer container) { if (container == null) { AddRange(source); } else { var predicate = FilterExpressions.PreparePredicate(source, container.FilterQueries); var ordered = FilterOrdered.OrderedQueryable(container, source); if (container.FilterPage.IsPagedList) { PageNumber = container.FilterPage.PageNumber; PageSize = container.FilterPage.PageSize; var total = source.Count(); TotalCount = total; TotalPages = total / PageSize; if (total % PageSize > 0) { TotalPages++; } var paged = FilterPaged.GetPagedResult(container, ordered.Where(predicate)); AddRange(paged); } else { AddRange(ordered); } } }
public ActionResult Page(int startRow, int endRow, SortEntry[] sortModel, Dictionary <string, FilterEntry> filterModel, string globalFilter) { IQueryable <Connection> query = connectionRepository.GetConnections(); // if filters aren't posted, in filters we get values from MVC; with "action", "controller" as keys; they must be excluded, currently by their null value criterion foreach (var kvp in filterModel.Where(x => x.Value != null)) { // get expression for this column LambdaExpression columnExpression = columnSource[kvp.Key]; // convert grid-specific filter to an universal entry UniversalFilterEntry universalFilterEntry = FilterEntryConverter.Convert(kvp.Value); // check whether the entry was parsed successfully if (universalFilterEntry == null) { continue; } // get the fltering expression from universalFilterEntry Expression <Func <Connection, bool> > filterExpression = FilterExpressions <Connection> .GetFilterExpression(columnExpression, universalFilterEntry); // and apply it to the query query = query.Where(filterExpression); } // global filtering if (String.IsNullOrWhiteSpace(globalFilter) == false) { query = query.Where(x => x.Name.Contains(globalFilter) || x.PPE.Contains(globalFilter) || x.MeterCode.Contains(globalFilter) || x.Company.Acronym.Contains(globalFilter) || x.Tariff.Name.Contains(globalFilter)); } int count = query.Count(); if (sortModel != null) { for (int i = 0; i < sortModel.Length; i++) { SortEntry sortEntry = sortModel[i]; string column = sortEntry.colId; bool isAsc = sortEntry.sort == SortEntry.asc; bool isFirst = i == 0; LambdaExpression columnExpression = columnSource[column]; query = SortHelper.ApplyOrderByFromLambda(query, columnExpression, isAsc, isFirst); } } else { query = query.OrderBy(x => x.Name); } var r = query.Skip(startRow).Take(endRow - startRow).Select(x => new { id = x.Id, ppe = x.PPE, meterCode = x.MeterCode, name = x.Name, tariff = x.Tariff.Name, company = x.Company.Acronym, startDate = x.StartDate, endDate = x.EndDate, orderedCapacity = x.OrderedCapacity, endDateNullable = x.EndDate, orderedCapacityNullable = x.OrderedCapacity, isActive = x.Name.Length % 2 == 0 // fake boolean column }).ToArray(); var response = new { rows = r, count = count }; return(new JsonNetResult(response)); }
protected bool Equals(PageVariableFragment other) { return(OriginalText.Span.SequenceEqual(other.OriginalText.Span) && Equals(Expression, other.Expression) && FilterExpressions.EquivalentTo(other.FilterExpressions)); }
public Query <T> OrFilter(Expression <Func <T, bool> > filter) { FilterExpressions = FilterExpressions.Or(filter); return(this); }
public virtual void AddFilterExpression(Expression <Func <T, bool> > filter) { FilterExpressions.Add(filter); }
/// <summary> /// Pulizia dei filtri /// </summary> public virtual void FilterExpressionsClear() { FilterExpressions.Clear(); CriteriaFilterExpressions.Clear(); }