/// <summary>
/// Geta a filter expression for an attribute value.
/// </summary>
/// <param name="configurationValues">The configuration values.</param>
/// <param name="filterValues">The filter values.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <returns></returns>
public virtual Expression AttributeFilterExpression(Dictionary <string, ConfigurationValue> configurationValues, List <string> filterValues, ParameterExpression parameterExpression)
{
if (filterValues.Count >= 2)
{
string comparisonValue = filterValues[0];
if (comparisonValue == "0")
{
return(null);
}
ComparisonType comparisonType = comparisonValue.ConvertToEnum <ComparisonType>(ComparisonType.EqualTo);
string filterValue = filterValues[1];
if (string.IsNullOrWhiteSpace(filterValue) &&
comparisonType != ComparisonType.IsBlank && comparisonType != ComparisonType.IsNotBlank)
{
return(null);
}
//string comparisonValue = filterValues[0];
//if ( comparisonValue != "0" )
//{
//ComparisonType comparisonType = comparisonValue.ConvertToEnum<ComparisonType>( ComparisonType.EqualTo );
MemberExpression propertyExpression = Expression.Property(parameterExpression, "Value");
ConstantExpression constantExpression = Expression.Constant(filterValues[1], typeof(string));
return(ComparisonHelper.ComparisonExpression(comparisonType, propertyExpression, constantExpression));
//}
}
return(null);
}
/// <summary>
/// Gets a filter expression for an entity property value.
/// </summary>
/// <param name="filterValues">The filter values.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <param name="propertyName">Name of the property.</param>
/// <param name="propertyType">Type of the property.</param>
/// <returns></returns>
public static Expression PropertyFilterExpression(List <string> filterValues, Expression parameterExpression, string propertyName, Type propertyType)
{
if (filterValues.Count >= 2)
{
string comparisonValue = filterValues[0];
if (comparisonValue != "0")
{
MemberExpression propertyExpression = Expression.Property(parameterExpression, propertyName);
var type = propertyType;
bool isNullableType = type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>);
if (isNullableType)
{
type = Nullable.GetUnderlyingType(type);
}
object value = ConvertValueToPropertyType(filterValues[1], type, isNullableType);
ComparisonType comparisonType = comparisonValue.ConvertToEnum <ComparisonType>(ComparisonType.EqualTo);
bool valueNotNeeded = (ComparisonType.IsBlank | ComparisonType.IsNotBlank).HasFlag(comparisonType);
if (value != null || valueNotNeeded)
{
ConstantExpression constantExpression = value != null?Expression.Constant(value, type) : null;
return(ComparisonHelper.ComparisonExpression(comparisonType, propertyExpression, constantExpression));
}
}
}
return(null);
}
/// <summary>
/// Gets a filter expression for an attribute value.
/// </summary>
/// <param name="configurationValues">The configuration values.</param>
/// <param name="filterValues">The filter values.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <returns></returns>
public override System.Linq.Expressions.Expression AttributeFilterExpression(Dictionary <string, ConfigurationValue> configurationValues, List <string> filterValues, System.Linq.Expressions.ParameterExpression parameterExpression)
{
if (filterValues.Count >= 2)
{
string comparisonValue = filterValues[0];
if (comparisonValue != "0")
{
Guid guid = filterValues[1].AsGuid();
int personId = new PersonAliasService(new RockContext()).Queryable()
.Where(a => a.Guid.Equals(guid))
.Select(a => a.PersonId)
.FirstOrDefault();
if (personId > 0)
{
ComparisonType comparisonType = comparisonValue.ConvertToEnum <ComparisonType>(ComparisonType.EqualTo);
MemberExpression propertyExpression = Expression.Property(parameterExpression, "ValueAsPersonId");
ConstantExpression constantExpression = Expression.Constant(personId, typeof(int));
return(ComparisonHelper.ComparisonExpression(comparisonType, propertyExpression, constantExpression));
}
}
}
return(new NoAttributeFilterExpression());
}
/// <summary>
/// Gets a filter expression for an entity property value.
/// </summary>
/// <param name="configurationValues">The configuration values.</param>
/// <param name="filterValues">The filter values.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <param name="propertyName">Name of the property.</param>
/// <param name="propertyType">Type of the property.</param>
/// <returns></returns>
public override Expression PropertyFilterExpression(Dictionary <string, ConfigurationValue> configurationValues, List <string> filterValues, Expression parameterExpression, string propertyName, Type propertyType)
{
if (filterValues.Count >= 2)
{
// uses Tab Delimited since slidingDateRangePicker is | delimited
var filterValueValues = filterValues[1].Split(new string[] { "\t" }, StringSplitOptions.None);
// Parse for RelativeValue of DateTime (if specified)
filterValueValues[0] = ParseRelativeValue(filterValueValues[0]);
string comparisonValue = filterValues[0];
if (comparisonValue != "0" && comparisonValue.IsNotNullOrWhiteSpace())
{
ComparisonType comparisonType = comparisonValue.ConvertToEnum <ComparisonType>(ComparisonType.EqualTo);
MemberExpression propertyExpression = Expression.Property(parameterExpression, propertyName);
if (comparisonType == ComparisonType.Between && filterValueValues.Length > 1)
{
var dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(filterValueValues[1]);
ConstantExpression constantExpressionLower = dateRange.Start.HasValue
? Expression.Constant(dateRange.Start, typeof(DateTime))
: null;
ConstantExpression constantExpressionUpper = dateRange.End.HasValue
? Expression.Constant(dateRange.End, typeof(DateTime))
: null;
if (constantExpressionLower == null && constantExpressionUpper == null)
{
return(new NoAttributeFilterExpression());
}
else
{
return(ComparisonHelper.ComparisonExpression(comparisonType, propertyExpression, constantExpressionLower, constantExpressionUpper));
}
}
else
{
var dateTime = filterValueValues[0].AsDateTime();
if (dateTime.HasValue)
{
ConstantExpression constantExpression = Expression.Constant(dateTime, typeof(DateTime));
return(ComparisonHelper.ComparisonExpression(comparisonType, propertyExpression, constantExpression));
}
else
{
if (comparisonType == ComparisonType.IsBlank || comparisonType == ComparisonType.IsNotBlank)
{
return(ComparisonHelper.ComparisonExpression(comparisonType, propertyExpression, null));
}
else
{
return(new NoAttributeFilterExpression());
}
}
}
}
}
return(null);
}
/// <summary>
/// Gets a filter expression to be used as part of a AttributeValue Query or EntityAttributeQueryExpression
/// </summary>
/// <param name="configurationValues">The configuration values.</param>
/// <param name="filterValues">The filter values.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <returns></returns>
public virtual Expression AttributeFilterExpression(Dictionary <string, ConfigurationValue> configurationValues, List <string> filterValues, ParameterExpression parameterExpression)
{
if (filterValues.Count >= 2)
{
ComparisonType?comparisonType = filterValues[0].ConvertToEnumOrNull <ComparisonType>();
if (comparisonType.HasValue)
{
string compareToValue = filterValues[1];
bool valueNotNeeded = (ComparisonType.IsBlank | ComparisonType.IsNotBlank).HasFlag(comparisonType);
if (valueNotNeeded || !string.IsNullOrWhiteSpace(compareToValue))
{
MemberExpression propertyExpression = Expression.Property(parameterExpression, this.AttributeValueFieldName);
return(ComparisonHelper.ComparisonExpression(comparisonType.Value, propertyExpression, AttributeConstantExpression(compareToValue)));
}
}
else
{
// No comparison type specified, so return NoAttributeFilterExpression ( which means don't filter )
return(new NoAttributeFilterExpression());
}
}
// return null if there isn't an additional expression that will help narrow down which AttributeValue records to include
return(null);
}
/// <summary>
/// Gets a filter expression for an entity property value.
/// </summary>
/// <param name="configurationValues">The configuration values.</param>
/// <param name="filterValues">The filter values.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <param name="propertyName">Name of the property.</param>
/// <param name="propertyType">Type of the property.</param>
/// <returns></returns>
public virtual Expression PropertyFilterExpression(Dictionary <string, ConfigurationValue> configurationValues, List <string> filterValues, Expression parameterExpression, string propertyName, Type propertyType)
{
if (filterValues.Count >= 2)
{
string comparisonValue = filterValues[0];
if (comparisonValue != "0")
{
MemberExpression propertyExpression = Expression.Property(parameterExpression, propertyName);
var type = propertyType;
bool isNullableType = type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>);
if (isNullableType)
{
type = Nullable.GetUnderlyingType(type);
}
object value = ConvertValueToPropertyType(filterValues[1], type);
if (value != null)
{
ComparisonType comparisonType = comparisonValue.ConvertToEnum <ComparisonType>(ComparisonType.EqualTo);
ConstantExpression constantExpression = Expression.Constant(value, type);
return(ComparisonHelper.ComparisonExpression(comparisonType, propertyExpression, constantExpression));
}
}
}
return(null);
}
/// <summary>
/// Gets the filters expression.
/// </summary>
/// <param name="configurationValues">The configuration values.</param>
/// <param name="filterValues">The filter values.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <returns></returns>
public override Expression AttributeFilterExpression(Dictionary <string, ConfigurationValue> configurationValues, List <string> filterValues, ParameterExpression parameterExpression)
{
if (filterValues.Count == 1)
{
List <string> selectedValues = filterValues[0].Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).ToList();
int valueCount = selectedValues.Count();
MemberExpression propertyExpression = Expression.Property(parameterExpression, "Value");
if (valueCount == 0)
{
// No Value specified, so return NoAttributeFilterExpression ( which means don't filter )
return(new NoAttributeFilterExpression());
}
else if (valueCount == 1)
{
// only one value, so do an Equal instead of Contains which might compile a little bit faster
ComparisonType comparisonType = ComparisonType.EqualTo;
return(ComparisonHelper.ComparisonExpression(comparisonType, propertyExpression, AttributeConstantExpression(selectedValues[0])));
}
else
{
ConstantExpression constantExpression = Expression.Constant(selectedValues, typeof(List <string>));
return(Expression.Call(constantExpression, typeof(List <string>).GetMethod("Contains", new Type[] { typeof(string) }), propertyExpression));
}
}
return(base.AttributeFilterExpression(configurationValues, filterValues, parameterExpression));
}
/// <summary>
/// Gets a filter expression for an attribute value.
/// </summary>
/// <param name="configurationValues">The configuration values.</param>
/// <param name="filterValues">The filter values.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <returns></returns>
public override Expression AttributeFilterExpression(Dictionary <string, ConfigurationValue> configurationValues, List <string> filterValues, ParameterExpression parameterExpression)
{
List <string> selectedValues = null;
ComparisonType comparisonType = ComparisonType.Contains;
if (filterValues.Count == 1)
{
// if there is only one filter value, it is a Contains comparison for the selectedValues
// This is the normal thing that DataViews would do with a SelectSingleFieldType
selectedValues = filterValues[0].Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).ToList();
}
else if (filterValues.Count >= 2)
{
// if there are 2 (or more) filter values, the first is the comparison type and the 2nd is the selected value(s)
// Note: Rock Lava Entity commands could do this, DataViews don't currently support more than just 'Contains'
comparisonType = filterValues[0].ConvertToEnum <ComparisonType>(ComparisonType.Contains);
if (comparisonType == ComparisonType.EqualTo)
{
// If EqualTo was specified, treat it as Contains
comparisonType = ComparisonType.Contains;
}
if (comparisonType == ComparisonType.NotEqualTo)
{
// If NotEqualTo was specified, treat it as DoesNotContain
comparisonType = ComparisonType.DoesNotContain;
}
selectedValues = filterValues[1].Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).ToList();
}
// if IsBlank (or IsNotBlank)
if ((ComparisonType.IsBlank | ComparisonType.IsNotBlank).HasFlag(comparisonType))
{
// Just checking if IsBlank or IsNotBlank, so let ComparisonExpression do its thing
MemberExpression propertyExpression = Expression.Property(parameterExpression, this.AttributeValueFieldName);
return(ComparisonHelper.ComparisonExpression(comparisonType, propertyExpression, AttributeConstantExpression(string.Empty)));
}
if (selectedValues?.Any() == true)
{
MemberExpression propertyExpression = Expression.Property(parameterExpression, "Value");
ConstantExpression constantExpression = Expression.Constant(selectedValues, typeof(List <string>));
Expression expression = Expression.Call(constantExpression, typeof(List <string>).GetMethod("Contains", new Type[] { typeof(string) }), propertyExpression);
if (comparisonType == ComparisonType.DoesNotContain)
{
expression = Expression.Not(expression);
}
return(expression);
}
return(new NoAttributeFilterExpression());
}
/// <summary>
/// Gets a filter expression for an attribute value.
/// </summary>
/// <param name="configurationValues">The configuration values.</param>
/// <param name="filterValues">The filter values.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <returns></returns>
public override Expression AttributeFilterExpression(Dictionary <string, ConfigurationValue> configurationValues, List <string> filterValues, ParameterExpression parameterExpression)
{
Expression comparison = null;
if (filterValues.Count > 1)
{
ComparisonType?comparisonType = filterValues[0].ConvertToEnumOrNull <ComparisonType>();
if (comparisonType.HasValue)
{
string compareToValue = filterValues[1];
MemberExpression propertyExpression = Expression.Property(parameterExpression, this.AttributeValueFieldName);
if (!string.IsNullOrWhiteSpace(compareToValue))
{
List <string> selectedValues = compareToValue.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).ToList();
foreach (var selectedValue in selectedValues)
{
var searchValue = "," + selectedValue + ",";
var qryToExtract = new AttributeValueService(new Data.RockContext()).Queryable().Where(a => ("," + a.Value + ",").Contains(searchValue));
var valueExpression = FilterExpressionExtractor.Extract <AttributeValue>(qryToExtract, parameterExpression, "a");
if (comparisonType.Value != ComparisonType.Contains)
{
valueExpression = Expression.Not(valueExpression);
}
if (comparison == null)
{
comparison = valueExpression;
}
else
{
comparison = Expression.Or(comparison, valueExpression);
}
}
}
else
{
// No comparison value was specified, so we can filter if the Comparison Type using no value still makes sense
if ((ComparisonType.IsBlank | ComparisonType.IsNotBlank).HasFlag(comparisonType))
{
// Just checking if IsBlank or IsNotBlank, so let ComparisonExpression do its thing
return(ComparisonHelper.ComparisonExpression(comparisonType.Value, propertyExpression, AttributeConstantExpression(string.Empty)));
}
}
}
}
if (comparison == null)
{
return(new Rock.Data.NoAttributeFilterExpression());
}
return(comparison);
}
/// <summary>
/// Gets a filter expression for an attribute value.
/// </summary>
/// <param name="configurationValues">The configuration values.</param>
/// <param name="filterValues">The filter values.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <returns></returns>
public override Expression AttributeFilterExpression(Dictionary <string, ConfigurationValue> configurationValues, List <string> filterValues, ParameterExpression parameterExpression)
{
Expression comparison = null;
if (filterValues.Count > 1)
{
//// OR up the where clauses for each of the selected values
// and make sure to wrap commas around things so we don't collide with partial matches
// so it'll do something like this:
//
// WHERE ',' + Value + ',' like '%,bacon,%'
// OR ',' + Value + ',' like '%,lettuce,%'
// OR ',' + Value + ',' like '%,tomato,%'
// should be either "Contains" or "Not Contains"
ComparisonType comparisonType = filterValues[0].ConvertToEnum <ComparisonType>(ComparisonType.Contains);
// No comparison value was specified, so we can filter if the Comparison Type using no value still makes sense
if ((ComparisonType.IsBlank | ComparisonType.IsNotBlank).HasFlag(comparisonType))
{
// Just checking if IsBlank or IsNotBlank, so let ComparisonExpression do its thing
MemberExpression propertyExpression = Expression.Property(parameterExpression, this.AttributeValueFieldName);
return(ComparisonHelper.ComparisonExpression(comparisonType, propertyExpression, AttributeConstantExpression(string.Empty)));
}
List <string> selectedValues = filterValues[1].Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).ToList();
foreach (var selectedValue in selectedValues)
{
var searchValue = "," + selectedValue + ",";
var qryToExtract = new AttributeValueService(new Data.RockContext()).Queryable().Where(a => ("," + a.Value + ",").Contains(searchValue));
var valueExpression = FilterExpressionExtractor.Extract <AttributeValue>(qryToExtract, parameterExpression, "a");
if (comparisonType != ComparisonType.Contains)
{
valueExpression = Expression.Not(valueExpression);
}
if (comparison == null)
{
comparison = valueExpression;
}
else
{
comparison = Expression.Or(comparison, valueExpression);
}
}
}
if (comparison == null)
{
return(new NoAttributeFilterExpression());
}
return(comparison);
}
/// <summary>
/// Gets a filter expression for an attribute value.
/// </summary>
/// <param name="configurationValues">The configuration values.</param>
/// <param name="filterValues">The filter values.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <returns></returns>
public override Expression AttributeFilterExpression(Dictionary <string, ConfigurationValue> configurationValues, List <string> filterValues, ParameterExpression parameterExpression)
{
if (filterValues.Count == 1)
{
MemberExpression propertyExpression = Expression.Property(parameterExpression, "ValueAsNumeric");
ComparisonType comparisonType = ComparisonType.EqualTo;
return(ComparisonHelper.ComparisonExpression(comparisonType, propertyExpression, AttributeConstantExpression(filterValues[0])));
}
return(base.AttributeFilterExpression(configurationValues, filterValues, parameterExpression));
}
/// <summary>
/// Gets a filter expression for an entity property value.
/// </summary>
/// <param name="configurationValues">The configuration values.</param>
/// <param name="filterValues">The filter values.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <param name="propertyName">Name of the property.</param>
/// <param name="propertyType">Type of the property.</param>
/// <returns></returns>
public override Expression PropertyFilterExpression(Dictionary <string, ConfigurationValue> configurationValues, List <string> filterValues, Expression parameterExpression, string propertyName, Type propertyType)
{
if (filterValues.Count == 1)
{
MemberExpression propertyExpression = Expression.Property(parameterExpression, propertyName);
ConstantExpression constantExpression = Expression.Constant(bool.Parse(filterValues[0]));
ComparisonType comparisonType = ComparisonType.EqualTo;
return(ComparisonHelper.ComparisonExpression(comparisonType, propertyExpression, constantExpression));
}
return(null);
}
/// <summary>
/// Gets a filter expression for an entity property value.
/// </summary>
/// <param name="filterValues">The filter values.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <param name="propertyName">Name of the property.</param>
/// <param name="propertyType">Type of the property.</param>
/// <returns></returns>
public static Expression PropertyFilterExpression(List <string> filterValues, Expression parameterExpression, string propertyName, Type propertyType)
{
/* 2020-08-17 MDP
* If it isn't fully configured we won't filter. We can detect if the filter isn't configured by..
*
* 1) There are less than 2 filterValues
* 2) A comparisonType isn't specified ("0" means not specified)
* 3) Except of in the case of IsBlank or IsNotBlank, a "CompareTo null" (filterValues[1]) value means the filter value isn't specified
*
* If we have any of the above cases, we'll return Expression.Const(true), which means we won't filter on this)
*/
if (filterValues.Count < 2)
{
// if PropertyFilter needs at least 2 parameters. If it doesn't, don't filter
return(Expression.Constant(true));
}
string comparisonValue = filterValues[0];
if (comparisonValue == "0")
{
// if the comparison as a string is "0", that means no comparison type is specified (comparisonType enum starts at 1)
return(Expression.Constant(true));
}
var type = propertyType;
bool isNullableType = type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>);
if (isNullableType)
{
type = Nullable.GetUnderlyingType(type);
}
object value = ConvertValueToPropertyType(filterValues[1], type, isNullableType);
ComparisonType comparisonType = comparisonValue.ConvertToEnum <ComparisonType>(ComparisonType.EqualTo);
bool valueNotNeeded = (ComparisonType.IsBlank | ComparisonType.IsNotBlank).HasFlag(comparisonType);
if (value != null || valueNotNeeded)
{
// a valid value is specified or we are doing a NotBlank/IsNotBlank, so build an filter expression
MemberExpression propertyExpression = Expression.Property(parameterExpression, propertyName);
ConstantExpression constantExpression = value != null?Expression.Constant(value, type) : null;
return(ComparisonHelper.ComparisonExpression(comparisonType, propertyExpression, constantExpression));
}
else
{
// if Property Filter isn't fully configured (for example "Birthday(int) greaterThan null"), don't filter the results
return(Expression.Constant(true));
}
}
/// <summary>
/// Gets a filter expression to be used as part of a AttributeValue Query or EntityAttributeQueryExpression
/// </summary>
/// <param name="configurationValues">The configuration values.</param>
/// <param name="filterValues">The filter values: FieldName, <see cref="ComparisonType">Comparison Type</see>, (optional) Comparison Value(s)</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <returns></returns>
public virtual Expression AttributeFilterExpression(Dictionary <string, ConfigurationValue> configurationValues, List <string> filterValues, ParameterExpression parameterExpression)
{
// If filterValues.Count >= 2, then filterValues[0] is ComparisonType, and filterValues[1] is a CompareToValue. Otherwise, filterValues[0] is a CompareToValue (for example, a SingleSelect attribute)
if (filterValues.Count >= 2)
{
ComparisonType?comparisonType = filterValues[0].ConvertToEnumOrNull <ComparisonType>();
if (comparisonType.HasValue)
{
string compareToValue = filterValues[1];
MemberExpression propertyExpression = Expression.Property(parameterExpression, this.AttributeValueFieldName);
if (!string.IsNullOrWhiteSpace(compareToValue))
{
// both a comparison type and value are specified, so we can process normally
return(ComparisonHelper.ComparisonExpression(comparisonType.Value, propertyExpression, AttributeConstantExpression(compareToValue)));
}
else
{
// No comparison value was specified, so we can filter if the Comparison Type using no value still makes sense
if ((ComparisonType.IsBlank | ComparisonType.IsNotBlank).HasFlag(comparisonType))
{
// Just checking if IsBlank or IsNotBlank, so let ComparisonExpression do its thing
return(ComparisonHelper.ComparisonExpression(comparisonType.Value, propertyExpression, AttributeConstantExpression(string.Empty)));
}
else if (this.FilterComparisonType.HasFlag(ComparisonType.IsBlank))
{
// if this Filter supports IsBlank/IsNotBlank, we can convert this to IsBlank/IsNotBlank if no value was specified
if (comparisonType == ComparisonType.EqualTo)
{
// an EqualTo was specified, but no value was specified, so convert it to a IsBlank
return(ComparisonHelper.ComparisonExpression(ComparisonType.IsBlank, propertyExpression, AttributeConstantExpression(string.Empty)));
}
else if (comparisonType == ComparisonType.NotEqualTo)
{
// a NotEqualTo was specified, but no value was specified, so convert it to a IsNotBlank
return(ComparisonHelper.ComparisonExpression(ComparisonType.IsNotBlank, propertyExpression, AttributeConstantExpression(string.Empty)));
}
}
}
}
else
{
// No comparison type specified, so return NoAttributeFilterExpression ( which means don't filter )
return(new NoAttributeFilterExpression());
}
}
// return NoAttributeFilterExpression ( which means don't filter ) if there isn't enough information to make a Comparison Expression
return(new NoAttributeFilterExpression());
}
/// <summary>
/// Gets a filter expression for an entity property value.
/// </summary>
/// <param name="configurationValues">The configuration values.</param>
/// <param name="filterValues">The filter values.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <param name="propertyName">Name of the property.</param>
/// <param name="propertyType">Type of the property.</param>
/// <returns></returns>
public override Expression PropertyFilterExpression(Dictionary <string, ConfigurationValue> configurationValues, List <string> filterValues, Expression parameterExpression, string propertyName, Type propertyType)
{
if (filterValues.Count < 2)
{
return(null);
}
var filterCompareValues = filterValues[1].FromJsonOrNull <List <Guid> >() ?? new List <Guid>();
if (!filterCompareValues.Any())
{
// if there aren't any filterCompareValues specified, interpret that as 'don't filter'
return(Expression.Constant(true));
}
var configurationJSON = configurationValues.GetValueOrNull(ConfigurationKey.ConfigurationJSON);
List <ConditionalScaleRangeRule> conditionalScaleRangeRuleList = configurationJSON.FromJsonOrNull <List <ConditionalScaleRangeRule> >() ?? new List <ConditionalScaleRangeRule>();
MemberExpression propertyExpression = Expression.Property(parameterExpression, propertyName);
Expression rangeComparison = null;
var conditionalScaleRangeRuleListToFilter = conditionalScaleRangeRuleList.Where(a => filterCompareValues.Contains(a.Guid)).ToList();
foreach (var conditionalScaleRangeRule in conditionalScaleRangeRuleListToFilter)
{
decimal lowValue = conditionalScaleRangeRule.LowValue ?? decimal.MinValue;
decimal highValue = conditionalScaleRangeRule.HighValue ?? decimal.MaxValue;
ConstantExpression constantExpressionLowValue = Expression.Constant(lowValue, typeof(decimal));
ConstantExpression constantExpressionHighValue = Expression.Constant(highValue, typeof(decimal));
var rangeBetweenExpression = ComparisonHelper.ComparisonExpression(ComparisonType.Between, propertyExpression, constantExpressionLowValue, constantExpressionHighValue);
if (rangeComparison == null)
{
rangeComparison = rangeBetweenExpression;
}
else
{
rangeComparison = Expression.Or(rangeComparison, rangeBetweenExpression);
}
}
var notNullComparison = ComparisonHelper.ComparisonExpression(ComparisonType.IsNotBlank, propertyExpression, AttributeConstantExpression(string.Empty));
var expression = Expression.AndAlso(notNullComparison, rangeComparison);
return(expression);
}
/// <summary>
/// Gets a filter expression for an entity property value.
/// </summary>
/// <param name="configurationValues">The configuration values.</param>
/// <param name="filterValues">The filter values.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <param name="propertyName">Name of the property.</param>
/// <param name="propertyType">Type of the property.</param>
/// <returns></returns>
public virtual Expression PropertyFilterExpression(Dictionary <string, ConfigurationValue> configurationValues, List <string> filterValues, Expression parameterExpression, string propertyName, Type propertyType)
{
if (filterValues.Count >= 2)
{
string comparisonValue = filterValues[0];
if (comparisonValue != "0")
{
MemberExpression propertyExpression = Expression.Property(parameterExpression, propertyName);
var type = propertyType;
bool isNullableType = type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>);
if (isNullableType)
{
type = Nullable.GetUnderlyingType(type);
}
ComparisonType comparisonType = comparisonValue.ConvertToEnum <ComparisonType>(ComparisonType.EqualTo);
// Parse the comparison string for multiple values.
var values = filterValues[1].Split(new string[] { "||" }, StringSplitOptions.None);
// Create an Expression with an OR relationship between each value.
Expression comparisonExpression = null;
foreach (var value in values)
{
object typedValue = ConvertValueToPropertyType(value, type);
if (typedValue != null)
{
ConstantExpression constantExpression = Expression.Constant(typedValue, type);
if (comparisonExpression == null)
{
comparisonExpression = ComparisonHelper.ComparisonExpression(comparisonType, propertyExpression, constantExpression);
}
else
{
comparisonExpression = Expression.OrElse(comparisonExpression, ComparisonHelper.ComparisonExpression(comparisonType, propertyExpression, constantExpression));
}
}
}
return(comparisonExpression);
}
}
return(null);
}
/// <summary>
/// Gets a filter expression for an attribute value.
/// </summary>
/// <param name="configurationValues">The configuration values.</param>
/// <param name="filterValues">The filter values.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <returns></returns>
public override Expression AttributeFilterExpression(Dictionary <string, ConfigurationValue> configurationValues, List <string> filterValues, ParameterExpression parameterExpression)
{
if (filterValues.Count == 1)
{
// NOTE: this is for backwards compatibility for filters that were saved when Boolean DataFilters didn't have a Compare Option
MemberExpression propertyExpression = Expression.Property(parameterExpression, "Value");
ConstantExpression constantExpression = Expression.Constant(filterValues[0]);
ComparisonType comparisonType = ComparisonType.EqualTo;
return(ComparisonHelper.ComparisonExpression(comparisonType, propertyExpression, constantExpression));
}
else
{
return(base.AttributeFilterExpression(configurationValues, filterValues, parameterExpression));
}
}
/// <summary>
/// Gets a filter expression for an attribute value.
/// </summary>
/// <param name="configurationValues">The configuration values.</param>
/// <param name="filterValues">The filter values.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <returns></returns>
public virtual Expression AttributeFilterExpression(Dictionary <string, ConfigurationValue> configurationValues, List <string> filterValues, ParameterExpression parameterExpression)
{
if (filterValues.Count >= 2)
{
string comparisonValue = filterValues[0];
if (comparisonValue != "0")
{
ComparisonType comparisonType = comparisonValue.ConvertToEnum <ComparisonType>(ComparisonType.EqualTo);
MemberExpression propertyExpression = Expression.Property(parameterExpression, this.AttributeValueFieldName);
return(ComparisonHelper.ComparisonExpression(comparisonType, propertyExpression, AttributeConstantExpression(filterValues[1])));
}
}
return(null);
}
/// <summary>
/// Geta a filter expression for an attribute value.
/// </summary>
/// <param name="configurationValues">The configuration values.</param>
/// <param name="filterValues">The filter values.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <returns></returns>
public override Expression AttributeFilterExpression(Dictionary <string, ConfigurationValue> configurationValues, List <string> filterValues, ParameterExpression parameterExpression)
{
if (filterValues.Count >= 2)
{
string comparisonValue = filterValues[0];
if (comparisonValue != "0")
{
filterValues[1] = ParseRelativeValue(filterValues[1]);
DateTime date = filterValues[1].AsDateTime() ?? DateTime.MinValue;
ComparisonType comparisonType = comparisonValue.ConvertToEnum <ComparisonType>(ComparisonType.EqualTo);
MemberExpression propertyExpression = Expression.Property(parameterExpression, "ValueAsDateTime");
ConstantExpression constantExpression = Expression.Constant(date, typeof(DateTime));
return(ComparisonHelper.ComparisonExpression(comparisonType, propertyExpression, constantExpression));
}
}
return(null);
}
/// <summary>
/// Gets a filter expression for an attribute value.
/// </summary>
/// <param name="configurationValues">The configuration values.</param>
/// <param name="filterValues">The filter values.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <returns></returns>
public virtual Expression AttributeFilterExpression(Dictionary <string, ConfigurationValue> configurationValues, List <string> filterValues, ParameterExpression parameterExpression)
{
if (filterValues.Count >= 2)
{
string comparisonValue = filterValues[0];
if (comparisonValue != "0")
{
ComparisonType comparisonType = comparisonValue.ConvertToEnum <ComparisonType>(ComparisonType.EqualTo);
bool valueNotNeeded = (ComparisonType.IsBlank | ComparisonType.IsNotBlank).HasFlag(comparisonType);
if (valueNotNeeded || !string.IsNullOrWhiteSpace(filterValues[1]))
{
MemberExpression propertyExpression = Expression.Property(parameterExpression, this.AttributeValueFieldName);
return(ComparisonHelper.ComparisonExpression(comparisonType, propertyExpression, AttributeConstantExpression(filterValues[1])));
}
}
}
return(null);
}
/// <summary>
/// Geta a filter expression for an attribute value.
/// </summary>
/// <param name="configurationValues">The configuration values.</param>
/// <param name="filterValues">The filter values.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <returns></returns>
public override Expression AttributeFilterExpression(Dictionary <string, ConfigurationValue> configurationValues, List <string> filterValues, ParameterExpression parameterExpression)
{
if (filterValues.Count < 2)
{
return(null);
}
// Get Comparison Type or exit if none specified.
string comparisonTypeValue = filterValues[0];
if (comparisonTypeValue == "0")
{
return(null);
}
ComparisonType?comparisonType = comparisonTypeValue.ConvertToEnumOrNull <ComparisonType>();
// If no comparison has been specified, we cannot form a valid filter expression.
if (!comparisonType.HasValue)
{
return(null);
}
// Get Comparison Date. If a date is required but not specified, we cannot form a valid filter expression.
string dateValue = filterValues[1];
if (string.IsNullOrWhiteSpace(dateValue) &&
comparisonType != ComparisonType.IsBlank && comparisonType != ComparisonType.IsNotBlank)
{
return(null);
}
filterValues[1] = ParseRelativeValue(filterValues[1]);
DateTime date = filterValues[1].AsDateTime() ?? DateTime.MinValue;
MemberExpression propertyExpression = Expression.Property(parameterExpression, "ValueAsDateTime");
ConstantExpression constantExpression = Expression.Constant(date, typeof(DateTime));
return(ComparisonHelper.ComparisonExpression(comparisonType.Value, propertyExpression, constantExpression));
}
/// <summary>
/// Gets a filter expression for an attribute value.
/// </summary>
/// <param name="configurationValues">The configuration values.</param>
/// <param name="filterValues">The filter values.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <returns></returns>
public override Expression AttributeFilterExpression(Dictionary <string, ConfigurationValue> configurationValues, List <string> filterValues, ParameterExpression parameterExpression)
{
bool allowMultiple = configurationValues != null && configurationValues.ContainsKey(ALLOW_MULTIPLE_KEY) && configurationValues[ALLOW_MULTIPLE_KEY].Value.AsBoolean();
List <string> selectedValues;
if (allowMultiple || filterValues.Count != 1)
{
ComparisonType comparisonType = filterValues[0].ConvertToEnum <ComparisonType>(ComparisonType.Contains);
// if it isn't either "Contains" or "Not Contains", just use the base AttributeFilterExpression
if (!(new ComparisonType[] { ComparisonType.Contains, ComparisonType.DoesNotContain }).Contains(comparisonType))
{
return(base.AttributeFilterExpression(configurationValues, filterValues, parameterExpression));
}
//// OR up the where clauses for each of the selected values
// and make sure to wrap commas around things so we don't collide with partial matches
// so it'll do something like this:
//
// WHERE ',' + Value + ',' like '%,bacon,%'
// OR ',' + Value + ',' like '%,lettuce,%'
// OR ',' + Value + ',' like '%,tomato,%'
if (filterValues.Count > 1)
{
selectedValues = filterValues[1].Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).ToList();
}
else
{
selectedValues = new List <string>();
}
Expression comparison = null;
foreach (var selectedValue in selectedValues)
{
var searchValue = "," + selectedValue + ",";
var qryToExtract = new AttributeValueService(new Data.RockContext()).Queryable().Where(a => ("," + a.Value + ",").Contains(searchValue));
var valueExpression = FilterExpressionExtractor.Extract <AttributeValue>(qryToExtract, parameterExpression, "a");
if (comparisonType != ComparisonType.Contains)
{
valueExpression = Expression.Not(valueExpression);
}
if (comparison == null)
{
comparison = valueExpression;
}
else
{
comparison = Expression.Or(comparison, valueExpression);
}
}
if (comparison == null)
{
// No Value specified, so return NoAttributeFilterExpression ( which means don't filter )
return(new NoAttributeFilterExpression());
}
else
{
return(comparison);
}
}
selectedValues = filterValues[0].Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).ToList();
int valueCount = selectedValues.Count();
MemberExpression propertyExpression = Expression.Property(parameterExpression, "Value");
if (valueCount == 0)
{
// No Value specified, so return NoAttributeFilterExpression ( which means don't filter )
return(new NoAttributeFilterExpression());
}
else if (valueCount == 1)
{
// only one value, so do an Equal instead of Contains which might compile a little bit faster
ComparisonType comparisonType = ComparisonType.EqualTo;
return(ComparisonHelper.ComparisonExpression(comparisonType, propertyExpression, AttributeConstantExpression(selectedValues[0])));
}
else
{
ConstantExpression constantExpression = Expression.Constant(selectedValues, typeof(List <string>));
return(Expression.Call(constantExpression, typeof(List <string>).GetMethod("Contains", new Type[] { typeof(string) }), propertyExpression));
}
}