/// <summary>
/// 处理In中的select
/// </summary>
/// <param name="where"></param>
private void HandlerInFilterWhere(IEnumerable <IFilter> where)
{
if (where.Any())
{
foreach (IFilter filter in where)
{
if (filter is InFilter)
{
InFilter infilter = filter as InFilter;
if (infilter.Values is SelectBuilder)
{
SelectBuilder inSel = infilter.Values as SelectBuilder;
var intb = inSel.Sources.Sources;
if (intb.Any())
{
foreach (AliasedSource tb in intb)
{
//添加有效期验证
FilterGroup inFilter = new FilterGroup(Conjunction.And,
new LessThanEqualToFilter(tb.Column(FapDbConstants.FAPCOLUMN_FIELD_EnableDate), new ParameterLiteral(FapDbConstants.FAPCOLUMN_PARAM_CurrentDate)),
new GreaterThanEqualToFilter(tb.Column(FapDbConstants.FAPCOLUMN_FIELD_DisableDate), new ParameterLiteral(FapDbConstants.FAPCOLUMN_PARAM_CurrentDate)),
new EqualToFilter(tb.Column(FapDbConstants.FAPCOLUMN_FIELD_Dr), new ParameterLiteral(FapDbConstants.FAPCOLUMN_PARAM_Dr)));
inSel.AddWhere(inFilter);
}
}
}
}
}
}
}
public void Constructor_WithIntegerValues_PropertiesAreSet()
{
var filter = new InFilter <int>("score", 1, 2);
Assert.That(filter.Dimension, Is.EqualTo("score"));
Assert.That(filter.Values.Count(), Is.EqualTo(2));
Assert.That(filter.Values, Contains.Item(1));
Assert.That(filter.Values, Contains.Item(2));
}
public void Constructor_WithStringValues_PropertiesAreSet()
{
var filter = new InFilter <string>("outlaw", "Good", "Bad", "Ugly");
Assert.That(filter.Dimension, Is.EqualTo("outlaw"));
Assert.That(filter.Values.Count(), Is.EqualTo(3));
Assert.That(filter.Values, Contains.Item("Good"));
Assert.That(filter.Values, Contains.Item("Bad"));
Assert.That(filter.Values, Contains.Item("Ugly"));
}
protected override void VisitInFilter(InFilter item)
{
Column attColumn;
var condition = GetCondition(item, out attColumn);
if (this.NegateOperator)
{
condition.NegateOperator();
}
AddFilterCondition(condition, attColumn);
return;
}
public IFilter Parse(BsonValue filter)
{
if (!filter.IsBsonArray)
{
throw new ArgumentOutOfRangeException(nameof(filter));
}
var values = new ReadOnlyCollection <BsonValue>(filter.AsBsonArray);
var inFilter = new InFilter(values);
return(new NotFilter(inFilter));
}
private MetadataConditionExpression GetCondition(InFilter filter, out Column attColumn)
{
var condition = new MetadataConditionExpression();
var left = filter.LeftHand;
attColumn = left as Column;
// defaullt attribute name for the filter condition.
if (attColumn != null)
{
condition.PropertyName = attColumn.Name;
}
else
{
throw new NotSupportedException("IN operator only works agains a column value.");
}
var conditionOperator = MetadataConditionOperator.In;
if (filter.Not)
{
conditionOperator = MetadataConditionOperator.NotIn;
}
var values = filter.Values;
if (values.IsValueList)
{
var valuesList = values as ValueList;
if (valuesList != null)
{
var inValues = new object[valuesList.Values.Count()];
int index = 0;
foreach (var item in valuesList.Values)
{
var literal = item as Literal;
if (literal == null)
{
throw new ArgumentException("The values list must contain literals.");
}
inValues[index] = GitLiteralValue(literal);
index++;
}
SetConditionExpressionValue(condition, conditionOperator, inValues);
return(condition);
}
throw new ArgumentException("The values list for the IN expression is null");
}
throw new NotSupportedException();
}
protected virtual Command Filter(InFilter filter)
{
//Validating if there are filters defined
if (filter == null)
{
return(null);
}
Command command = new Command();
command.Append(ColumnFullName(filter));
command.Append(InClause(filter.Values.ToList()));
return(command);
}
/// <summary>
/// Generates the text for an InFilter builder.
/// </summary>
/// <param name="item">The InFilter builder to generate the text for.</param>
protected internal override void VisitInFilter(InFilter item)
{
Action visitor = () =>
{
item.LeftHand.Accept(forSubCommand());
writer.Write(" ");
if (item.Not)
{
writer.Write("NOT ");
}
writer.Write("IN ");
item.Values.Accept(forSubCommand());
};
visitFilter(item, visitor);
}
public void TestToWhereExpression_NullableIntProperty_PropertyValueIsNull()
{
var list = new List <InFilterTestClass>();
list.Add(new InFilterTestClass
{
NullableId = null
});
var testInList = new List <int> {
1
};
var filter = new InFilter <InFilterTestClass>("NullableId", testInList);
var where = filter.ToWhereExpression();
var results = list.Where(where.Compile()).ToList();
Assert.AreEqual(0, results.Count);
}
private static IFilter ParseFilterIn(QueryOperator queryOperator, XElement element)
{
var filter = new InFilter {
QueryOperator = queryOperator
};
foreach (var attribute in element.Attributes())
{
filter.FilterAttributes.Add(attribute.Name.LocalName, attribute.Value);
}
//---
var fieldRefElement = element.Element("FieldRef");
var valuesElement = element.Element("Values");
ParseFieldRef(fieldRefElement, filter);
filter.FieldValues = valuesElement?.Elements("Value").Select(e => e.Value).ToList() ?? new List <string>();
return(filter);
}
public void LongUrl()
{
_mockHttp.When($"{_baseUrl}/items")
.Respond("application/json", File.ReadAllText(Path.Combine(Environment.CurrentDirectory, "Fixtures\\DeliveryClient\\items.json")));
var httpClient = _mockHttp.ToHttpClient();
var client = new DeliveryClient(_guid)
{
HttpClient = httpClient
};
var elements = new ElementsParameter(Enumerable.Range(0, 1000).Select(i => "test").ToArray());
var inFilter = new InFilter("test", Enumerable.Range(0, 1000).Select(i => "test").ToArray());
var allFilter = new AllFilter("test", Enumerable.Range(0, 1000).Select(i => "test").ToArray());
var anyFilter = new AnyFilter("test", Enumerable.Range(0, 1000).Select(i => "test").ToArray());
// Act
var response = client.GetItemsAsync(elements, inFilter, allFilter, anyFilter).Result;
// Assert
Assert.NotNull(response);
}
public void LongUrl()
{
_mockHttp
.When($"{_baseUrl}/items")
.Respond("application/json", File.ReadAllText(Path.Combine(Environment.CurrentDirectory, $"Fixtures{Path.DirectorySeparatorChar}DeliveryClient{Path.DirectorySeparatorChar}items.json")));
var client = DeliveryClientFactory.GetMockedDeliveryClientWithProjectId(_guid, _mockHttp);
A.CallTo(() => client.ResiliencePolicyProvider.Policy)
.Returns(Policy.HandleResult <HttpResponseMessage>(result => true)
.RetryAsync(client.DeliveryOptions.MaxRetryAttempts));
var elements = new ElementsParameter(Enumerable.Range(0, 1000).Select(i => "test").ToArray());
var inFilter = new InFilter("test", Enumerable.Range(0, 1000).Select(i => "test").ToArray());
var allFilter = new AllFilter("test", Enumerable.Range(0, 1000).Select(i => "test").ToArray());
var anyFilter = new AnyFilter("test", Enumerable.Range(0, 1000).Select(i => "test").ToArray());
// Act
var response = client.GetItemsAsync(elements, inFilter, allFilter, anyFilter).Result;
// Assert
Assert.NotNull(response);
}
public void TestToWhereExpression_IntProperty_FilterValuesAreLong()
{
var list = new List <InFilterTestClass>();
list.Add(new InFilterTestClass
{
Id = 1
});
list.Add(new InFilterTestClass
{
Id = 2
});
var testInList = new List <long> {
1L
};
var filter = new InFilter <InFilterTestClass>("Id", testInList);
var where = filter.ToWhereExpression();
var results = list.Where(where.Compile()).ToList();
Assert.AreEqual(1, results.Count);
}
public void TestToWhereExpression_IntProperty_MultipleInFilterValues()
{
var list = new List <InFilterTestClass>();
list.Add(new InFilterTestClass
{
Id = 1
});
list.Add(new InFilterTestClass
{
Id = 2
});
var testInList = new List <int> {
list.First().Id, list.Last().Id
};
var filter = new InFilter <InFilterTestClass>("Id", testInList);
var where = filter.ToWhereExpression();
var results = list.Where(where.Compile()).ToList();
Assert.AreEqual(2, results.Count);
}
/// <summary>
/// Builds the actual filter SQL expression <c>[Attribute-Operand] [Operator] [Comparison-Value]</c> for the given
/// attribute <paramref name="filter"/>.
/// </summary>
/// <param name="filter">Attribute filter instance to create the SQL expression for.</param>
/// <param name="attributeOperand">Comparison attribute to be used. Depending on the cardinality of the
/// to-be-filtered attribute, this will be the inline attribute alias or the attribute alias of the collection
/// attribute table.</param>
/// <param name="bvNamespace">Namespace used to build bind var names.</param>
/// <param name="resultParts">Statement parts for the attribute filter.</param>
/// <param name="resultBindVars">Bind variables for the attribute filter.</param>
public static void BuildAttributeFilterExpression(IAttributeFilter filter, object attributeOperand, BindVarNamespace bvNamespace,
IList <object> resultParts, IList <BindVar> resultBindVars)
{
Type attributeType = filter.AttributeType.AttributeType;
RelationalFilter relationalFilter = filter as RelationalFilter;
if (relationalFilter != null)
{
resultParts.Add(attributeOperand);
switch (relationalFilter.Operator)
{
case RelationalOperator.EQ:
resultParts.Add(" = ");
break;
case RelationalOperator.NEQ:
resultParts.Add(" <> ");
break;
case RelationalOperator.LT:
resultParts.Add(" < ");
break;
case RelationalOperator.LE:
resultParts.Add(" <= ");
break;
case RelationalOperator.GT:
resultParts.Add(" > ");
break;
case RelationalOperator.GE:
resultParts.Add(" >= ");
break;
default:
throw new NotImplementedException(string.Format(
"Relational filter operator '{0}' isn't supported by the media library", relationalFilter.Operator));
}
BindVar bindVar = new BindVar(bvNamespace.CreateNewBindVarName("V"), relationalFilter.FilterValue, attributeType);
resultParts.Add("@" + bindVar.Name);
resultBindVars.Add(bindVar);
return;
}
LikeFilter likeFilter = filter as LikeFilter;
if (likeFilter != null)
{
if (!likeFilter.CaseSensitive)
{
resultParts.Add("UPPER(");
}
resultParts.Add(attributeOperand);
if (!likeFilter.CaseSensitive)
{
resultParts.Add(")");
}
resultParts.Add(" LIKE ");
BindVar bindVar = new BindVar(bvNamespace.CreateNewBindVarName("V"), likeFilter.Expression, attributeType);
if (likeFilter.CaseSensitive)
{
resultParts.Add("@" + bindVar.Name);
}
else
{
resultParts.Add("UPPER(@" + bindVar.Name + ")");
}
resultBindVars.Add(bindVar);
if (likeFilter.EscapeChar.HasValue)
{
bindVar = new BindVar(bvNamespace.CreateNewBindVarName("E"), likeFilter.EscapeChar.ToString(), typeof(Char));
resultParts.Add(" ESCAPE @" + bindVar.Name);
resultBindVars.Add(bindVar);
}
return;
}
BetweenFilter betweenFilter = filter as BetweenFilter;
if (betweenFilter != null)
{
resultParts.Add(attributeOperand);
resultParts.Add(" BETWEEN ");
BindVar bindVar = new BindVar(bvNamespace.CreateNewBindVarName("V"), betweenFilter.Value1, attributeType);
resultParts.Add("@" + bindVar.Name);
resultBindVars.Add(bindVar);
resultParts.Add(" AND ");
bindVar = new BindVar(bvNamespace.CreateNewBindVarName("V"), betweenFilter.Value2, attributeType);
resultParts.Add("@" + bindVar.Name);
resultBindVars.Add(bindVar);
return;
}
InFilter inFilter = filter as InFilter;
if (inFilter != null)
{
if (inFilter.Values.Count == 0)
{
resultParts.Add("1 = 2"); // No comparison values means filter is always false
return;
}
int clusterCount = 0;
foreach (IList <object> valuesCluster in CollectionUtils.Cluster(inFilter.Values, MAX_IN_VALUES_SIZE))
{
if (clusterCount > 0)
{
resultParts.Add(" OR ");
}
resultParts.Add(attributeOperand);
IList <string> bindVarRefs = new List <string>(MAX_IN_VALUES_SIZE);
foreach (object value in valuesCluster)
{
BindVar bindVar = new BindVar(bvNamespace.CreateNewBindVarName("V"), value, attributeType);
bindVarRefs.Add("@" + bindVar.Name);
resultBindVars.Add(bindVar);
}
resultParts.Add(" IN (" + StringUtils.Join(", ", bindVarRefs) + ")");
clusterCount++;
}
return;
}
throw new InvalidDataException("Filter type '{0}' isn't supported by the media library", filter.GetType().Name);
}
public override async Task <ICollection <FilterValue> > GetAvailableValuesAsync(IEnumerable <Guid> necessaryMIATypeIds, IFilter selectAttributeFilter, IFilter filter)
{
IContentDirectory cd = ServiceRegistration.Get <IServerConnectionManager>().ContentDirectory;
if (cd == null)
{
throw new NotConnectedException("The MediaLibrary is not connected");
}
bool showVirtual = VirtualMediaHelper.ShowVirtualMedia(necessaryMIATypeIds);
if (string.IsNullOrEmpty(CertificationHelper.DisplayMovieCertificationCountry))
{
HomogenousMap valueGroups = await cd.GetValueGroupsAsync(MovieAspect.ATTR_CERTIFICATION, null, ProjectionFunction.None,
necessaryMIATypeIds, filter, true, showVirtual);
IList <FilterValue> result = new List <FilterValue>(valueGroups.Count);
int numEmptyEntries = 0;
foreach (KeyValuePair <object, object> group in valueGroups)
{
string certification = (string)group.Key;
if (!string.IsNullOrEmpty(certification))
{
CertificationMapping cert;
if (CertificationMapper.TryFindMovieCertification(certification, out cert))
{
result.Add(new FilterValue(cert.CertificationId, cert.Name,
new RelationalFilter(MovieAspect.ATTR_CERTIFICATION, RelationalOperator.EQ, certification), null, (int)group.Value, this));
}
}
else
{
numEmptyEntries += (int)group.Value;
}
}
if (numEmptyEntries > 0)
{
result.Insert(0, new FilterValue("UR", Consts.RES_VALUE_UNRATED_TITLE, new EmptyFilter(MovieAspect.ATTR_CERTIFICATION), null, numEmptyEntries, this));
}
return(result);
}
else
{
IList <FilterValue> result = new List <FilterValue>();
IFilter emptyFilter = new EmptyFilter(MovieAspect.ATTR_CERTIFICATION);
int numEmptyItems = await cd.CountMediaItemsAsync(necessaryMIATypeIds, BooleanCombinationFilter.CombineFilters(BooleanOperator.And, filter, emptyFilter), true, showVirtual);
if (numEmptyItems > 0)
{
result.Add(new FilterValue("UR", Consts.RES_VALUE_UNRATED_TITLE, emptyFilter, null, numEmptyItems, this));
}
List <string> usedFilters = new List <string>();
foreach (var cert in CertificationMapper.GetMovieCertificationsForCountry(CertificationHelper.DisplayMovieCertificationCountry))
{
IEnumerable <CertificationMapping> certs = CertificationMapper.FindAllAllowedMovieCertifications(cert.CertificationId);
if (certs.Count() > 0)
{
List <string> certList = new List <string>(certs.Select(c => c.CertificationId).Except(usedFilters));
usedFilters.AddRange(certList);
IFilter certFilter = new InFilter(MovieAspect.ATTR_CERTIFICATION, certList);
int numItems = await cd.CountMediaItemsAsync(necessaryMIATypeIds, BooleanCombinationFilter.CombineFilters(BooleanOperator.And, filter, certFilter), true, showVirtual);
result.Add(new FilterValue(cert.CertificationId, cert.Name, certFilter, null, numItems, this));
}
}
return(result);
}
}
public void InFilterTest()
{
var filter = new InFilter <OrderStatusType>("filterName", OrderStatusType.CREATED, OrderStatusType.NOT_PAID, OrderStatusType.PAID);
Assert.AreEqual("filterName::in(CREATED,NOT_PAID,PAID)", filter.ToString());
}
public void Constructor_TypeIsCorrect()
{
var filter = new InFilter <string>("test_dimension");
Assert.That(filter.Type, Is.EqualTo("in"));
}
public void TestConstructor_ValueIsNotIEnumerable()
{
var filter = new InFilter <InFilterTestClass>("Id", 1);
}
public void TestConstructor_PropertyTypeIsNotNumeric_CollectionIsNumeric()
{
var filter = new InFilter <InFilterTestClass>("S", new List <int>());
}
