public override WSFilter GetCustomFilter(Expression parent, int level)
{
try
{
if (parent != null && IsFiltrable && EntitySchema != null)
{
level++;
Expression member = Expression.Property(parent, Param.WSColumnRef.NAME);
if (member != null)
{
ParameterExpression id = Expression.Parameter(EntitySchema.Source.ReturnType, level.ToHex());
WSFilter subFilter = EntitySchema.GetCustomFilter(id, level);
if (subFilter != null && subFilter.IsValid)
{
dynamic subExpr = subFilter.GetType().GetMethod("ToLambda").MakeGenericMethod(new Type[] { EntitySchema.Source.ReturnType }).Invoke(subFilter, new object[] { id });
return(new WSEntityListFFilter(Param, member, WSEntityListFFilter.OPERATIONS.Any)
{
Value = (subExpr == null) ? true : subExpr
});
}
}
}
}
catch (Exception e) { WSStatus status = WSStatus.NONE.clone(); Func.RegError(GetType(), e, ref status); }
return(null);
}
public WSFilter GetMainFilter(WSRequest Request, Expression _EntityExpression, int _level)
{
WSCombineFilter mainFilter = new WSCombineFilter(WSCombineFilter.SQLMode.AndAlso);
WSFilter BaseFilter = GetBaseFilter(Request, _EntityExpression, _level);
if (BaseFilter != null && BaseFilter.IsValid) { mainFilter.Save(BaseFilter); }
WSFilter CustomFilter = GetCustomFilter(_EntityExpression, _level);
if (CustomFilter != null && CustomFilter.IsValid) { mainFilter.Save(CustomFilter); }
return mainFilter != null && mainFilter.IsValid ? mainFilter.Reduce() : null;
}
public override WSFilter GetFieldFilter(MetaFunctions CFunc, WSTableParam param, Expression parent, int level, string state = null, bool?negate = null)
{
try
{
///**************************************************
//* if(filter array contains any conditional 'IOJFilter'
//* like : "[{option_name1:value1},{option_name2:value2}]" (example:"[{max:123},{min:123}]") , - then use 'CombineMode.AndAlso'
//* else
//* (if all values in the filter array are simple type values)
//* like : "{value1,value2,value3,...}" ,- use 'CombineMode.Or'
//* ***********************************************/
WSCombineFilter filter = new WSCombineFilter(WSCombineFilter.SQLMode.OrElse, negate);
foreach (WSJson j in Value)
{
WSFilter jFilter = j.GetFieldFilter(CFunc, param, parent, level, state, negate);
filter.Save(jFilter);
}
return(filter.Any() ? (filter.Count == 1 && !filter.Negate) ? filter.FirstOrDefault() : filter : null);
}
catch (Exception e) { WSStatus status = WSStatus.NONE.clone(); CFunc.RegError(GetType(), e, ref status); }
return(null);
}
public override WSFilter GetCustomFilter(Expression parent, int level)
{
WSFilter filter = !IsFiltrable ? null : IOBaseOptions.GetFieldFilter(Func, param, parent, level);
return(filter != null && filter.IsValid ? filter : null);
}
public override WSFilter GetFieldFilter(MetaFunctions CFunc, WSTableParam param, Expression parent, int level, string state = null, bool?negate = null)
{
WSCombineFilter filter = new WSCombineFilter(WSCombineFilter.SQLMode.AndAlso);
try
{
if (param != null && param.isValid && (param.DataType.IsNullable() || Value != null))
{
if (param.DataType.IsSimple())
{
bool localNegate = WSConstants.ALIACES.NOT.Match(state);
negate = negate == null ? localNegate : localNegate != negate;
WSFilter pFilter = Value.GetFieldFilter(CFunc, param, parent, level, Key, negate);
filter.Save(pFilter);
}
else if (param.DataType.IsSameOrSubclassOf(typeof(WSEntity)) || param.DataType.IsCollectionOf <WSEntity>())
{
if (WSConstants.ALIACES.NOT.Match(Key))
{
return(Value.GetFieldFilter(CFunc, param, parent, level, state, true));
}
else if (WSConstants.ALIACES.ANY.Match(Key))
{
return(Value.GetFieldFilter(CFunc, param, parent, level, Key, true));
}
else
{
WSTableSource PSource = (WSTableSource)CFunc.GetSourceByType/*<WSTableSource>*/ (param.DataType.GetEntityType());
WSTableParam subParam = PSource == null ? null : (WSTableParam)PSource.GetXParam(Key);
Expression member = Expression.Property(parent, param.WSColumnRef.NAME);
if (subParam == null && WSConstants.SPECIAL_CASES.Any(c => c.Match(Key)))
{
if (param.DataType.IsSameOrSubclassOf(typeof(WSEntity)))
{
return(new WSEntityFFilter(param, member, WSEntityFFilter.OPERATIONS.STATE_OPERATIONS.FirstOrDefault(x => x.Match(Key)))
{
Value = null
});
}
else if (param.DataType.IsCollectionOf <WSEntity>())
{
return(new WSEntityListFFilter(param, member, WSEntityListFFilter.OPERATIONS.STATE_OPERATIONS.FirstOrDefault(x => x.Match(Key)))
{
Value = null
});
}
}
else
{
WSFilter subFilter = null;
if (param.DataType.IsSameOrSubclassOf(typeof(WSEntity)))
{
filter.Save(new WSEntityFFilter(param, member, WSEntityFFilter.OPERATIONS.NotEqual)
{
Value = null
});
subFilter = Value.GetFieldFilter(CFunc, subParam, member, level, Key);
if (subFilter != null && subFilter.IsValid)
{
filter.Save(new WSEntityFFilter(param, member, WSEntityFFilter.OPERATIONS.Filter)
{
Value = subFilter
});
}
}
else if (param.DataType.IsCollectionOf <WSEntity>())
{
level++;
Type elemType = param.DataType.GetEntityType();
ParameterExpression id = Expression.Parameter(elemType, level.ToHex());
subFilter = Value.GetFieldFilter(CFunc, subParam, id, level, Key, negate);
if (subFilter != null && subFilter.IsValid)
{
dynamic subExpr = subFilter.GetType().GetMethod("ToLambda").MakeGenericMethod(new Type[] { elemType }).Invoke(subFilter, new object[] { id });
filter.Save(new WSEntityListFFilter(subParam, member, WSEntityListFFilter.OPERATIONS.Any)
{
Value = (subExpr == null) ? true : subExpr
});
}
}
}
}
}
}
}
catch (Exception e) { WSStatus status = WSStatus.NONE.clone(); CFunc.RegError(GetType(), e, ref status); }
return(filter.Any() ? (filter.Count == 1 && !filter.Negate) ? filter.FirstOrDefault() : filter : null);
}
public override WSFilter GetBaseFilter(WSRequest Request, Expression _member, int _level, WSJson _BaseFilter = null)
{
WSJson BaseFilter = _BaseFilter == null ? Source.BaseFilter : _BaseFilter;
WSCombineFilter filter = new WSCombineFilter(WSCombineFilter.SQLMode.AndAlso);
if (filter != null && BaseFilter != null && BaseFilter.IsValid)
{
Expression member = null;
filter = BaseFilter is WSJArray ? new WSCombineFilter(WSCombineFilter.SQLMode.OrElse) : filter;
BaseFilter.apply(Request, Func);
if (BaseFilter != null && BaseFilter.IsValid)
{
if (_member.Type == Source.ReturnType)
{
member = _member;
}
else if (Parent != null)
{
WSTableParam paramExt = (WSTableParam)Parent.Source.GetXParam(Name);
if (paramExt != null)
{
member = Expression.Property(_member, paramExt.WSColumnRef.NAME);
}
}
if (member != null)
{
if (BaseFilter is WSJValue)
{
if (((WSJValue)BaseFilter).Value.IsTrue() || ((WSJValue)BaseFilter).Value.IsFalse())
{
WSFilter subFilter = ((WSJValue)BaseFilter).GetOptionFilter(Func, member, _level);
if (subFilter != null)
{
filter.Add(subFilter);
}
}
}
else if (BaseFilter is WSJObject)
{
foreach (WSJProperty item in ((WSJObject)BaseFilter).Value)
{
bool replace = true;
List <WSMemberSchema> _schemas = readFieldSchema(item, out replace);
if (_schemas.Any())
{
foreach (WSMemberSchema _schema in _schemas)
{
WSFilter subFilter = _schema.GetCustomFilter(member, _level);
if (subFilter != null)
{
filter.Add(subFilter);
}
}
}
}
}
else if (BaseFilter is WSJArray)
{
foreach (WSJson item in ((WSJArray)BaseFilter).Value)
{
bool replace = true;
List <WSMemberSchema> _schemas = readFieldSchema(item, out replace);
if (_schemas.Any())
{
foreach (WSMemberSchema _schema in _schemas)
{
WSFilter subFilter = _schema.GetCustomFilter(member, _level);
if (subFilter != null)
{
filter.Add(subFilter);
}
}
}
else if (item is WSJValue && (((WSJValue)item).Value.IsTrue() || ((WSJValue)item).Value.IsFalse()))
{
WSFilter subFilter = ((WSJValue)item).GetOptionFilter(Func, member, _level);
if (subFilter != null)
{
filter.Add(subFilter);
}
}
}
}
}
}
}
WSFilter result = filter != null && filter.IsValid ? filter.Reduce() : null;
return(result);
}
