public void AddSimpleFilter(IFilterInfo f1)
{
if (f1.IsFilterEnable)
{
this.CurrentStatementGroup.Add(f1);
}
}
public void AddExistFilter(IFilterInfo f1)
{
if (f1.IsFilterEnable)
{
this._statements.Add(f1.FilterInfos.ToList());
}
}
/// <summary>
/// Initializes a new instance of the <see cref="FilterViewModel"/> class.
/// </summary>
/// <param name="filterInfo">The filter information.</param>
/// <param name="filterType">Type of the filter.</param>
public FilterViewModel(IFilterInfo filterInfo, FilterType filterType)
{
if (filterInfo == null)
return;
IsAdmin = filterInfo.IsAdminFilter.HasValue && filterInfo.IsAdminFilter.Value;
_filterType = filterType;
OriginalName = _name = filterInfo.Name;
Id = filterInfo.Id;
_originalFilterDefinitions = filterInfo.FilterDefinition;
SortDescriptors = filterInfo.SortDescriptors;
GroupColumn = filterInfo.GroupColumn;
FilterGuid = filterInfo.Guid;
DefaultLayoutId = filterInfo.DefaultLayoutId == 0 ? (int?) null : filterInfo.DefaultLayoutId;
Layout = filterInfo.DefaultLayout;
if (filterInfo.QuickFilterId != null)
{
QuickFilterId = filterInfo.QuickFilterId.Value;
if ((QuickFilters) QuickFilterId.Value != QuickFilters.None)
QuickFilter = (QuickFilters) QuickFilterId.Value;
}
}
private Expression GetExpression(ParameterExpression param, IFilterInfo statement, string propertyName = null)
{
Expression resultExpr = null;
var memberName = propertyName ?? statement.PropertyName;
MemberExpression member = param.GetMemberExpression(memberName);
if (Nullable.GetUnderlyingType(member.Type) != null && statement.Value != null)
{
resultExpr = Expression.Property(member, "HasValue");
member = Expression.Property(member, "Value");
}
var constant1 = Expression.Constant(statement.Value);
var constant2 = Expression.Constant(statement.Value2);
this.CheckPropertyValueMismatch(member, constant1);
var safeStringExpression = statement.Operation.GetExpression(member, constant1, constant2);
resultExpr = resultExpr != null?Expression.AndAlso(resultExpr, safeStringExpression) : safeStringExpression;
resultExpr = this.GetSafePropertyMember(param, memberName, resultExpr);
if (statement.Operation.ExpectNullValues && memberName.Contains("."))
{
resultExpr = Expression.OrElse(this.CheckIfParentIsNull(param, memberName), resultExpr);
}
return(resultExpr);
}
public void Add(IFilterInfo info)
{
var predicate = _filterBuilder.BuildFromString(info.Property, info.Operator, info.Value);
if (predicate == null)
{
// Log warning? throw exception to log a warning?
}
else
{
Add(predicate);
}
}
private Expression ProcessListStatement(ParameterExpression param, IFilterInfo statement)
{
var basePropertyName = statement.PropertyName.Substring(0, statement.PropertyName.IndexOf("["));
var propertyName = statement.PropertyName.Substring(statement.PropertyName.IndexOf("[") + 1).Replace("]", string.Empty);
var type = param.Type.GetProperty(basePropertyName).PropertyType.GetGenericArguments()[0];
ParameterExpression listItemParam = Expression.Parameter(type, "i");
var lambda = Expression.Lambda(this.GetExpression(listItemParam, statement, propertyName), listItemParam);
var member = param.GetMemberExpression(basePropertyName);
var enumerableType = typeof(Enumerable);
var anyInfo = enumerableType.GetMethods(BindingFlags.Static | BindingFlags.Public).First(m => m.Name == "Any" && m.GetParameters().Count() == 2);
anyInfo = anyInfo.MakeGenericMethod(type);
return(Expression.Call(anyInfo, member, lambda));
}
public Filter(IFilterInfo f1, IFilterInfo f2, Connector connector)
{
this._statements = new List <List <IFilterInfo> > {
new List <IFilterInfo>()
};
this.CurrentStatementGroup.Add(f1);
var connection = new FilterStatementConnection(this, f1);
if (connector == Connector.Or)
{
connection.Or.By(f2);
}
else
{
connection.And.By(f2);
}
}
public bool SetSource(string FileName)
{
try
{
FilterGraph = new FilgraphManager();
object ppUnk = null;
FilterGraph.AddSourceFilter(FileName, out ppUnk);
FilterGraph.RenderFile(FileName);
IFilterInfo Info = (IFilterInfo)ppUnk;
TestControl = Info.Filter as ITestControl;
BasicAudio = FilterGraph as IBasicAudio;
VideoWindow = FilterGraph as IVideoWindow;
MediaControl = FilterGraph as IMediaControl;
}
catch (Exception ex)
{
Clear();
return(false);
}
return(true);
}
public IFilterStatementConnection By(IFilterInfo statement)
{
this.CurrentStatementGroup.Add(statement);
return(new FilterStatementConnection(this, statement));
}
public IntegerExistsInFilter(Expression <Func <T, ICollection <TCollection> > > expression, IFilterInfo filter)
: base(expression, filter)
{
}
private static Filter CreateFilter(IFilterInfo filter, QuickFilters quickFilter)
{
return new Filter
{
ProcessSystemName = filter.ProcessSystemName,
Id = filter.Id,
Name = filter.Name,
FilterDefinition = ConvertMemberTypesToDataTypes(filter.FilterDefinition),
IsAdminFilter = filter.IsAdminFilter ?? false,
LayoutId = ToNullable(filter.DefaultLayoutId),
QuickFilter = quickFilter
};
}
private bool IsList(IFilterInfo statement)
{
return(statement.PropertyName.Contains("[") && statement.PropertyName.Contains("]"));
}
/// <summary>
/// Initializes a new instance of the <see cref="FilterStatementConnection"/> class.
/// </summary>
/// <param name="filter"></param>
/// <param name="statement"></param>
internal FilterStatementConnection(IFilter filter, IFilterInfo statement)
{
this._filter = filter;
this._statement = statement;
}
/// <summary>
/// Creates filter metadata.
/// </summary>
/// <param name="filter">
/// The filter.
/// </param>
/// <param name="includeParameters">
/// True to include parameter metadata; otherwise, false.
/// </param>
/// <param name="includeParameterValues">
/// True to include parameter values; otherwise, false.
/// </param>
/// <returns>
/// The <see cref="FilterMetadata"/>.
/// </returns>
public FilterMetadata CreateFilterMetadata(IFilterInfo filter, bool includeParameters, bool includeParameterValues)
{
var layoutId = filter.DefaultLayoutId > 0 ? (int?)filter.DefaultLayoutId : null;
var filterMetadata = new FilterMetadata { Id = filter.Id, Name = filter.Name, LayoutId = layoutId };
if (includeParameters)
{
var processMetadata = ProcessMetadataRepository.GetProcessMetadata(filter.ProcessSystemName);
var filterDescriptor = FilterDescriptorFactory.CreateFilterFromJSON(filter.FilterDefinition);
filterMetadata.Parameters.AddRange(
filterDescriptor.GetUdpDescriptors()
.Select(x => x.Value)
.OfType<FilterValue>()
.Select(filterValue => CreateParameterMetadata(processMetadata, filterValue, includeParameterValues)));
}
return filterMetadata;
}
///<summary>
///根据模型生成 Filter 表达式
///</summary>
protected List <Expression <Func <TEntity, bool> > > BuildFilterInfo <TEntity>(IViewModel vm, IFilterInfo filterInfo)
{
//将条件按照列组合起来
if (filterInfo.Filters != null && filterInfo.Filters.Count() > 0)
{
return(BuildWhereExpression <TEntity>(vm, filterInfo.Filters));
}
return(null);
}
/// <summary>
/// Creates filter metadata.
/// </summary>
/// <param name="filter">
/// The filter.
/// </param>
/// <param name="includeParameters">
/// True to include parameter metadata; otherwise, false.
/// </param>
/// <param name="includeParameterValues">
/// True to include parameter values; otherwise, false.
/// </param>
/// <returns>
/// The <see cref="FilterMetadata"/>.
/// </returns>
public FilterMetadata CreateFilterMetadata(IFilterInfo filter, bool includeParameters, bool includeParameterValues)
{
return FilterMetadataFactory.CreateFilterMetadata(filter, includeParameters, includeParameterValues);
}
public BaseCollectionExistsInFilter(Expression <Func <T, ICollection <TCollection> > > expression, IFilterInfo filter)
{
this.Connector = Connector.And;
this.Operation = filter.Operation;
string name = expression.ToString().Split('.')[1] + $"[{filter.PropertyName}]";
this.FilterInfos = new List <IFilterInfo>
{
new FilterInfo <TPropertyType>(name, this.Operation, filter.Value)
};
this.IsFilterEnable = filter.Value != null;
}
/// <summary>
/// Initializes a new instance of the <see cref="FilterViewModel"/> class.
/// </summary>
/// <param name="filterInfo">The filter information.</param>
public FilterViewModel(IFilterInfo filterInfo)
{
_name = filterInfo.Name;
Id = filterInfo.Id;
_originalFilterDefinitions = filterInfo.FilterDefinition;
}
