/// <summary>
/// Gets the filters to search contacts by phone numbers.
/// </summary>
/// <param name="esq">The entity schema query that searches for contact communication.</param>
/// <param name="phones">The phone numbers.</param>
/// <returns>The group of filters, that filters contact communications by the given phone numbers.</returns>
public EntitySchemaQueryFilterCollection GetSearchContactFilters(EntitySchemaQuery esq, List <string> phones)
{
if (phones == null || !phones.Any())
{
return(null);
}
IEnumerable <string> validPhones = phones
.Select(PreprocessPhone)
.Where(StringUtilities.IsNotNullOrWhiteSpace)
.ToList();
if (!validPhones.Any())
{
return(null);
}
var filterGroup = new EntitySchemaQueryFilterCollection(esq, LogicalOperationStrict.Or);
foreach (string number in validPhones)
{
FilterComparisonType comparisonType = number.Length <= _internalNumberLength
? FilterComparisonType.Equal
: FilterComparisonType.StartWith;
filterGroup.Add(esq.CreateFilterWithParameters(comparisonType,
"[ContactCommunication:Contact:Id].SearchNumber", number));
}
return(filterGroup);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="columnPath">Column path.</param>
/// <param name="values">Values collection.</param>
/// <param name="comparisonType">Comparison type.</param>
/// <param name="logicalOperation">Logical operation.</param>
public EntityCollectionMappingHandlerFilter(string columnPath, List <object> values,
FilterComparisonType comparisonType = FilterComparisonType.Equal,
LogicalOperationStrict logicalOperation = LogicalOperationStrict.And)
{
ColumnPath = columnPath;
Values = values;
ComparisonType = comparisonType;
LogicalOperation = logicalOperation;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="columnPath">Column path.</param>
/// <param name="values">Values collection.</param>
/// <param name="comparisonType">Comparison type.</param>
/// <param name="logicalOperation">Logical operation.</param>
public HierarchyDataStructureFilter(string columnPath, IEnumerable <object> values,
FilterComparisonType comparisonType = FilterComparisonType.Equal,
LogicalOperationStrict logicalOperation = LogicalOperationStrict.And)
{
ColumnPath = columnPath;
Values = values;
ComparisonType = comparisonType;
LogicalOperation = logicalOperation;
}
internal static ExpressionMetadata GenerateComparisonExpressionMetadata(Expression left,
FilterComparisonType comparisonType, ExpressionModelMetadata modelMetadata, params Expression[] rights)
{
var leftExpressionMetadata = GenerateFilterElementExpression(left, modelMetadata);
var rightExpressionMetadataList =
rights.Select(right => GenerateFilterElementExpression(right, modelMetadata)).ToArray();
return(GenerateComparisonExpressionMetadata(leftExpressionMetadata, comparisonType,
rightExpressionMetadataList));
}
/// <summary>
/// Adds esq detail phone filter.
/// </summary>
/// <param name="esq"><see cref="EntitySchemaQuery"/> esq.</param>
/// <param name="filterComparisonType"><see cref="FilterComparisonType"/> filterComparisonType.</param>
private void ApplyDetailPhoneFilter(EntitySchemaQuery esq, FilterComparisonType filterComparisonType)
{
EntitySchemaQueryFilterCollection esqFilters = new EntitySchemaQueryFilterCollection(esq);
Guid phoneTypeId = new Guid(CommunicationTypeConsts.CommunicationPhoneId);
Guid smsTypeId = new Guid(CommunicationTypeConsts.CommunicationSmsId);
esqFilters.Add(esq.CreateFilterWithParameters(filterComparisonType,
"[ComTypebyCommunication:CommunicationType:CommunicationType].[Communication:Id:Communication].Id",
phoneTypeId, smsTypeId));
esq.Filters.Add(esqFilters);
}
private static ExpressionMetadata GenerateIsNullExpressionMetadata(ExpressionMetadata left,
FilterComparisonType comparisonType)
{
var nullComparisonType = GetNullComparisonType(comparisonType);
return(new ExpressionMetadata()
{
NodeType = ExpressionMetadataNodeType.Comparison,
LeftExpression = left,
ComparisonType = nullComparisonType
});
}
/// <summary>
/// Adds a status filter on the returned orchestrations
/// </summary>
/// <param name="status">The status to filter by</param>
/// <param name="comparisonType">type of comparison to be performed on the status</param>
/// <returns></returns>
public OrchestrationStateQuery AddStatusFilter(OrchestrationStatus status, FilterComparisonType comparisonType)
{
if (FilterMap.ContainsKey(typeof(OrchestrationStateStatusFilter)))
{
throw new ArgumentException("Cannot add more than one status filters");
}
FilterMap.Add(typeof(OrchestrationStateStatusFilter),
new OrchestrationStateStatusFilter {
Status = status, ComparisonType = comparisonType
});
return(this);
}
/// <summary>
/// Preparies communication details entities queries.
/// </summary>
/// <param name="filterType">Filter type.</param>
/// <param name="numberColumnAlias">Alias name of the number column.</param>
private void PrepareCommunicationDetailEntityQueries(FilterComparisonType filterType, string numberColumnAlias)
{
foreach (var detail in CommunicationDetails)
{
EntitySchemaQuery esq = PrepareDetailEsq(detail, numberColumnAlias);
if (esq != null)
{
ApplyDetailPhoneFilter(esq, filterType);
var numberColumn = esq.Columns.FindByName(CommunicationNumberColumnName);
if (numberColumn == null)
{
continue;
}
string numberColumnAliasWrap = GetColumnAliasWrapper(numberColumnAlias);
numberColumn.SetForcedQueryColumnValueAlias(numberColumnAliasWrap);
var key = string.Format("{0}_{1}", detail.Key, numberColumnAlias);
EntityQueries.Add(key, esq);
}
}
}
public static Filter CreateComparisonFilter(string columnPath, FilterComparisonType comparisonType,
DataValueType dataValueType, params object[] values)
{
var rightExpressions = values.Select(value => CreateParameterExpression(value, dataValueType)).ToList();
var filter = new Filter()
{
FilterType = FilterType.CompareFilter,
ComparisonType = comparisonType,
IsEnabled = true,
LeftExpression = CreateColumnExpression(columnPath),
RightExpression = rightExpressions.Count == 1 ? rightExpressions.First() : null,
RightExpressions = rightExpressions.Count > 1 ? rightExpressions.ToArray() : null
};
if (comparisonType == FilterComparisonType.IsNull)
{
filter.IsNull = true;
filter.FilterType = FilterType.IsNullFilter;
}
return(filter);
}
private static bool CanBeConvertedAsIsNullComparison(ExpressionMetadata left, FilterComparisonType comparisonType, ExpressionMetadata right)
{
return(right.NodeType == ExpressionMetadataNodeType.Property &&
right.Parameter.Value == null &&
left.NodeType == ExpressionMetadataNodeType.Column &&
(comparisonType == FilterComparisonType.Equal || comparisonType == FilterComparisonType.NotEqual));
}
public virtual void SetComparison(FilterComparisonType comparison, object value)
{
throw new NotSupportedException($"State handler '{GetType().Name}' does not support method {nameof(SetComparison)}");
}
/// <summary>
/// Adds length function filter for entity schema query to current filter collection.
/// </summary>
/// <param name="filterCollection">Filter collection, which the created filter will be added to.</param>
/// <param name="schema">Entity schema.</param>
/// <param name="columnName">Name of column, which should be operand for the function.</param>
/// <param name="comparisonType">Type of comparison with function.</param>
/// <param name="value">Value to compare function with.</param>
/// <returns>Created compare filter like "LEN(column_name) comparison_type value".</returns>
public static EntitySchemaQueryFilter AddLengthFilter(this EntitySchemaQueryFilterCollection filterCollection,
EntitySchema schema, string columnName, FilterComparisonType comparisonType, int value)
{
var esq = filterCollection.ParentQuery;
EntitySchemaQueryFunction function = esq.CreateLengthFunction(
EntitySchemaQuery.CreateSchemaColumnExpression(schema, columnName));
var filter = new EntitySchemaQueryFilter(FilterComparisonType.Equal)
{
LeftExpression = new EntitySchemaQueryExpression(function),
ComparisonType = comparisonType
};
filter.RightExpressions.Add(new EntitySchemaQueryExpression(EntitySchemaQueryExpressionType.Parameter)
{
ParameterValue = value
});
filterCollection.Add(filter);
return(filter);
}
/// <summary>
/// Initializes new instance of <see cref="QueryFilterData"/>.
/// </summary>
public QueryFilterData(string columnPath, object value, FilterComparisonType comparisonType)
{
ColumnPath = columnPath ?? throw new ArgumentNullException(nameof(columnPath));
Value = value;
ComparisonType = comparisonType;
}
internal static ExpressionMetadata GenerateComparisonExpressionMetadata(ExpressionMetadata left, FilterComparisonType comparisonType, params ExpressionMetadata[] rights)
{
return(new ExpressionMetadata()
{
NodeType = ExpressionMetadataNodeType.Comparison,
LeftExpression = left,
RightExpressions = rights.ToList(),
ComparisonType = comparisonType
});
}
public override void SetComparison(FilterComparisonType comparison, object value)
{
throw new NotSupportedException($"For filtering use .Where() clause.");
}
public void SetComparison(FilterComparisonType comparison, object value)
{
LogWriter.WriteLine($"* SetComparison: {comparison} {value}");
_currentState.SetComparison(comparison, value);
}
private static FilterComparisonType GetNullComparisonType(FilterComparisonType comparisonType)
{
return(comparisonType == FilterComparisonType.NotEqual
? FilterComparisonType.IsNotNull
: FilterComparisonType.IsNull);
}
public override void SetComparison(FilterComparisonType comparison, object value)
{
_currentFilter.AddFilter(new QueryFilterData(_filterColumn, value, comparison));
_filterColumn = null;
}
public static Filter CreateNullFilter(string columnPath, DataValueType dataValueType, FilterComparisonType comparisonType = FilterComparisonType.IsNull)
{
return(CreateComparisonFilter(columnPath, comparisonType, dataValueType));
}
public ComparisonFilter(FilterComparisonType type, object value, string propertyPath) : base(propertyPath)
{
Type = type;
Value = value;
}
