public static FilterProviderBase GetFilterProvider(string tableName, string filterMemberName, StatementContext modify)
{
FilterProviderBase provider = Providers.Cast <FilterProviderBase>().FirstOrDefault(probase => (probase.ObjectType == null || probase.ObjectType.Name == tableName) && probase.FilterMemberName == filterMemberName && (probase.StatementContext == modify || probase.StatementContext == StatementContext.Both));
if (provider != null && HasFilterValue(provider) && !provider.UseFilterValueWhenNull)
{
return(null);
}
return(provider);
}
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 (Attribute 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));
}
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());
}
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;
}
static bool HasFilterValue(FilterProviderBase provider) {
return provider.FilterValue == null || (provider.FilterValue is ICollection && ((ICollection)provider.FilterValue).Count == 0);
}
static bool HasFilterValue(FilterProviderBase provider)
{
return(provider.FilterValue == null || (provider.FilterValue is ICollection && ((ICollection)provider.FilterValue).Count == 0));
}
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);
}
public void CopyTo(FilterProviderBase[] array, int index)
{
base.CopyTo(array, index);
}
void ApplyCondition(SelectStatement statement, FilterProviderBase providerBase, string nodeAlias) {
var objectType = GetObjectType(statement.TableName);
if (FilteredByKey(statement, objectType)) return;
CriteriaOperator condition = null;
if (providerBase.FilterValue is IList) {
CriteriaOperator criteriaOperator = ((IEnumerable)providerBase.FilterValue).Cast<object>().Aggregate<object, CriteriaOperator>(null, (current, value)
=> current | (
value == null
? (CriteriaOperator)new QueryOperand(providerBase.FilterMemberName, nodeAlias).IsNull()
: new QueryOperand(providerBase.FilterMemberName, nodeAlias) == new OperandValue( value)));
criteriaOperator = new GroupOperator(criteriaOperator);
condition = criteriaOperator;
} else
condition = new QueryOperand(providerBase.FilterMemberName, nodeAlias) == (providerBase.FilterValue == null ? null : providerBase.FilterValue.ToString());
if (objectType != null)
{
var typeInfo = XafTypesInfo.CastTypeToTypeInfo(objectType);
if (typeInfo.OwnMembers.FirstOrDefault(x=>x.Name == "ObjectType") != null)
{
var excludes = new List<Type>();
foreach (var item in _BaseTypesDictionary.Where(x => x.Value == typeInfo).Select(x => x.Key))
{
if (FilterProviderManager.GetFilterProvider(item.Type,providerBase.FilterMemberName,StatementContext.Select) == null)
excludes.Add(item.Type);
}
if (excludes.Count > 0)
{
var table = XafTypesInfo.XpoTypeInfoSource.GetEntityClassInfo(typeof(XPObjectType)).Table;
statement.SubNodes.Add(new JoinNode(table,"OT",JoinType.Inner){Condition = new QueryOperand("ObjectType",statement.Alias) == new QueryOperand("OId","OT")});
condition |= new InOperator(new QueryOperand("TypeName","OT"),excludes.Select(x=>new OperandValue( x.FullName)).ToArray());
}
}
}
statement.Condition &= new GroupOperator(condition);
}
