void CreateMembers(ITypesInfo typesInfo)
{
foreach (FilterProviderBase provider in FilterProviderManager.Providers)
{
FilterProviderBase provider1 = provider;
foreach (ITypeInfo typeInfo in typesInfo.PersistentTypes.Where(typeInfo => TypeMatch(typeInfo, provider1)))
{
CreateMember(typeInfo, provider);
}
}
}
void CreateMembers(ITypesInfo typesInfo)
{
foreach (FilterProviderBase provider in FilterProviderManager.Providers)
{
FilterProviderBase provider1 = provider;
foreach (ITypeInfo typeInfo in typesInfo.PersistentTypes.Where(
typeInfo => (provider1.ObjectType == null || provider1.ObjectType == typeInfo.Type) && typeInfo.FindMember(provider1.FilterMemberName) == null && typeInfo.IsPersistent))
{
CreateMember(typeInfo, provider);
}
}
}
void ApplyCondition(SelectStatement statement, FilterProviderBase providerBase, string nodeAlias)
{
if (providerBase.FilterValue is IList)
{
CriteriaOperator criteriaOperator = ((IEnumerable)providerBase.FilterValue).Cast <object>().Aggregate <object, CriteriaOperator>(null, (current, value)
=> current | new QueryOperand(providerBase.FilterMemberName, nodeAlias) == value.ToString());
criteriaOperator = new GroupOperator(criteriaOperator);
statement.Condition &= criteriaOperator;
}
else
{
statement.Condition &= new QueryOperand(providerBase.FilterMemberName, nodeAlias) == (providerBase.FilterValue == null ? null : providerBase.FilterValue.ToString());
}
}
public void InsertData(IList <InsertStatement> statements)
{
foreach (InsertStatement statement in statements)
{
if (!IsSystemTable(statement.TableName))
{
List <QueryOperand> operands = statement.Operands.OfType <QueryOperand>().ToList();
for (int i = 0; i < operands.Count(); i++)
{
FilterProviderBase providerBase =
FilterProviderManager.GetFilterProvider(statement.TableName, operands[i].ColumnName, StatementContext.Insert);
if (providerBase != null && !FilterIsShared(statements, providerBase))
{
statement.Parameters[i].Value = GetModifyFilterValue(providerBase);
}
}
}
}
}
public SelectStatement ApplyCondition(SelectStatement statement)
{
var extractor = new CriteriaOperatorExtractor();
extractor.Extract(statement.Condition);
foreach (FilterProviderBase provider in FilterProviderManager.Providers)
{
FilterProviderBase providerBase = FilterProviderManager.GetFilterProvider(statement.TableName, provider.FilterMemberName, StatementContext.Select);
if (providerBase != null)
{
IEnumerable <BinaryOperator> binaryOperators = GetBinaryOperators(extractor, providerBase);
if (!FilterIsShared(statement.TableName, providerBase.Name) && !binaryOperators.Any())
{
string nodeAlias = GetNodeAlias(statement, providerBase);
ApplyCondition(statement, providerBase, nodeAlias);
}
}
}
return(statement);
}
public static void CreateMember(ITypeInfo typeInfo, FilterProviderBase provider)
{
var attributes = new List <Attribute> {
new BrowsableAttribute(false), new MemberDesignTimeVisibilityAttribute(
false)
};
IMemberInfo member = typeInfo.CreateMember(provider.FilterMemberName, provider.FilterMemberType);
if (provider.FilterMemberIndexed)
{
attributes.Add(new IndexedAttribute());
}
if (provider.FilterMemberSize != SizeAttribute.DefaultStringMappingFieldSize)
{
attributes.Add(new SizeAttribute(provider.FilterMemberSize));
}
foreach (var attribute in attributes)
{
member.AddAttribute(attribute);
}
}
string GetNodeAlias(SelectStatement statement, FilterProviderBase providerBase)
{
return(statement.Operands.OfType <QueryOperand>().Where(operand
=> operand.ColumnName == providerBase.FilterMemberName).Select(operand
=> operand.NodeAlias).FirstOrDefault() ?? GetNodeAlias(statement, providerBase.FilterMemberName));
}
IEnumerable <BinaryOperator> GetBinaryOperators(CriteriaOperatorExtractor extractor, FilterProviderBase providerBase)
{
return(extractor.BinaryOperators.Where(
@operator =>
@operator.RightOperand is OperandValue &&
ReferenceEquals(((OperandValue)@operator.RightOperand).Value, providerBase.FilterMemberName)));
}
bool FilterIsShared(IEnumerable <InsertStatement> statements, FilterProviderBase providerBase)
{
return(statements.Aggregate(false, (current, insertStatement) => current & FilterIsShared(insertStatement.TableName, providerBase.Name)));
}
object GetModifyFilterValue(FilterProviderBase providerBase)
{
return(providerBase.FilterValue is IList
? ((IList)providerBase.FilterValue).OfType <object>().FirstOrDefault()
: providerBase.FilterValue);
}
bool TypeMatch(ITypeInfo typeInfo, FilterProviderBase provider1)
{
return(((!typeInfo.IsInterface && provider1.ObjectType == null || provider1.ObjectType == typeInfo.Type) && typeInfo.FindMember(provider1.FilterMemberName) == null && typeInfo.IsPersistent) && !ModelSystemTablesNodesGenerator.SystemTables.Contains(typeInfo.Name));
}
