public void shouldReturnNullWhenElementIsEmpty()
{
XmlElement element = _document.CreateElement("QueryFilter");
FilterParser parser = new FilterParser(_metaModel.GetAssetType("Test"));
IFilterTerm term = parser.parse(element);
Assert.IsNull(term);
}
public void shouldThrowConfigurationExceptionWhenElementIsInvalid()
{
XmlDocument document = new XmlDocument();
XmlElement element = document.CreateElement("NotWhatWeExpect");
FilterParser parser = new FilterParser(_metaModel.GetAssetType("Test"));
try
{
parser.parse(element);
Assert.Fail("Expected Configuration Exception");
}
catch (ConfigurationException){}
}
public void shouldReturnValidFilterTermWhenOnlyOneTermIsPresent()
{
XmlDocument document = new XmlDocument();
XmlElement termElement = document.CreateElement("FilterTerm");
termElement.SetAttribute("attribute", "Name");
termElement.SetAttribute("operator", "=");
termElement.SetAttribute("value", "Fred");
XmlElement filterElement = document.CreateElement("QueryFilter");
filterElement.AppendChild(termElement);
FilterParser parser = new FilterParser(_metaModel.GetAssetType("Test"));
IFilterTerm term = parser.parse(filterElement);
Assert.IsNotNull(term);
Assert.AreEqual("Name='Fred'", term.Token);
}
public static IList<IFilterDescriptor> Create(string input)
{
IList<IFilterDescriptor> result = new List<IFilterDescriptor>();
FilterParser parser = new FilterParser(input);
IFilterNode filterNode = parser.Parse();
if (filterNode == null)
{
return result;
}
FilterNodeVisitor visitor = new FilterNodeVisitor();
filterNode.Accept(visitor);
result.Add(visitor.Result);
return result;
}
Func <EventRecordProxy, bool> GetViewFilter(TxReader reader)
{
Func <EventRecordProxy, bool> where = null;
if (reader.ShouldFilterByWhere)
{
where = FilterParser.ParseWhere <EventRecordProxy>(reader.WhereFilter);
}
Func <EventRecordProxy, bool> func = (e) =>
{
if (reader.ShouldFilterTimeWindow && !reader.TimeFilter(e.TimeStamp.Ticks))
{
return(false);
}
if (reader.ShouldFilterKeywords && !reader.KeywordFilter(e.Keywords))
{
return(false);
}
if (reader.ShouldFilterProviders && !reader.ProviderFilter(e.ProviderId))
{
return(false);
}
if (reader.ShouldFilterByWhere && !where (e))
{
return(false);
}
return(true);
};
return(func);
}
public void Parser()
{
FilterParser parser;
IFilter result;
FilterAndSet filters;
parser = new FilterParser("FirstField=Value, SecondField=OtherValue | OrSecond = SomethingElse | OrThird ~= Field, Last!=Condition");
result = parser.Parse();
Assert.True(result is FilterAndSet);
filters = (FilterAndSet)result;
Assert.Equal(3, ((FilterAndSet)filters).Count);
Assert.IsType <Filter>(filters[0]);
Assert.Equal("FirstField", (filters[0] as Filter).Field);
Assert.Equal("=", (filters[0] as Filter).Operator);
Assert.Equal("Value", (filters[0] as Filter).Value);
Assert.IsType <FilterOrSet>(filters[1]);
Assert.Equal(3, (filters[1] as FilterOrSet).Count);
(filters[1] as FilterOrSet).ForEach(x => Assert.IsType <Filter>(x));
Assert.Equal("SecondField", ((filters[1] as FilterOrSet)[0] as Filter).Field);
Assert.Equal("=", ((filters[1] as FilterOrSet)[0] as Filter).Operator);
Assert.Equal("OtherValue", ((filters[1] as FilterOrSet)[0] as Filter).Value);
Assert.Equal("OrSecond", ((filters[1] as FilterOrSet)[1] as Filter).Field);
Assert.Equal("=", ((filters[1] as FilterOrSet)[1] as Filter).Operator);
Assert.Equal("SomethingElse", ((filters[1] as FilterOrSet)[1] as Filter).Value);
Assert.Equal("OrThird", ((filters[1] as FilterOrSet)[2] as Filter).Field);
Assert.Equal("~=", ((filters[1] as FilterOrSet)[2] as Filter).Operator);
Assert.Equal("Field", ((filters[1] as FilterOrSet)[2] as Filter).Value);
Assert.IsType <Filter>(filters[2]);
Assert.Equal("Last", (filters[2] as Filter).Field);
Assert.Equal("!=", (filters[2] as Filter).Operator);
Assert.Equal("Condition", (filters[2] as Filter).Value);
}
public void Single_Filter_Should_Parse_Global_And_Local_Custom_Operator_Successfully()
{
// Arrange
var filter = "(Email[SimilarTo]@gmail.com)[or](Email[EndsWith]@gmail.com)";
var localOverride = new Dictionary <OperatorType, string>()
{
{ OperatorType.Like, "SimilarTo" }
};
var globalOverride = new Dictionary <OperatorType, string>()
{
{ OperatorType.EndsWith, "EndsWith" }
};
// Act
var parseResults = new FilterParser(globalOverride).Parse(filter, localOverride);
// Assert
Assert.NotNull(parseResults);
Assert.NotEmpty(parseResults);
Assert.Equal(typeof(Criterion), parseResults.ElementAt(0).GetType());
Assert.Equal(ConditionOperatorType.Like, ((Criterion)parseResults.ElementAt(0)).Operator);
Assert.Equal(typeof(Criterion), parseResults.ElementAt(1).GetType());
Assert.Equal(ConditionOperatorType.EndsWith, ((Criterion)parseResults.ElementAt(1)).Operator);
}
/// <summary>
/// 查询单条记录
/// </summary>
/// <param name="table">数据表名称</param>
/// <param name="filter">过滤条件</param>
/// <returns>返回数据列表</returns>
public T SelectSingle <T>(string table, object filter)
{
var filterEntities = JsonParser.ConvertEntities(filter);
if (filterEntities.Count <= 0)
{
throw new Exception("未传入筛选条件,未防止错误,该执行已停止.");
}
var filterSql = new FilterParser().Parse(table, filterEntities[0]);
if (string.IsNullOrEmpty(filterSql))
{
throw new Exception("未能解析出需要筛选sql语句,未防止错误,该执行已停止.");
}
var sql = new SelectParser().Parse(table);
if (string.IsNullOrEmpty(sql))
{
throw new Exception("未能解析出需要执行的sql语句.");
}
var entity = this.QuerySingle <T>(sql + " WHERE " + filterSql);
return(entity);
}
private void InitializeFakeObjects()
{
_parser = new FilterParser();
}
public void Nested_Filter_Should_Convert_Second_Tier_Successfully()
{
// Arrange
var filter = "(LastName[eq]Doe)[and]((FirstName[eq]John)[or](FirstName[eq]Jane))";
// Act
var stringResults = new FilterParser().Parse(filter);
var typeResults = new FilterParser().ParseAs(filter, new TypeSearchConverter <object>());
// Assert
Assert.NotNull(stringResults);
Assert.NotNull(typeResults);
Assert.NotEmpty(stringResults);
Assert.NotEmpty(typeResults.Criteria);
// StringSearch
Assert.Equal(typeof(NestedCriterion), stringResults.ElementAt(1).GetType());
var stringNestedCriterion = (NestedCriterion)stringResults.ElementAt(1);
Assert.Equal(typeof(Criterion), stringNestedCriterion.Criteria.ElementAt(0).GetType());
var stringFirstCriterion = (Criterion)stringNestedCriterion.Criteria.ElementAt(0);
Assert.Equal(LogicOperatorType.And, stringFirstCriterion.LogicOperator);
Assert.Equal("FirstName", stringFirstCriterion.Name);
Assert.Equal(ConditionOperatorType.Equals, stringFirstCriterion.Operator);
Assert.Equal("John", stringFirstCriterion.Value);
Assert.Equal(typeof(Criterion), stringNestedCriterion.Criteria.ElementAt(1).GetType());
var stringSecondCriterion = (Criterion)stringNestedCriterion.Criteria.ElementAt(1);
Assert.Equal(LogicOperatorType.Or, stringSecondCriterion.LogicOperator);
Assert.Equal("FirstName", stringSecondCriterion.Name);
Assert.Equal(ConditionOperatorType.Equals, stringSecondCriterion.Operator);
Assert.Equal("Jane", stringSecondCriterion.Value);
// TypeSearch
Assert.Equal(typeof(CriteriaContainer <object>), typeResults.Criteria.ElementAt(1).GetType());
var typeCriterion = typeResults.Criteria.ElementAt(1);
Assert.NotNull(typeCriterion.NestedFilter);
var nestedCriteria = typeCriterion.NestedFilter;
Assert.Equal(typeof(CriteriaContainer <object>), nestedCriteria.Criteria.ElementAt(0).GetType());
var typeNestedCriterion1 = nestedCriteria.Criteria.ElementAt(0);
Assert.NotNull(typeNestedCriterion1.SingleCriterion);
var typeFirstCriterion = typeNestedCriterion1.SingleCriterion;
Assert.Equal(LogicalOperator.And, typeNestedCriterion1.Operator);
Assert.Equal("FirstName", typeFirstCriterion.Name);
Assert.Equal(SingleOperator.Equals, typeFirstCriterion.Operator);
Assert.Equal("John", typeFirstCriterion.Value);
Assert.Equal(typeof(CriteriaContainer <object>), nestedCriteria.Criteria.ElementAt(1).GetType());
var typeNestedCriterion2 = nestedCriteria.Criteria.ElementAt(1);
Assert.NotNull(typeNestedCriterion2.SingleCriterion);
var typeSecondCriterion = typeNestedCriterion2.SingleCriterion;
Assert.Equal(LogicalOperator.Or, typeNestedCriterion2.Operator);
Assert.Equal("FirstName", typeSecondCriterion.Name);
Assert.Equal(SingleOperator.Equals, typeSecondCriterion.Operator);
Assert.Equal("Jane", typeSecondCriterion.Value);
}
public void StringTests()
{
// Setup parser
var parser = new FilterParser(new List <FieldDefinition>
{
new FieldDefinition(STRING_FIELD, StringSetup())
});
// Correct string array test with separator contained.
parser.Parse($@"{STRING_FIELD}:in:[""ABCD""]");
Assert.That(parser.IsValid);
Assert.That(parser.Conditions.Count == 1);
Assert.That(parser.Conditions.Any());
Assert.That(parser.Conditions[0].Comparers == Comparer.In);
Assert.That(parser.Conditions[0].ArrayOfStringValues.Count == 1 && parser.Conditions[0].ArrayOfStringValues.First() == "ABCD");
// Correct string array test with two items. Includes single quote inside a double-quote string.
parser.Parse($@"{STRING_FIELD}:in:[""AB'CD"",""BCDE""]");
Assert.That(parser.IsValid);
Assert.That(parser.Conditions.Count == 1);
Assert.That(parser.Conditions.Any());
Assert.That(parser.Conditions[0].Comparers == Comparer.In);
Assert.That(parser.Conditions[0].ArrayOfStringValues.Count == 2 && parser.Conditions[0].ArrayOfStringValues[0] == @"AB'CD" && parser.Conditions[0].ArrayOfStringValues[1] == "BCDE");
// Incorrect string array test.
parser.Parse($@"{STRING_FIELD}:in:1234");
Assert.That(!parser.IsValid);
Assert.That(parser.Conditions.Count == 1);
Assert.That(parser.Conditions.Any());
Assert.That(parser.Conditions[0].Comparers == Comparer.In);
Assert.That(parser.Conditions[0].Errors[0].ErrorType == ErrorType.InvalidValue);
// Incorrect string array test.
parser.Parse($@"{STRING_FIELD}:in:""234""");
Assert.That(!parser.IsValid);
Assert.That(parser.Conditions.Count == 1);
Assert.That(parser.Conditions.Any());
Assert.That(parser.Conditions[0].Comparers == Comparer.In);
Assert.That(parser.Conditions[0].Errors[0].ErrorType == ErrorType.InvalidValue);
// Correct string array test with separator contained.
parser.Parse($@"{STRING_FIELD}:in:[""AB:CD"",""BCDE""]");
Assert.That(parser.IsValid);
Assert.That(parser.Conditions.Count == 1);
Assert.That(parser.Conditions.Any());
Assert.That(parser.Conditions[0].Comparers == Comparer.In);
Assert.That(parser.Conditions[0].ArrayOfStringValues.Count == 2 && parser.Conditions[0].ArrayOfStringValues[0] == "AB:CD" && parser.Conditions[0].ArrayOfStringValues[1] == "BCDE");
// Correct string array test with separator contained.
parser.Parse($@"{STRING_FIELD}:in:[""AB:CD"",""BC;DE""]");
Assert.That(parser.IsValid);
Assert.That(parser.Conditions.Count == 1);
Assert.That(parser.Conditions.Any());
Assert.That(parser.Conditions[0].Comparers == Comparer.In);
Assert.That(parser.Conditions[0].ArrayOfStringValues.Count == 2 && parser.Conditions[0].ArrayOfStringValues[0] == "AB:CD" && parser.Conditions[0].ArrayOfStringValues[1] == "BC;DE");
Assert.That(parser.Conditions[0].ParameterDataType == DataType.ArrayOfStringType);
// Duplicate test.
parser.Parse($@"{STRING_FIELD}:in:[""AB:CD"",""AB:CD""]");
Assert.That(!parser.IsValid);
Assert.That(parser.Conditions.Count == 1);
Assert.That(parser.Conditions.Any());
Assert.That(parser.Conditions[0].Comparers == Comparer.In);
Assert.That(parser.Conditions[0].ArrayOfStringValues.Count == 2 && parser.Conditions[0].ArrayOfStringValues[0] == "AB:CD" && parser.Conditions[0].ArrayOfStringValues[1] == "AB:CD");
Assert.That(parser.Conditions[0].ParameterDataType == DataType.ArrayOfStringType);
Assert.That(parser.Conditions[0].Errors[0].ErrorType == ErrorType.DuplicatesInList);
// Empty list test.
parser.Parse($@"{STRING_FIELD}:in:[]");
Assert.That(!parser.IsValid);
Assert.That(parser.Conditions.Count == 1);
Assert.That(parser.Conditions.Any());
Assert.That(parser.Conditions[0].Comparers == Comparer.In);
Assert.That(parser.Conditions[0].ArrayOfStringValues.Count == 0);
Assert.That(parser.Conditions[0].ParameterDataType == DataType.ArrayOfStringType);
Assert.That(parser.Conditions[0].Errors[0].ErrorType == ErrorType.EmptyList);
// All-operator test.
parser.Parse($@"{STRING_FIELD}:all:[""AB:CD"",""CD:EF""]");
Assert.That(parser.IsValid);
Assert.That(parser.Conditions.Count == 1);
Assert.That(parser.Conditions.Any());
Assert.That(parser.Conditions[0].Comparers == Comparer.All);
Assert.That(parser.Conditions[0].ArrayOfStringValues.Count == 2 && parser.Conditions[0].ArrayOfStringValues[0] == "AB:CD" && parser.Conditions[0].ArrayOfStringValues[1] == "CD:EF");
Assert.That(parser.Conditions[0].ParameterDataType == DataType.ArrayOfStringType);
// All-operator test. Duplicates in list.
parser.Parse($@"{STRING_FIELD}:all:[""AB:CD"",""AB:CD""]");
Assert.That(!parser.IsValid);
Assert.That(parser.Conditions.Count == 1);
Assert.That(parser.Conditions.Any());
Assert.That(parser.Conditions[0].Comparers == Comparer.All);
Assert.That(parser.Conditions[0].ArrayOfStringValues.Count == 2 && parser.Conditions[0].ArrayOfStringValues[0] == "AB:CD" && parser.Conditions[0].ArrayOfStringValues[1] == "AB:CD");
Assert.That(parser.Conditions[0].ParameterDataType == DataType.ArrayOfStringType);
Assert.That(parser.Conditions[0].Errors[0].ErrorType == ErrorType.DuplicatesInList);
}
internal FilterExpression(FilterToken token)
{
Expression = FilterParser.Parse(FilterExpressionTokenizer.Tokenize(token.StringValue));
}
public void PropertyFilterSubExpression_RecursionOnArray_ReturnsCorrectValue()
{
string json = @"
{
`x`: {
`y`: {
`a`: 1,
`b`: 2,
`c`: 3,
`d`: [ true, true ]
}
},
`z`: 123
}
".Replace("`", "\"");
FilterSubExpression exp = FilterParser.Parse(FilterExpressionTokenizer.Tokenize("@.. == @.b"));
exp = (exp as ComparisonFilterSubExpression)?.LeftSide as PropertyFilterSubExpression;
Assert.NotNull(exp);
string expectedJson = @"
[
{
`x`: {
`y`: {
`a`: 1,
`b`: 2,
`c`: 3,
`d`: [
true,
true
]
}
},
`z`: 123
},
{
`y`: {
`a`: 1,
`b`: 2,
`c`: 3,
`d`: [
true,
true
]
}
},
{
`a`: 1,
`b`: 2,
`c`: 3,
`d`: [
true,
true
]
},
[
true,
true
]
]".Replace("`", "\"").RemoveWhiteSpace();
JsonElement result = exp.Execute(JsonDocument.Parse(json).RootElement);
string resultJson = JsonSerializer.Serialize(result);
Assert.Equal(expectedJson, resultJson);
}
/// <summary>
/// Builds the sorter.
/// </summary>
/// <returns>a <see cref="Sorter{T}"/></returns>
private Sorter <byte[]> BuildSorter()
{
Logger.Debug("Building sorter");
var sorter = new Sorter <byte[]>();
var formatterParser = new FormatterParser {
Encoding = Encoding
};
sorter.InputFiles = Input.Select(r => r.GetFileInfo()).ToList();
if (Output.Count == 1)
{
var outputFiles = new List <IOutputFile <byte[]> >();
var outputFile = new LegacyOutputFile {
Output = Output[0].GetFileInfo()
};
if (!string.IsNullOrWhiteSpace(Outrec))
{
outputFile.Formatter = formatterParser.GetFormatter(Outrec);
}
outputFiles.Add(outputFile);
sorter.OutputFiles = outputFiles;
}
if (Output.Count > 1)
{
var outfilParser = new OutfilParser {
Encoding = Encoding, SortEncoding = SortEncoding
};
var outputFiles = outfilParser.GetOutputFiles(Outfils);
if (Output.Count != outputFiles.Count)
{
throw new SortException("The number of output files must match the number of outfil configurations.");
}
for (var i = 0; i < Output.Count; i++)
{
outputFiles[i].Output = Output[i].GetFileInfo();
}
sorter.OutputFiles = outputFiles;
}
if (RecordLength > 0 || Separator == null)
{
sorter.RecordAccessorFactory = new BlockAccessorFactory {
RecordLength = RecordLength
};
}
else
{
sorter.RecordAccessorFactory = new SeparatorAccessorFactory {
Separator = Encoding.GetBytes(Separator)
};
}
if (!string.IsNullOrWhiteSpace(SortCard))
{
var comparerParser = new ComparerParser {
Encoding = Encoding, SortEncoding = SortEncoding
};
sorter.Comparer = comparerParser.GetComparer(SortCard);
}
if (!string.IsNullOrWhiteSpace(Include) || !string.IsNullOrWhiteSpace(Omit))
{
var filterParser = new FilterParser {
Encoding = Encoding, SortEncoding = SortEncoding
};
sorter.Filter = filterParser.GetFilter(Include, Omit);
}
if (SkipDuplicates)
{
sorter.Sum = new SkipSum <byte[]>();
}
if (!string.IsNullOrWhiteSpace(Sum))
{
var sumParser = new SumParser {
Encoding = Encoding
};
sorter.Sum = sumParser.GetSum(Sum);
}
if (!string.IsNullOrWhiteSpace(Inrec))
{
sorter.InputFormatter = formatterParser.GetFormatter(Inrec);
}
if (MaxInMemorySize > 0)
{
sorter.MaxInMemorySize = MaxInMemorySize;
}
sorter.HeaderSize = HeaderSize;
return(sorter);
}
public void Naive() => FilterParser.BuildFromText(Text);
private void saveEntity()
{
string id = context.Request["Id"];
string where = context.Request["filter"];
string entityName = context.Request["entityName"];
int mid = 0;
if (!Int32.TryParse(id, out mid))
{
context.Response.Write("{success:false, errorMessage:'ID geçersiz!'}");
return;
}
// bu istisnai durum, sadece konfigürasyon veritabanına kaydedilmiyor
if (entityName == "Configuration")
{
Provider.Configuration.SetFieldsByPostData(context.Request.Form);
Provider.Configuration.Save();
context.Response.Write("{success:true}");
return;
}
// entitiyi kaydedelim
BaseEntity entity = null;
if (mid > 0)
{
entity = (BaseEntity)Provider.Database.Read(Provider.GetEntityType(entityName), mid);
}
else
{
entity = Provider.CreateEntity(entityName);
}
entity.SetFieldsByPostData(context.Request.Form);
if (!string.IsNullOrEmpty(where))
{
FilterParser filterParser = new FilterParser(where, entityName);
where = filterParser.GetWhere();
foreach (var item in filterParser.GetNameValuePairs())
{
if (string.IsNullOrEmpty(context.Request.Form[item.Key]))
{
entity.SetMemberValue(item.Key, item.Value);
}
}
}
entity.Save();
// entitiye ait Lang kayıtlarını kaydedelim
Type langEntityType = Provider.GetEntityType(entityName + "Lang");
if (langEntityType != null)
{
Dictionary <int, NameValueCollection> langEntities = new Dictionary <int, NameValueCollection>();
Dictionary <int, string> langEntityFieldSum = new Dictionary <int, string>();
for (int i = 0; i < context.Request.Form.Count; i++)
{
string key = context.Request.Form.GetKey(i);
if (key.Contains("_lang_"))
{
string[] parts = key.Split(new string[] { "_lang_" }, StringSplitOptions.None);
int langId = int.Parse(parts[1]);
string fieldName = parts[0];
string fieldVal = context.Request.Form[key];
if (!langEntities.ContainsKey(langId))
{
langEntities.Add(langId, new NameValueCollection());
}
langEntities[langId].Add(fieldName, fieldVal);
if (!langEntityFieldSum.ContainsKey(langId))
{
langEntityFieldSum.Add(langId, "");
}
langEntityFieldSum[langId] += fieldVal;
}
}
// içi boş olan langEntitileri kaldıralım
foreach (var item in langEntityFieldSum)
{
if (item.Value.Trim() == "")
{
langEntities.Remove(item.Key);
}
}
foreach (var item in langEntities)
{
BaseEntity langEntity = (BaseEntity)Provider.Database.Read(langEntityType, entityName + "Id = {0} AND LangId={1}", entity.Id, item.Key);
if (langEntity == null)
{
langEntity = Provider.CreateEntity(langEntityType);
}
langEntity.SetFieldsByPostData(item.Value);
langEntity.SetMemberValue(entityName + "Id", entity.Id);
langEntity.SetMemberValue("LangId", item.Key);
langEntity.Save();
}
}
context.Response.Write("{success:true}");
}
/// <summary>
/// Builds the sorter.
/// </summary>
/// <returns>a <see cref="Sorter{T}"/></returns>
private Sorter <byte[]> BuildSorter()
{
Logger.Debug("Building sorter");
var sorter = new Sorter <byte[]>();
if (RecordLength > 0 || Separator == null)
{
sorter.RecordAccessorFactory = new BlockAccessorFactory {
RecordLength = RecordLength
};
}
else
{
sorter.RecordAccessorFactory = new SeparatorAccessorFactory {
Separator = Encoding.GetBytes(Separator)
};
}
if (!string.IsNullOrWhiteSpace(SortCard))
{
var comparerParser = new ComparerParser {
Encoding = Encoding, SortEncoding = SortEncoding
};
sorter.Comparer = comparerParser.GetComparer(SortCard);
}
if (!string.IsNullOrWhiteSpace(Include) || !string.IsNullOrWhiteSpace(Omit))
{
var filterParser = new FilterParser {
Encoding = Encoding, SortEncoding = SortEncoding
};
sorter.Filter = filterParser.GetFilter(Include, Omit);
}
if (SkipDuplicates)
{
sorter.Sum = new SkipSum <byte[]>();
}
if (!string.IsNullOrWhiteSpace(Sum))
{
var sumParser = new SumParser {
Encoding = Encoding
};
sorter.Sum = sumParser.GetSum(Sum);
}
var formatterParser = new FormatterParser {
Encoding = Encoding
};
if (!string.IsNullOrWhiteSpace(Inrec))
{
sorter.InputFormatter = formatterParser.GetFormatter(Inrec);
}
if (!string.IsNullOrWhiteSpace(Outrec))
{
sorter.OutputFormatter = formatterParser.GetFormatter(Outrec);
}
if (MaxInMemorySize > 0)
{
sorter.MaxInMemorySize = MaxInMemorySize;
}
sorter.HeaderSize = HeaderSize;
return(sorter);
}
/// <summary>
/// Parses a test filter.
/// </summary>
/// <param name="filterExpr">The filter expression.</param>
/// <returns>The parsed filter.</returns>
public static Filter <ITestDescriptor> ParseTestFilter(string filterExpr)
{
FilterParser <ITestDescriptor> parser = new FilterParser <ITestDescriptor>(new TestDescriptorFilterFactory <ITestDescriptor>());
return(parser.ParseFilter(filterExpr));
}
public ExtractableValuesVisitor(FilterParser parser) => _parser = parser;
private IFilterNode Parse(string input)
{
FilterParser parser = new FilterParser(input);
return(parser.Parse());
}
private IFilterNode Parse(string input)
{
FilterParser parser = new FilterParser(input);
return parser.Parse();
}
public void shouldTreatMultipleTermsAsANDFilter()
{
XmlDocument document = new XmlDocument();
XmlElement term1Element = document.CreateElement("FilterTerm");
term1Element.SetAttribute("attribute", "Name");
term1Element.SetAttribute("operator", "=");
term1Element.SetAttribute("value", "Fred");
XmlElement term2Element = document.CreateElement("FilterTerm");
term2Element.SetAttribute("attribute", "Reference");
term2Element.SetAttribute("operator", "=");
term2Element.SetAttribute("value", "Some Text Here");
XmlElement filterElement = document.CreateElement("QueryFilter");
filterElement.AppendChild(term1Element);
filterElement.AppendChild(term2Element);
FilterParser parser = new FilterParser(_metaModel.GetAssetType("Test"));
IFilterTerm term = parser.parse(filterElement);
Assert.IsNotNull(term);
Assert.AreEqual("(Name='Fred';Reference='Some Text Here')", term.Token);
}
private void getGridList()
{
string entityName = context.Request["entityName"];
string where = context.Request["extraFilter"] ?? "";
string orderBy = context.Request["orderBy"] ?? "";
string page = String.IsNullOrEmpty(context.Request["page"]) ? "0" : context.Request["page"];
string limit = String.IsNullOrEmpty(context.Request["limit"]) ? "20" : context.Request["limit"];
int fieldNo = 0;
Type entityType = Provider.GetEntityType(entityName);
BaseEntity sampleEntity = Provider.CreateEntity(entityType);
while (context.Request.Form["f_" + fieldNo] != null)
{
string op = context.Request.Form["o_" + fieldNo];
string field = context.Request.Form["f_" + fieldNo];
string val = context.Request.Form["c_" + fieldNo];
where += (where == "" ? "" : " AND ") + field + op + val;
fieldNo++;
}
if (!string.IsNullOrWhiteSpace(context.Request.Form["search"]))
{
string search = context.Request.Form["search"];
if (!search.Contains("%"))
{
search = "%" + search + "%";
}
where += " AND " + sampleEntity.GetNameColumn() + "like" + search;
}
FilterParser filterParser = new FilterParser(where, entityName);
where = filterParser.GetWhere();
DataTable dt = Provider.ReadList(entityType, Int32.Parse(page), Int32.Parse(limit), orderBy, where, filterParser.GetParams());
context.Response.Write("<table class=\"bk-grid\" border=\"0\" cellspacing=\"0\" cellpadding=\"2\">\n");
if (dt != null)
{
context.Response.Write("\t<tr>\n");
foreach (DataColumn dc in dt.Columns)
{
if (dc.ColumnName == "_CinarRowNumber")
{
continue; //***
}
string columnName = dc.ColumnName;
string columnTitle = Provider.TranslateColumnName(entityName, columnName);
context.Response.Write("\t\t<th id=\"h_" + dc.ColumnName + "\">" + columnTitle + "</th>\n");
}
context.Response.Write("\t</tr>\n");
}
if (dt != null)
{
if (dt.Rows.Count == 0)
{
context.Response.Write("\t<tr><td style=\"padding:30px;text-align:center\" colspan=\"50\">" + Provider.GetResource("No record") + "</td></tr>\n");
}
else
{
for (int i = 0; i < dt.Rows.Count; i++)
{
DataRow dr = dt.Rows[i];
context.Response.Write("\t<tr id=\"r_" + dr[0] + "\">\n");
foreach (DataColumn dc in dt.Columns)
{
if (dc.ColumnName == "_CinarRowNumber")
{
continue; //***
}
object valObj = dr[dc.ColumnName];
string dispVal = "";
if (dr.IsNull(dc))
{
dispVal = "";
}
else if (dc.DataType == typeof(Boolean))
{
dispVal = ((bool)valObj) ? Provider.GetResource("Yes") : Provider.GetResource("No");
}
else if (dc.DataType == typeof(String))
{
string str = Regex.Replace(valObj.ToString(), "<.*?>", string.Empty);
if (str.Length > 50)
{
dispVal = CMSUtility.HtmlEncode(str.StrCrop(50)); // str.Substring(0, 50) + "..."
}
else
{
dispVal = str;
}
}
else if (dc.DataType == typeof(DateTime))
{
dispVal = ((DateTime)valObj).ToString(Provider.Configuration.DefaultDateFormat);
}
else
{
dispVal = valObj.ToString();
}
context.Response.Write("\t\t<td value=\"" + CMSUtility.HtmlEncode(valObj) + "\">" + dispVal + "</td>\n");
}
context.Response.Write("\t</tr>\n");
}
}
}
context.Response.Write("</table>");
}
/// <summary>
/// Parses a test filter set.
/// </summary>
/// <param name="filterExpr">The filter expression.</param>
/// <returns>The parsed filter set.</returns>
public static FilterSet<ITestDescriptor> ParseTestFilterSet(string filterExpr)
{
FilterParser<ITestDescriptor> parser = new FilterParser<ITestDescriptor>(new TestDescriptorFilterFactory<ITestDescriptor>());
return parser.ParseFilterSet(filterExpr);
}
public void TokensWithMethodsComparisonLogicOperatorsAndTruthy_Parse_ReturnsValidExpression()
{
string input = "@.price.count >= 0 && (@.name.first.contains('a') || @['name'].contains(5) || @.f)";
IReadOnlyList <FilterExpressionToken> tokens = FilterExpressionTokenizer.Tokenize(input);
FilterSubExpression expr = FilterParser.Parse(tokens);
Assert.IsType <LogicalFilterSubExpression>(expr);
LogicalFilterSubExpression e1 = expr as LogicalFilterSubExpression;
Assert.True(e1.IsAnd);
Assert.IsType <ComparisonFilterSubExpression>(e1.LeftSide);
// @.price.count >= 0
ComparisonFilterSubExpression comp1 = e1.LeftSide as ComparisonFilterSubExpression;
Assert.True(comp1.IsGreaterOrEqual);
Assert.IsType <PropertyFilterSubExpression>(comp1.LeftSide);
Assert.True(comp1.LeftSide is PropertyFilterSubExpression p1 &&
p1.PropertyChain.Length == 2 &&
p1.PropertyChain.First() == "price" &&
p1.PropertyChain.Last() == "count"
);
Assert.True(comp1.RightSide is NumberConstantFilterSubExpression c1 &&
c1.Value == 0.0
);
// @.name.first.contains('a') || @['name'].contains(5) || @.f
LogicalFilterSubExpression comp2 = (e1.RightSide as GroupFilterSubExpression).Expression as LogicalFilterSubExpression;
Assert.NotNull(comp2);
// @.name.first.contains('a')
Assert.IsType <MethodCallFilterSubExpression>(comp2.LeftSide);
MethodCallFilterSubExpression mc1 = comp2.LeftSide as MethodCallFilterSubExpression;
Assert.Equal("contains", mc1.MethodName);
Assert.True(mc1.Arguments.Count == 1 && (mc1.Arguments.Single() as StringConstantFilterSubExpression).Value == "a");
PropertyFilterSubExpression calledOn1 = mc1.CalledOnExpression as PropertyFilterSubExpression;
Assert.True(calledOn1.PropertyChain.Length == 2 && calledOn1.PropertyChain.First() == "name" && calledOn1.PropertyChain.Last() == "first");
// @['name'].contains(5) || @.f
Assert.IsType <LogicalFilterSubExpression>(comp2.RightSide);
LogicalFilterSubExpression logical3 = comp2.RightSide as LogicalFilterSubExpression;
Assert.True(logical3.IsOr);
// @['name'].contains(5)
Assert.IsType <MethodCallFilterSubExpression>(logical3.LeftSide);
MethodCallFilterSubExpression mc2 = logical3.LeftSide as MethodCallFilterSubExpression;
Assert.Equal("contains", mc2.MethodName);
Assert.Equal(5.0, (mc2.Arguments.Single() as NumberConstantFilterSubExpression).Value);
Assert.Equal("name", (mc2.CalledOnExpression as PropertyFilterSubExpression).PropertyChain.Single());
// || @.f
Assert.IsType <TruthyFilterSubExpression>(logical3.RightSide);
TruthyFilterSubExpression truthy = logical3.RightSide as TruthyFilterSubExpression;
Assert.IsType <PropertyFilterSubExpression>(truthy.Expression);
PropertyFilterSubExpression truthyProp = truthy.Expression as PropertyFilterSubExpression;
Assert.Equal("f", truthyProp.PropertyChain.Single());
}
public void shouldThrowConfigurationExceptionWhenFilterTermElementIsInvalid()
{
XmlDocument document = new XmlDocument();
XmlElement termElement = document.CreateElement("NotWhatWeExpectTerm");
termElement.SetAttribute("attribute", "Name");
termElement.SetAttribute("operator", "=");
termElement.SetAttribute("value", "Fred");
XmlElement filterElement = document.CreateElement("QueryFilter");
filterElement.AppendChild(termElement);
FilterParser parser = new FilterParser(_metaModel.GetAssetType("Test"));
try
{
parser.parse(filterElement);
Assert.Fail("Expected Configuration Exception");
}
catch (ConfigurationException) {}
}
public void Sprache() => FilterParser.BuildFromText(Text);
