public void Apply_MultipleGreaterThanOrEqualFilter()
{
NumberFilter <Int32> filter = new NumberFilter <Int32> {
Method = "greater-than-or-equal", Values = new[] { "1", "2" }
};
IEnumerable expected = items.Where(model => model.Sum >= 1);
IEnumerable actual = items.Where(sumExpression, filter);
Assert.Equal(expected, actual);
}
public void Apply_MultipleNullableLessThanOrEqualFilter()
{
NumberFilter <Int32> filter = new NumberFilter <Int32> {
Method = "less-than-or-equal", Values = new[] { "", "1" }
};
IEnumerable expected = items.Where(model => model.NSum <= 1);
IEnumerable actual = items.Where(nSumExpression, filter);
Assert.Equal(expected, actual);
}
public void Apply_GreaterThanOrEqualFilter(String value, Int32?number)
{
NumberFilter <Int32> filter = new NumberFilter <Int32> {
Method = "greater-than-or-equal", Values = new[] { value }
};
IEnumerable actual = items.Where(sumExpression, filter);
IEnumerable expected = items.Where(model => model.Sum >= number);
Assert.Equal(expected, actual);
}
public void Apply_MultipleNullableGreaterThanFilter()
{
NumberFilter <Int32> filter = new NumberFilter <Int32> {
Method = "greater-than", Values = new[] { "", "1" }
};
IEnumerable expected = items.Where(model => model.NSum > 1);
IEnumerable actual = items.Where(nSumExpression, filter);
Assert.Equal(expected, actual);
}
public void Apply_MultipleLessThanFilter()
{
NumberFilter <Int32> filter = new NumberFilter <Int32> {
Method = "less-than", Values = new[] { "1", "2" }
};
IEnumerable expected = items.Where(model => model.Sum < 2);
IEnumerable actual = items.Where(sumExpression, filter);
Assert.Equal(expected, actual);
}
public void Apply_LessThanFilter(String value, Int32?number)
{
NumberFilter <Int32> filter = new NumberFilter <Int32> {
Method = "less-than", Values = new[] { value }
};
IEnumerable expected = items.Where(model => model.Sum < number);
IEnumerable actual = items.Where(sumExpression, filter);
Assert.Equal(expected, actual);
}
public void Apply_MultipleNotEqualsFilter()
{
NumberFilter <Int32> filter = new NumberFilter <Int32> {
Method = "not-equals", Values = new[] { "1", "2" }
};
IEnumerable expected = items.Where(model => model.Sum != 1 && model.Sum != 2);
IEnumerable actual = items.Where(sumExpression, filter);
Assert.Equal(expected, actual);
}
public void Apply_NullableNotEqualsFilter(String value, Int32?number)
{
NumberFilter <Int32> filter = new NumberFilter <Int32> {
Method = "not-equals", Values = new[] { value }
};
IEnumerable expected = items.Where(model => model.NSum != number);
IEnumerable actual = items.Where(nSumExpression, filter);
Assert.Equal(expected, actual);
}
public void SetUp()
{
models = new[] { new GridModel(), new GridModel {
NSum = 1, Sum = 1
}, new GridModel {
NSum = 2, Sum = 2
} }.AsQueryable();
Expression <Func <GridModel, Int32> > expression = (model) => model.Sum;
filter = Substitute.ForPartsOf <NumberFilter <GridModel> >();
filter.FilteredExpression = expression;
}
internal IQueryable <TEntity> Apply(IQueryable <TEntity> query, SearchModel searchModel)
{
if (searchModel.AdvancedFilterModels == null || searchModel.AdvancedFilterModels.Count <= 0)
{
return(query);
}
var accessExpresion = Expression.Parameter(typeof(TEntity), "x");
var filterPredicates = new List <FilterPredicate>();
var textualFilter = new TextualFilter <TEntity>();
var dateFilter = new DateFilter <TEntity>();
var booleanFilter = new BooleanFilter <TEntity>();
var numberFilter = new NumberFilter <TEntity>();
foreach (var filter in searchModel.AdvancedFilterModels)
{
switch (filter.Type)
{
case CellDataType.Date:
var filterPredicate = dateFilter.GetPredicateExpression(query, filter, accessExpresion);
filterPredicates.Add(filterPredicate);
break;
case CellDataType.Text:
var filterPredicate1 = textualFilter.GetPredicateExpression(query, filter, accessExpresion);
filterPredicates.Add(filterPredicate1);
break;
case CellDataType.Number:
var filterPredicate2 = numberFilter.GetPredicateExpression(query, filter, accessExpresion);
filterPredicates.Add(filterPredicate2);
break;
case CellDataType.Bool:
var filterPredicate3 = booleanFilter.GetPredicateExpression(query, filter, accessExpresion);
filterPredicates.Add(filterPredicate3);
break;
case CellDataType.None:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
query = textualFilter.BuildFilterExpression(query, filterPredicates, accessExpresion);
return(query);
}
public NumberFilterTests()
{
items = new[]
{
new GridModel(),
new GridModel { NSum = 1, Sum = 1 },
new GridModel { NSum = 2, Sum = 2 }
}.AsQueryable();
filter = Substitute.ForPartsOf<NumberFilter>();
nSumExpression = (model) => model.NSum;
sumExpression = (model) => model.Sum;
}
public NumberFilterTests()
{
items = new[]
{
new GridModel(),
new GridModel {
NSum = 1, Sum = 2
},
new GridModel {
NSum = 2, Sum = 1
}
}.AsQueryable();
filter = Substitute.ForPartsOf <NumberFilter>();
nSumExpression = (model) => model.NSum;
sumExpression = (model) => model.Sum;
}
public void ValidateNumberFilterTest()
{
var exception = Assert.Throws <StorageClientException>(() =>
{
var unused = new NumberFilter(null);
});
Assert.AreEqual("Number filter or it's values can't be null", exception.Message);
exception = Assert.Throws <StorageClientException>(() =>
{
var unused = new NumberFilter(new long[] { 1, 2 }, "illegal");
});
Assert.AreEqual("Operator in non range number filter can by only in [NULL,$not,$lt,$lte,$gt,$gte]",
exception.Message);
exception = Assert.Throws <StorageClientException>(() =>
{
var unused = new RangeFilter(1, "$gt", 2, "illegal");
});
Assert.AreEqual("Operator2 in range number filter can by only in [$lt,$lte]", exception.Message);
exception = Assert.Throws <StorageClientException>(() =>
{
var unused = new RangeFilter(2, "$gt", 1, "$lt");
});
Assert.AreEqual("The first value in range filter can by only less or equals the second value",
exception.Message);
exception = Assert.Throws <StorageClientException>(() =>
{
var unused = new RangeFilter(2, null, 1, "$lt");
});
Assert.AreEqual("Operator1 in range number filter can by only in [$gt,$gte]", exception.Message);
exception = Assert.Throws <StorageClientException>(() =>
{
var unused = new NumberFilter(new long[] { 2, 1 }, "$gt");
});
Assert.AreEqual("Operator in list number filter can by only in [NULL,$not]",
exception.Message);
}
public override bool Equals(object obj)
{
if (obj == null)
{
return(false);
}
if (obj == this)
{
return(true);
}
return(obj is CustomAttributeFilter other &&
((CustomAttributeDefinitionId == null && other.CustomAttributeDefinitionId == null) || (CustomAttributeDefinitionId?.Equals(other.CustomAttributeDefinitionId) == true)) &&
((Key == null && other.Key == null) || (Key?.Equals(other.Key) == true)) &&
((StringFilter == null && other.StringFilter == null) || (StringFilter?.Equals(other.StringFilter) == true)) &&
((NumberFilter == null && other.NumberFilter == null) || (NumberFilter?.Equals(other.NumberFilter) == true)) &&
((SelectionUidsFilter == null && other.SelectionUidsFilter == null) || (SelectionUidsFilter?.Equals(other.SelectionUidsFilter) == true)) &&
((BoolFilter == null && other.BoolFilter == null) || (BoolFilter?.Equals(other.BoolFilter) == true)));
}
public override int GetHashCode()
{
int hashCode = 1810299489;
if (CustomAttributeDefinitionId != null)
{
hashCode += CustomAttributeDefinitionId.GetHashCode();
}
if (Key != null)
{
hashCode += Key.GetHashCode();
}
if (StringFilter != null)
{
hashCode += StringFilter.GetHashCode();
}
if (NumberFilter != null)
{
hashCode += NumberFilter.GetHashCode();
}
if (SelectionUidsFilter != null)
{
hashCode += SelectionUidsFilter.GetHashCode();
}
if (BoolFilter != null)
{
hashCode += BoolFilter.GetHashCode();
}
return(hashCode);
}
public void given_3446_assume_skip_returns_true()
{
var filter = new NumberFilter();
Assert.Equal(true, filter.Skip("34567"));
}
public FindFilter KeyEq(NumberField field, params long[] values)
{
_numberFilters[field] = new NumberFilter(values);
return(this);
}
public FindFilter KeyLess(NumberField field, long value, bool includingValue = true)
{
_numberFilters[field] = new NumberFilter(new[] { value },
includingValue ? Filter.OperatorLessOrEquals : Filter.OperatorLess);
return(this);
}
public FindFilter KeyNotEq(NumberField field, params long[] values)
{
_numberFilters[field] = new NumberFilter(values, Filter.OperatorNot);
return(this);
}
private static BinaryExpression GetNumberExpression <TSource>(NumberFilter numberFilter, ParameterExpression paramExpression)
{
var sourceType = typeof(TSource);
var propertyInfo = sourceType.GetProperty(numberFilter.FieldName);
if (propertyInfo == null)
{
throw new InvalidOperationException($"Filter property {numberFilter.FieldName} not found");
}
var fieldExpr = Expression.Property(paramExpression, propertyInfo);
var number = ConvertFromInvariantString(propertyInfo.PropertyType, numberFilter.Number);
var valExpr = Expression.Constant(number);
//var valExpr = Expression.Constant(numberFilter.Number);
BinaryExpression binaryExpression = null;
switch (numberFilter.Operator)
{
case NumberOperator.Equal:
binaryExpression = Expression.Equal(fieldExpr, valExpr);
break;
case NumberOperator.GreaterThan:
binaryExpression = Expression.GreaterThan(fieldExpr, valExpr);
break;
case NumberOperator.GreaterThanOrEqual:
binaryExpression = Expression.GreaterThanOrEqual(fieldExpr, valExpr);
break;
case NumberOperator.InRange:
var fromNumber = ConvertFromInvariantString(propertyInfo.PropertyType, numberFilter.FromNumber);
var toNumber = ConvertFromInvariantString(propertyInfo.PropertyType, numberFilter.ToNumber);
var fromExpr = Expression.GreaterThanOrEqual(fieldExpr, Expression.Constant(fromNumber));
var toExpr = Expression.LessThanOrEqual(fieldExpr, Expression.Constant(toNumber));
binaryExpression = Expression.AndAlso(fromExpr, toExpr);
break;
case NumberOperator.LessThan:
binaryExpression = Expression.LessThan(fieldExpr, valExpr);
break;
case NumberOperator.LessThanOrEqual:
binaryExpression = Expression.LessThanOrEqual(fieldExpr, valExpr);
break;
case NumberOperator.NotEqual:
binaryExpression = Expression.NotEqual(fieldExpr, valExpr);
break;
default:
throw new InvalidOperationException($"Operator cannot be found for field {numberFilter.FieldName}");
}
return(binaryExpression);
}
private CommandType RunCommand(string command)
{
if (command == "--help" || command == "-?")
{
showHelp(this.cbxImportItems);
return(CommandType.Help);
}
if (command == "--version" || command == "-v")
{
Console.WriteLine("Version:" + Assembly.GetExecutingAssembly().GetName().Version);
return(CommandType.Help);
}
if (command.StartsWith("-i:"))
{
wordLibraryImport = GetImportInterface(command.Substring(3));
beginImportFile = true;
return(CommandType.Import);
}
if (command.StartsWith("-o:"))
{
wordLibraryExport = GetExportInterface(command.Substring(3));
beginImportFile = false;
return(CommandType.Export);
}
if (command.StartsWith("-c:")) //code
{
codingFile = command.Substring(3);
pattern.MappingTablePath = codingFile;
pattern.IsPinyinFormat = false;
beginImportFile = false;
return(CommandType.Coding);
}
if (command.StartsWith("-ft:")) //filter
{
var filterStrs = command.Substring(4);
Regex lenRegex = new Regex(@"len:(\d+)-(\d+)");
Regex rankRegex = new Regex(@"rank:(\d+)-(\d+)");
Regex rmRegex = new Regex(@"rm:(\w+)");
foreach (var filterStr in filterStrs.Split('|'))
{
if (lenRegex.IsMatch(filterStr))
{
var match = lenRegex.Match(filterStr);
var from = Convert.ToInt32(match.Groups[1].Value);
var to = Convert.ToInt32(match.Groups[2].Value);
var numberFilter = new LengthFilter()
{
MinLength = from, MaxLength = to
};
this.filters.Add(numberFilter);
}
else if (rankRegex.IsMatch(filterStr))
{
var match = rankRegex.Match(filterStr);
var from = Convert.ToInt32(match.Groups[1].Value);
var to = Convert.ToInt32(match.Groups[2].Value);
var rFilter = new RankFilter()
{
MinLength = from, MaxLength = to
};
this.filters.Add(rFilter);
}
else if (rmRegex.IsMatch(filterStr))
{
var match = rmRegex.Match(filterStr);
var rmType = match.Groups[1].Value;
ISingleFilter filter;
switch (rmType)
{
case "eng": filter = new EnglishFilter(); break;
case "num": filter = new NumberFilter(); break;
case "space": filter = new SpaceFilter(); break;
case "pun": filter = new EnglishPunctuationFilter(); break;
default: throw new ArgumentException("Unsupport filter type:" + rmType);
}
this.filters.Add(filter);
}
}
return(CommandType.Coding);
}
if (command.StartsWith("-ct:")) //code type
{
var codeType = command.Substring(4).ToLower();
switch (codeType)
{
case "pinyin": pattern.CodeType = CodeType.Pinyin; break;
case "wubi": pattern.CodeType = CodeType.Wubi; break;
case "zhengma": pattern.CodeType = CodeType.Zhengma; break;
case "cangjie": pattern.CodeType = CodeType.Cangjie; break;
case "zhuyin": pattern.CodeType = CodeType.TerraPinyin; break;
default: pattern.CodeType = CodeType.Pinyin; break;
}
return(CommandType.CodeType);
}
if (command.StartsWith("-r:")) //Rank
{
var rankType = command.Substring(3).ToLower();
switch (rankType)
{
case "baidu": this.wordRankGenerater = new BaiduWordRankGenerater(); break;
case "google": this.wordRankGenerater = new GoogleWordRankGenerater(); break;
default: {
var rankNumber = Convert.ToInt32(rankType);
var gen = new DefaultWordRankGenerater();
gen.ForceUse = true;
gen.Rank = rankNumber;
this.wordRankGenerater = gen;
} break;
}
return(CommandType.CodeType);
}
if (command.StartsWith("-os:")) //code type
{
var os = command.Substring(4).ToLower();
switch (os)
{
case "windows": pattern.OS = OperationSystem.Windows; break;
case "mac":
case "macos": pattern.OS = OperationSystem.MacOS; break;
case "linux":
case "unix": pattern.OS = OperationSystem.Linux; break;
default: pattern.OS = OperationSystem.Windows; break;
}
return(CommandType.OS);
}
if (command.StartsWith("-ld2:")) //ld2 encoding
{
string ecodes = command.Substring(5);
string[] arr = ecodes.Split(',');
wordEncoding = Encoding.GetEncoding(arr[0]);
if (arr.Length > 1)
{
xmlEncoding = Encoding.GetEncoding(arr[1]);
}
return(CommandType.Encoding);
}
if (command.StartsWith("-f:")) //format
{
format = command.Substring(3);
beginImportFile = false;
var sort = new List <int>();
for (int i = 0; i < 3; i++)
{
char c = format[i];
sort.Add(Convert.ToInt32(c));
}
pattern.Sort = sort;
pattern.CodeSplitString = format[3].ToString();
pattern.SplitString = format[4].ToString();
string t = format[5].ToString().ToLower();
beginImportFile = false;
if (t == "l")
{
pattern.CodeSplitType = BuildType.LeftContain;
}
if (t == "r")
{
pattern.CodeSplitType = BuildType.RightContain;
}
if (t == "b")
{
pattern.CodeSplitType = BuildType.FullContain;
}
if (t == "n")
{
pattern.CodeSplitType = BuildType.None;
}
pattern.ContainCode = (format[6].ToString().ToLower() == "y");
pattern.ContainRank = (format[8].ToString().ToLower() == "y");
return(CommandType.Format);
}
if (beginImportFile)
{
importPaths.AddRange(FileOperationHelper.GetFilesPath(command));
}
if (type == CommandType.Export)
{
exportPath = command;
}
return(CommandType.Other);
}
public void given_abc123_assume_skipr_returns_false()
{
var filter = new NumberFilter();
Assert.Equal(false, filter.Skip("abc123"));
}
public void given_empty_string_assume_skip_equals_true()
{
var filter = new NumberFilter();
Assert.Equal(true, filter.Skip(" "));
}
private void HandleTextChanged(object sender, TextChangedEventArgs e)
{
NumberFilter num = new NumberFilter();
((Entry)sender).Text = num.letterFilter(e.NewTextValue);
}
