public void TestContainsFilter()
{
ContainsFilter v1 = new ContainsFilter(ConnectorAttributeBuilder.Build("foo", "bar"));
ContainsFilter v2 = (ContainsFilter)CloneObject(v1);
Assert.AreEqual(v1.GetAttribute(), v2.GetAttribute());
}
// uses contains filter to get cities in florida
private void menuItemContainsFilter_Click(object sender, System.EventArgs e)
{
try
{
Feature fFlorida = _catalog.SearchForFeature("usa", MapInfo.Data.SearchInfoFactory.SearchWhere("State='FL'"));
// build up a search info by hand (not using the factory)
QueryFilter filter = new ContainsFilter(fFlorida.Geometry, ContainsType.Geometry);
QueryDefinition qd = new QueryDefinition(filter, "MI_Geometry", "MI_Style", "MI_Key");
SearchInfo si = new SearchInfo(null, qd);
IResultSetFeatureCollection fc = _catalog.Search("uscty_1k", si);
// set map view to show search results
_map.SetView(fFlorida);
ShowSearchGeometry(fFlorida.Geometry);
// show results as selection
SelectFeatureCollection(fc);
}
finally
{
Cursor.Current = Cursors.Default;
}
}
public void CanDetermineContainsFilter()
{
// arrange
var mocker = new AutoMoqer();
mocker.GetMock <IQueryBuilderFactory>()
.Setup(m => m.Create <JObject>())
.Returns(() => mocker.GetMock <IQueryBuilder <JObject> >().Object);
const string columnName = "someColumnName";
const string filterValue = "someFilterValue";
var expectedFilter = new ContainsFilter(columnName, filterValue);
var addedFilters = new List <IFilter <JObject> >();
mocker.GetMock <IQueryBuilder <JObject> >()
.Setup(m => m.AddFilter(It.IsAny <IFilter <JObject> >()))
.Callback <IFilter <JObject> >(filter => addedFilters.Add(filter));
mocker.GetMock <IQueryBuilder <JObject> >()
.Setup(m => m.Build())
.Returns(() => new Query <JObject>(addedFilters));
var input = new List <KeyValuePair <string, StringValues> >
{
new KeyValuePair <string, StringValues>(columnName, new StringValues(filterValue))
};
var target = mocker.Create <HttpQueryJsonConverter>();
// act
var result = target.Convert(input) as Query <JObject>;
// assert
mocker.Verify <IQueryBuilder <JObject> >(m => m.AddFilter(expectedFilter), Times.Once());
mocker.Verify <IQueryBuilder <JObject> >(m => m.Build(), Times.Once());
Assert.NotEmpty(result.Filters);
Assert.Equal(addedFilters, result.Filters);
}
public void TestNotFilter()
{
ContainsFilter left1 = new ContainsFilter(ConnectorAttributeBuilder.Build("foo", "bar"));
NotFilter v1 = new NotFilter(left1);
NotFilter v2 = (NotFilter)CloneObject(v1);
ContainsFilter left2 = (ContainsFilter)v2.Filter;
Assert.AreEqual(left1.GetAttribute(), left2.GetAttribute());
}
/// <summary>
///
/// </summary>
/// <param name="p"></param>
/// <param name="filter"></param>
/// <returns></returns>
public string VisitContainsFilter(Hashtable p, ContainsFilter filter)
{
var name = filter.GetName();
var name2 = name as String;
if (p.ContainsKey(name))
{
name2 = p[name] as String;
}
return(string.Format("{0} -like \"{1}{2}{3}\"", name2, "*", filter.GetValue(), "*"));
}
public void TestAndFilter()
{
ContainsFilter left1 = new ContainsFilter(ConnectorAttributeBuilder.Build("foo", "bar"));
ContainsFilter right1 = new ContainsFilter(ConnectorAttributeBuilder.Build("foo2", "bar2"));
AndFilter v1 = new AndFilter(left1, right1);
AndFilter v2 = (AndFilter)CloneObject(v1);
ContainsFilter left2 = (ContainsFilter)v2.Left;
ContainsFilter right2 = (ContainsFilter)v2.Right;
Assert.AreEqual(left1.GetAttribute(), left2.GetAttribute());
Assert.AreEqual(right1.GetAttribute(), right2.GetAttribute());
}
protected override String CreateContainsExpression(ContainsFilter filter,
Boolean not)
{
String[] attrNames = GetLdapNamesForAttribute(filter.GetAttribute());
if (attrNames == null)
{
return(null);
}
StringBuilder builder = new StringBuilder();
if (not)
{
builder.Append("(!");
}
if (attrNames.Length == 1)
{
builder.Append('(');
builder.Append(attrNames[0]);
builder.Append("=*");
int len = builder.Length;
GetLdapFilterValue(builder, attrNames[0], filter.GetValue());
// Build (attr=*) rather than (attr=**) for zero-length values.
if (builder.Length != len)
{
builder.Append('*');
}
builder.Append(')');
}
else
{
builder.Append("(|");
foreach (String attrName in attrNames)
{
builder.Append('(');
builder.Append(attrName);
builder.Append("=*");
int len = builder.Length;
GetLdapFilterValue(builder, attrName, filter.GetValue());
// Build (attr=*) rather than (attr=**) for zero-length values.
if (builder.Length != len)
{
builder.Append('*');
}
builder.Append(')');
}
builder.Append(')');
}
if (not)
{
builder.Append(')');
}
return(builder.ToString());
}
public void AlwaysCaseInsensitive()
{
var e = new SystemEvent {
Message = "Start MESSAGE End"
};
var extendedProperties = new FakeExtendedProperties {
{ "property", "Message" }, { "value", "Message" }
};
var filter = new ContainsFilter(extendedProperties, Enumerable.Empty <ICreateFilterExpressions>());
Assert.True(Filter.Compile(filter).Invoke(e));
}
public void CanHaveNullValue()
{
var e = new SystemEvent {
Message = "Start Message End"
};
var extendedProperties = new FakeExtendedProperties {
{ "property", "Message" }, { "value", null }
};
var filter = new ContainsFilter(extendedProperties, Enumerable.Empty <ICreateFilterExpressions>());
Assert.True(Filter.Compile(filter).Invoke(e));
}
public void TestOrFilter()
{
ContainsFilter left1 = new ContainsFilter(ConnectorAttributeBuilder.Build("foo", "bar"));
ContainsFilter right1 = new ContainsFilter(ConnectorAttributeBuilder.Build("foo2", "bar2"));
OrFilter v1 = new OrFilter(left1, right1);
OrFilter v2 = (OrFilter)CloneObject(v1);
ContainsFilter left2 = (ContainsFilter)v2.Left;
ContainsFilter right2 = (ContainsFilter)v2.Right;
Assert.AreEqual(left1.GetAttribute(), left2.GetAttribute());
Assert.AreEqual(right1.GetAttribute(), right2.GetAttribute());
}
public void ReturnFalseIfStringDoesNotContainValue()
{
var e = new SystemEvent {
Message = "Start Message End"
};
var extendedProperties = new FakeExtendedProperties {
{ "property", "Message" }, { "value", "Does Not Contain" }
};
var filter = new ContainsFilter(extendedProperties, Enumerable.Empty <ICreateFilterExpressions>());
Assert.False(Filter.Compile(filter).Invoke(e));
}
private void TestAddFilter(Action <IQuery <JObject>, IFilter <JObject> > assert)
{
// arrange
var target = new QueryBuilder <JObject>();
var filter = new ContainsFilter("someColumn", "someText");
// act
target.AddFilter(filter);
var result = target.Build();
// assert
assert(result, filter);
}
private void UpdatePropertiesPanel(XmlNode selectedItem)
{
if (selectedItem.Name == "input")
{
switch (selectedItem.Attributes["type"].Value)
{
case "MSMQ":
MyGrid = new MSMQIN(selectedItem, this.View);
break;
case "MQ":
MyGrid = new MQIN(selectedItem, this.View);
break;
case "FILE":
MyGrid = new FILEIN(selectedItem, this.View);
break;
case "KAFKA":
MyGrid = new KAFKAIN(selectedItem, this.View);
break;
case "HTTP":
MyGrid = new HTTPIN(selectedItem, this.View);
break;
case "RABBITDEFEX":
MyGrid = new RABBITIN(selectedItem, this.View);
break;
case "MQTT":
MyGrid = new MQTTIN(selectedItem, this.View);
break;
case "TCPSERVER":
MyGrid = new TCPIN(selectedItem, this.View);
break;
case "TESTSOURCE":
MyGrid = new TESTSOURCE(selectedItem, this.View);
break;
}
}
else if (selectedItem.Name == "output" || selectedItem.Name == "altqueue")
{
switch (selectedItem.Attributes["type"].Value)
{
case "MSMQ":
MyGrid = new MSMQOUT(selectedItem, this.View);
break;
case "MQ":
MyGrid = new MQOUT(selectedItem, this.View);
break;
case "FILE":
MyGrid = new FILEOUT(selectedItem, this.View);
break;
case "KAFKA":
MyGrid = new KAFKAOUT(selectedItem, this.View);
break;
case "REST":
MyGrid = new RESTOUT(selectedItem, this.View);
break;
case "HTTP":
MyGrid = new HTTPOUT(selectedItem, this.View);
break;
case "TCPCLIENT":
MyGrid = new TCPOUT(selectedItem, this.View);
break;
case "RABBITDEFEX":
MyGrid = new RABBITOUT(selectedItem, this.View);
break;
case "MQTT":
MyGrid = new MQTTIN(selectedItem, this.View);
break;
case "SMTP":
MyGrid = new SMTPOut(selectedItem, this.View);
break;
case "FTP":
MyGrid = new FTPOut(selectedItem, this.View);
break;
case "SINK":
MyGrid = new SINK(selectedItem, this.View);
break;
}
}
else if (selectedItem.Name == "monitor")
{
MyGrid = new MonitorGrid(selectedItem, this.View);
}
else if (selectedItem.Name == "filter")
{
MyGrid = new Filter(selectedItem, this.View);
}
else if (selectedItem.Name == "pipe")
{
MyGrid = new PIPE(selectedItem, this.View);
}
else if (selectedItem.Name == "namespace")
{
MyGrid = new NameSpaceGrid(selectedItem, this.View);
}
else if (selectedItem.Name == "service")
{
MyGrid = new ServiceSetting(selectedItem, this.View);
}
else if (selectedItem.Name == "and" || selectedItem.Name == "or" || selectedItem.Name == "xor" || selectedItem.Name == "not")
{
MyGrid = new BooleanExpression(selectedItem, this.View);
}
else if (selectedItem.Name == "contains")
{
MyGrid = new ContainsFilter(selectedItem, this.View);
}
else if (selectedItem.Name == "equals")
{
MyGrid = new EqualsFilter(selectedItem, this.View);
}
else if (selectedItem.Name == "matches")
{
MyGrid = new MatchesFilter(selectedItem, this.View);
}
else if (selectedItem.Name == "length")
{
MyGrid = new LengthFilter(selectedItem, this.View);
}
else if (selectedItem.Name == "xpexists")
{
MyGrid = new XPExistsFilter(selectedItem, this.View);
}
else if (selectedItem.Name == "xpmatches")
{
MyGrid = new XPMatchesFilter(selectedItem, this.View);
}
else if (selectedItem.Name == "xpequals")
{
MyGrid = new XPEqualsFilter(selectedItem, this.View);
}
else if (selectedItem.Name == "dateRange")
{
MyGrid = new DateRangeFilter(selectedItem, this.View);
}
else if (selectedItem.Name == "contextContains")
{
MyGrid = new ContextFilter(selectedItem, this.View);
}
OnPropertyChanged("MyGrid");
}
public void TestMultiExtractor()
{
IValueExtractor extractor = new MultiExtractor("field,Property,GetMethod");
IValueExtractor re1 = new ReflectionExtractor("field");
IValueExtractor re2 = new ReflectionExtractor("Property");
IValueExtractor re3 = new ReflectionExtractor("GetMethod");
IValueExtractor[] res = { re1, re2, re3 };
IValueExtractor extractor1 = new MultiExtractor(res);
Assert.IsNotNull(extractor);
Assert.IsNotNull(extractor1);
Assert.AreEqual(extractor, extractor1);
Assert.AreEqual(extractor.ToString(), extractor1.ToString());
Assert.AreEqual(extractor.GetHashCode(), extractor1.GetHashCode());
IValueExtractor[] extractors = (extractor as MultiExtractor).Extractors;
Assert.IsNotNull(extractors);
Assert.AreEqual(extractors.Length, 3);
Assert.AreEqual(extractors[0], re1);
Assert.AreEqual(extractors[1], re2);
Assert.AreEqual(extractors[2], re3);
ReflectionTestType o1 = new ReflectionTestType();
IList list = (IList)extractor.Extract(o1);
Assert.AreEqual(list.Count, extractors.Length);
for (int i = 0; i < extractors.Length; i++)
{
Assert.AreEqual(list[i], extractors[i].Extract(o1));
}
Assert.IsNull(extractor.Extract(null));
ReflectionTestType o2 = new ReflectionTestType();
TestQueryCacheEntry entry1 = new TestQueryCacheEntry("key1", o1);
TestQueryCacheEntry entry2 = new TestQueryCacheEntry("key2", o2);
Assert.AreEqual((extractor as MultiExtractor).CompareEntries(entry1, entry2), 0);
o2.field = 100;
Assert.AreEqual((extractor as MultiExtractor).CompareEntries(entry1, entry2), -1);
// testing on remote cache
INamedCache cache = CacheFactory.GetCache(CacheName);
cache.Clear();
Address a1 = new Address("street1", "city1", "state1", "zip1");
Address a2 = new Address("treet2", "city2", "tate2", "zip2");
Address a3 = new Address("street3", "city3", "state3", "zip3");
Hashtable ht = new Hashtable();
ht.Add("multiExtractorKey1", a1);
ht.Add("multiExtractorKey2", a2);
ht.Add("multiExtractorKey3", a3);
cache.InsertAll(ht);
extractor1 = new ReflectionExtractor("getStreet");
IValueExtractor extractor2 = new ReflectionExtractor("getState");
extractor = new MultiExtractor(new IValueExtractor[] { extractor1, extractor2 });
IFilter filter = new ContainsFilter(extractor, "street1");
ICollection keys = cache.GetKeys(filter);
Assert.AreEqual(keys.Count, 1);
Assert.Contains("multiExtractorKey1", (IList)keys);
CacheFactory.Shutdown();
}
protected override String CreateContainsExpression(ContainsFilter filter, bool not)
{
String rv = "( CONTAINS " + filter.GetName() + " " + filter.GetValue() + " )";
return(Not(rv, not));
}
public void TestNotFilter()
{
ContainsFilter left1 = new ContainsFilter(ConnectorAttributeBuilder.Build("foo", "bar"));
NotFilter v1 = new NotFilter(left1);
NotFilter v2 = (NotFilter)CloneObject(v1);
ContainsFilter left2 = (ContainsFilter)v2.Filter;
Assert.AreEqual(left1.GetAttribute(), left2.GetAttribute());
}
public IQueryable <SimpleEntity> Filter(IQueryable <SimpleEntity> items, ContainsFilter parameter)
{
AddLog("QF"); // Using queryable filter ...
return(items.Where(i => i.Name.Contains(parameter.Pattern)));
}
public void TestContainsFilter()
{
ContainsFilter v1 = new ContainsFilter(ConnectorAttributeBuilder.Build("foo", "bar"));
ContainsFilter v2 = (ContainsFilter)CloneObject(v1);
Assert.AreEqual(v1.GetAttribute(), v2.GetAttribute());
}
protected override Filter CreateContainsExpression(ContainsFilter filter, bool not)
{
return(not ? FilterBuilder.Not(filter) : filter);
}
public Dictionary <string, object> VisitContainsFilter(Hashtable p, ContainsFilter filter)
{
return(CreateMap("CONTAINS", filter.GetName(), filter.GetValue()));
}
protected override IDictionary <String, Object> CreateContainsExpression(ContainsFilter filter, Boolean not)
{
return(CreateFilter("CONTAINS", filter, not));
}
// uses contains filter to get cities in florida
private void menuItemContainsFilter_Click(object sender, System.EventArgs e)
{
try
{
Feature fFlorida = _catalog.SearchForFeature("usa", MapInfo.Data.SearchInfoFactory.SearchWhere("State='FL'"));
// build up a search info by hand (not using the factory)
QueryFilter filter = new ContainsFilter(fFlorida.Geometry, ContainsType.Geometry);
QueryDefinition qd = new QueryDefinition(filter, "MI_Geometry", "MI_Style", "MI_Key");
SearchInfo si = new SearchInfo(null, qd);
IResultSetFeatureCollection fc = _catalog.Search("uscty_1k", si);
// set map view to show search results
_map.SetView(fFlorida);
ShowSearchGeometry(fFlorida.Geometry);
// show results as selection
SelectFeatureCollection(fc);
}
finally
{
Cursor.Current = Cursors.Default;
}
}
public void NotCompositeExpression()
{
var filter = new ContainsFilter(new FakeExtendedProperties(), Enumerable.Empty <ICreateFilterExpressions>());
Assert.False(filter.CompositeExpression);
}
IContentExpression ParseExpression(Queue <DslToken> q, Func <DslToken, bool> terminate)
{
IContentExpression exp = null;
while (q.Count > 0)
{
var lookAhead = q.Peek();
if (terminate(lookAhead))
{
break;
}
else if (lookAhead.IsConstant())
{
if (exp != null)
{
throw new ParserException($"Unexpected token", lookAhead);
}
var token = q.DequeueAndValidate(Utils.ConstantTokens);
exp = CreateConstant(token);
}
else if (lookAhead.TokenType == TokenType.Equals)
{
if (exp == null)
{
throw new ParserException($"Unexpected token", lookAhead);
}
var token = q.DequeueAndValidate(TokenType.Equals);
exp = new EqualToFilter(exp,
ParseExpression(q, t => t.TokenType == TokenType.And || t.TokenType == TokenType.Or || terminate(t)));
}
else if (lookAhead.TokenType == TokenType.Contains)
{
if (exp == null)
{
throw new ParserException($"Unexpected token", lookAhead);
}
var token = q.DequeueAndValidate(TokenType.Contains);
exp = new ContainsFilter(exp,
ParseExpression(q, t => t.TokenType == TokenType.And || t.TokenType == TokenType.Or || terminate(t)));
}
else if (lookAhead.TokenType == TokenType.MatchRegex)
{
if (exp == null)
{
throw new ParserException($"Unexpected token", lookAhead);
}
var token = q.DequeueAndValidate(TokenType.MatchRegex);
var pattern = q.DequeueAndValidate(TokenType.String);
exp = new RegexFilter(exp, pattern.Value);
}
else if (lookAhead.TokenType == TokenType.And)
{
if (exp == null)
{
throw new ParserException($"Unexpected token", lookAhead);
}
var token = q.DequeueAndValidate(TokenType.And);
if (exp is IContentFilter leftBool)
{
var right = ParseExpression(q, terminate);
if (right is IContentFilter rightBool)
{
exp = new AndFilter(leftBool, rightBool);
}
else
{
throw new ParserException("AND cannot have a right operand that does not yield boolean", token);
}
}
else
{
throw new ParserException("AND cannot have a left operand that does not yield boolean", token);
}
}
else if (lookAhead.TokenType == TokenType.Or)
{
if (exp == null)
{
throw new ParserException($"Unexpected token", lookAhead);
}
var token = q.DequeueAndValidate(TokenType.Or);
if (exp is IContentFilter leftBool)
{
var right = ParseExpression(q, terminate);
if (right is IContentFilter rightBool)
{
exp = new OrFilter(leftBool, rightBool);
}
else
{
throw new ParserException("OR cannot have a right operand that does not yield boolean", token);
}
}
else
{
throw new ParserException("OR cannot have a left operand that does not yield boolean", token);
}
}
else if (lookAhead.TokenType == TokenType.Path)
{
if (exp == null)
{
throw new ParserException($"Unexpected token", lookAhead);
}
var token = q.DequeueAndValidate(TokenType.Path);
exp = new PathExpression(exp, ContentPath.Parse($"$.{token.Value.TrimStart('.')}"));
}
else if (lookAhead.TokenType == TokenType.DollarSign)
{
if (exp != null)
{
throw new ParserException($"Unexpected token", lookAhead);
}
q.DequeueAndValidate(TokenType.DollarSign);
exp = new ScopeRootExpression();
}
else if (lookAhead.TokenType == TokenType.OpenCurly)
{
if (exp != null)
{
throw new ParserException($"Unexpected token", lookAhead);
}
exp = CreateObjectExpression(q);
}
else if (lookAhead.TokenType == TokenType.OpenSquareBracket)
{
if (exp != null)
{
throw new ParserException($"Unexpected token", lookAhead);
}
exp = CreateListExpression(q);
}
else if (lookAhead.TokenType == TokenType.OpenBracket)
{
if (exp != null)
{
throw new ParserException($"Unexpected token", lookAhead);
}
q.DequeueAndValidate(TokenType.OpenBracket); // open bracket (
exp = ParseExpression(q, t => t.TokenType == TokenType.CloseBracket);
q.DequeueAndValidate(TokenType.CloseBracket); // close bracket )
}
else
{
throw new ParserException($"Unexpected token", lookAhead);
}
}
if (exp == null)
{
throw new ParserException($"Unexpected end", null);
}
return(exp);
}
public string VisitContainsFilter(Hashtable p, ContainsFilter filter)
{
throw new NotImplementedException();
}
