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