/// <summary>
/// Typeds the type of the values for operator column.
/// </summary>
/// <param name="typedValues">The typed values.</param>
/// <param name="conditionType">Type of the condition.</param>
/// <param name="columnType">Type of the column.</param>
/// <returns>IList{TypedValue}.</returns>
private static IList <TypedValue> TypedValuesForOperatorColumnType(IEnumerable <TypedValue> typedValues, ConditionType conditionType, DatabaseType columnType)
{
IList <TypedValue> values = new List <TypedValue>();
if (typedValues == null)
{
return(values);
}
foreach (TypedValue typedValue in typedValues)
{
int operatorCount = ConditionTypeHelper.GetArgumentCount(conditionType);
if (operatorCount <= 0)
{
continue;
}
DatabaseType type = ConditionTypeHelper.GetArgumentType(conditionType, columnType, operatorCount - 1);
if (type != null)
{
typedValue.Type = type;
values.Add(typedValue);
}
}
return(values);
}
private static ReportCondition ReportConditionFromRule(ReportConditionalFormatRule rule, ReportColumn column)
{
ReportCondition reportCondition = new ReportCondition();
if (rule.Operator.HasValue && rule.Operator != ConditionType.Unspecified)
{
string alias = "oper" + rule.Operator.ToString();
reportCondition.Operator = Entity.Get <OperatorEnum>(new EntityRef(alias));
}
Parameter parameter = reportCondition.ConditionParameter != null?reportCondition.ConditionParameter.AsWritable <Parameter>() : new Parameter();
// Clear the old parameter
if (parameter.ParamTypeAndDefault != null)
{
parameter.ParamTypeAndDefault.AsWritable().Delete();
}
// Force entity resource list for argument if we have entities
ActivityArgument activityArgument = null;
if (rule.Values != null && rule.Values.Count > 0)
{
ResourceListArgument resourceList = new ResourceListArgument();
foreach (KeyValuePair <long, string> valuePair in rule.Values)
{
Resource resource = Entity.Get <Resource>(valuePair.Key);
if (resource != null)
{
resourceList.ResourceListParameterValues.Add(resource);
}
}
TypedArgument argumentType = column.ColumnExpression.ReportExpressionResultType.As <TypedArgument>();
resourceList.ConformsToType = argumentType.ConformsToType;
activityArgument = resourceList.As <ActivityArgument>();
activityArgument.Save();
}
else if (rule.Operator.HasValue)
{
int operatorCount = ConditionTypeHelper.GetArgumentCount(rule.Operator.Value);
if (operatorCount > 0)
{
activityArgument = ReportConditionHelper.ArgumentForConditionType(column.ColumnExpression.ReportExpressionResultType, rule.Operator.Value, rule.Value);
activityArgument.Save();
}
}
parameter.ParamTypeAndDefault = activityArgument;
parameter.Save();
reportCondition.ConditionParameter = parameter;
return(reportCondition);
}
private bool ConditionContainArgument(QueryCondition condition)
{
//if the number of arguments that a particular type of condition operator requires is zero, skip the check
if (ConditionTypeHelper.GetArgumentCount(condition.Operator) == 0)
{
return(true);
}
else
{
if ((condition.Argument != null && condition.Argument.Value != null)
||
(condition.Arguments != null && condition.Arguments.Count > 0 && condition.Arguments [0].Value != null))
{
return(true);
}
else
{
return(false);
}
}
}
/// <summary>
/// Applies the analyser conditions.
/// </summary>
/// <param name="structuredQuery">The structured query.</param>
/// <param name="selectedColumnConditions">The selected column conditions.</param>
private static void ApplyAnalyserConditions(StructuredQuery structuredQuery, IEnumerable <SelectedColumnCondition> selectedColumnConditions)
{
foreach (SelectedColumnCondition columnCondition in selectedColumnConditions)
{
QueryCondition queryCondition = structuredQuery.Conditions.FirstOrDefault(sqc => sqc.EntityId.ToString(CultureInfo.InvariantCulture) == columnCondition.ExpressionId);
if (columnCondition.ExpressionId == "_id")
{
queryCondition = new QueryCondition( );
queryCondition.Expression = new IdExpression {
NodeId = structuredQuery.RootEntity.NodeId
};
structuredQuery.Conditions.Add(queryCondition);
}
if (queryCondition == null)
{
// Adhoc condition for column
SelectColumn column = structuredQuery.SelectColumns.FirstOrDefault(sqc => sqc.EntityId.ToString(CultureInfo.InvariantCulture) == columnCondition.ExpressionId);
if (column == null)
{
continue;
}
queryCondition = new QueryCondition();
queryCondition.Argument = new TypedValue();
queryCondition.Argument.Type = columnCondition.Type;
queryCondition.Expression = new ColumnReference {
ColumnId = column.ColumnId
};
structuredQuery.Conditions.Add(queryCondition);
}
if (columnCondition.EntityIdentifiers != null && columnCondition.EntityIdentifiers.Count > 0)
{
queryCondition.Operator = columnCondition.Operator;
long sourceId = queryCondition.Argument.SourceEntityTypeId;
DatabaseType type = ConditionTypeHelper.GetArgumentType(columnCondition.Operator, queryCondition.Argument.Type);
queryCondition.Arguments.Clear();
var isStructureLevelOperator = ConditionTypeHelper.IsStructureLevelOperator(queryCondition.Operator);
foreach (long filterEntityId in columnCondition.EntityIdentifiers)
{
object value;
if (isStructureLevelOperator && type is StringType)
{
value = filterEntityId.ToString();
}
else
{
value = filterEntityId;
}
queryCondition.Arguments.Add(new TypedValue
{
Type = type,
SourceEntityTypeId = sourceId,
Value = value
});
}
}
else
{
queryCondition.Operator = columnCondition.Operator;
if (queryCondition.Argument != null)
{
if (columnCondition.Type != null)
{
DatabaseType argType = queryCondition.Argument.Type is UnknownType ? columnCondition.Type : queryCondition.Argument.Type;
queryCondition.Argument.Type = ConditionTypeHelper.GetArgumentType(columnCondition.Operator, argType);
}
queryCondition.Argument.Value = columnCondition.Value;
}
}
}
}
/// <summary>
/// Builds a predicate that examines the raw data (as its native .Net type) to determine if
/// it passes the specified filter.
/// </summary>
/// <remarks>
/// This overload assumes that the values will not be null.
/// </remarks>
/// <param name="condition">The condition to be applied.</param>
/// <param name="gridResultColumn">The grid result column.</param>
/// <param name="conditionalFormatter">The conditional formatter.</param>
/// <returns>A predicate that accepts a data value and returns true if the value is acceptable on the basis of the filter.</returns>
private static Predicate <object> BuildValueFilterPredicateNoNulls(Condition condition, ResultColumn gridResultColumn, ConditionalFormatter conditionalFormatter)
{
// Get and check argument
TypedValue argument = condition.Argument;
string sArgument = null;
IComparable cArgument = null;
// Handle null strings. TODO: Improve this hack
if (argument != null && argument.Value == null && argument.Type is StringType)
{
argument.Value = "";
}
if (argument == null || argument.Value == null)
{
if (ConditionTypeHelper.GetArgumentCount(condition.Operator) != 0)
{
throw new ArgumentException(@"Condition has no (or null) argument.", "condition");
}
}
else
{
sArgument = argument.Value as string;
cArgument = argument.Value as IComparable;
}
bool isDate = condition.ColumnType is DateType;
bool isCurrency = condition.ColumnType is CurrencyType;
// Return lambda to evaluate test
// 'cell' is statically type object
switch (condition.Operator)
{
case ConditionType.Unspecified:
return(cell => true); // assert false - predicates should not be built from filters with unspecified operators. Silently ignore.
case ConditionType.Equal:
if (argument.Type is StringType)
{
return(cell => ((string)cell).Equals(argument.ValueString, StringComparison.CurrentCultureIgnoreCase));
}
return(cell => argument != null && argument.Value.Equals(isCurrency ? ConvertCurrencyCell(cell, condition.ColumnType) : cell));
case ConditionType.NotEqual:
if (argument.Type is StringType)
{
return(cell => !((string)cell).Equals(argument.ValueString, StringComparison.CurrentCultureIgnoreCase));
}
return(cell => argument != null && !argument.Value.Equals(isCurrency ? ConvertCurrencyCell(cell, condition.ColumnType) : cell));
case ConditionType.GreaterThan:
return(cell => cArgument != null && cArgument.CompareTo(isCurrency ? ConvertCurrencyCell(cell, condition.ColumnType) : cell) < 0);
case ConditionType.GreaterThanOrEqual:
return(cell => cArgument != null && cArgument.CompareTo(isCurrency ? ConvertCurrencyCell(cell, condition.ColumnType) : cell) <= 0);
case ConditionType.LessThan:
return(cell => cArgument != null && cArgument.CompareTo(isCurrency ? ConvertCurrencyCell(cell, condition.ColumnType) : cell) > 0);
case ConditionType.LessThanOrEqual:
return(cell => cArgument != null && cArgument.CompareTo(isCurrency ? ConvertCurrencyCell(cell, condition.ColumnType) : cell) >= 0);
case ConditionType.Contains:
return(cell => ((string)cell).IndexOf(sArgument, StringComparison.CurrentCultureIgnoreCase) >= 0);
case ConditionType.StartsWith:
return(cell => ((string)cell).StartsWith(sArgument, StringComparison.CurrentCultureIgnoreCase));
case ConditionType.EndsWith:
return(cell => ((string)cell).EndsWith(sArgument, StringComparison.CurrentCultureIgnoreCase));
case ConditionType.AnyOf:
return(cell => AnyOf((long)cell, condition.Arguments));
case ConditionType.AnyExcept:
return(cell => AnyExcept((long)cell, condition.Arguments));
case ConditionType.Today:
case ConditionType.ThisMonth:
case ConditionType.ThisQuarter:
case ConditionType.ThisYear:
case ConditionType.CurrentFinancialYear:
case ConditionType.LastNDays:
case ConditionType.NextNDays:
case ConditionType.LastNMonths:
case ConditionType.NextNMonths:
case ConditionType.LastNQuarters:
case ConditionType.NextNQuarters:
case ConditionType.LastNYears:
case ConditionType.NextNYears:
case ConditionType.LastNFinancialYears:
case ConditionType.NextNFinancialYears:
case ConditionType.LastNDaysTillNow:
case ConditionType.NextNDaysFromNow:
case ConditionType.ThisWeek:
case ConditionType.LastNWeeks:
case ConditionType.NextNWeeks:
return(cell =>
{
DateTime minDate, maxDate;
var cellAsDateTime = isDate ? (DateTime)cell : UtcToLocal((DateTime)cell);
const int startMonthOfFinancialYear = 7; //TODO: this comes from old code. Reported as a bug to Diana to improve to respect tenant FY configuration.
PeriodConditionHelper.GetPeriodFromConditionType(condition.Operator, DateTime.Today, cArgument != null ? cArgument as int?: null, startMonthOfFinancialYear, isDate, out minDate, out maxDate);
return cellAsDateTime >= minDate && cellAsDateTime < maxDate;
});
case ConditionType.DateEquals:
{
if (argument != null && argument.Value != null)
{
DateTime today = ((DateTime)argument.Value).Date;
DateTime threshold = today.AddDays(1);
return(cell =>
{
DateTime dCell = isDate ? (DateTime)cell : UtcToLocal((DateTime)cell);
return threshold.CompareTo(dCell) > 0 && today.CompareTo(dCell) <= 0;
});
}
}
break;
case ConditionType.IsTrue:
return(cell => ((bool)cell));
case ConditionType.IsFalse:
return(cell => !((bool)cell));
case ConditionType.IsNull:
return(cell => string.Empty.Equals(cell)); // this method does not get called if it is truly null
case ConditionType.IsNotNull:
return(cell => !string.Empty.Equals(cell)); // this method does not get called if it is truly null
case ConditionType.CurrentUser:
return(IsCurrentUser);
case ConditionType.AnyBelowStructureLevel:
case ConditionType.AnyAboveStructureLevel:
case ConditionType.AnyAtOrAboveStructureLevel:
case ConditionType.AnyAtOrBelowStructureLevel:
return(cell => ApplyStructureViewCondition((string)cell, condition, gridResultColumn, conditionalFormatter));
default:
throw new Exception("Unknown filter operator.");
}
return(null);
}
