private static Criteria GetCriteriaObject(IClassDef classDef, string criteriaString)
{
var criteria = CriteriaParser.CreateCriteria(criteriaString);
QueryBuilder.PrepareCriteria(classDef, criteria);
return(criteria);
}
public void TestFind_UsingGuidCriteriaString_Typed()
{
//---------------Set up test pack-------------------
BORegistry.DataAccessor = new DataAccessorInMemory(new DataStoreInMemory());
ClassDef.ClassDefs.Clear();
ContactPersonTestBO.LoadDefaultClassDef_WOrganisationID();
OrganisationTestBO.LoadDefaultClassDef();
ContactPersonTestBO cp = new ContactPersonTestBO {
Surname = Guid.NewGuid().ToString("N")
};
cp.OrganisationID = OrganisationTestBO.CreateSavedOrganisation().OrganisationID;
cp.Save();
DataStoreInMemory dataStore = new DataStoreInMemory();
dataStore.Add(cp);
Criteria criteria = CriteriaParser.CreateCriteria("OrganisationID = " + cp.OrganisationID);
//---------------Assert Precondtions---------------
Assert.IsNotNull(cp.OrganisationID);
//---------------Execute Test ----------------------
ContactPersonTestBO loadedCP = dataStore.Find <ContactPersonTestBO>(criteria);
//---------------Test Result -----------------------
Assert.IsNotNull(loadedCP);
Assert.AreSame(cp.ID, loadedCP.ID);
}
static void Main(string[] args)
{
var filePath = args[0];
//TODO: Resolve dependencies with some IOC container
IStudentService service = new StudentService(new StudentRepository(), new ParseDataService());
ICriteriaParser <Student> parser = new CriteriaParser();
service.InitializeData(filePath);
var criteria = new Dictionary <string, string>();
for (var i = 1; i < args.Length; i++)
{
var data = args[i].Split('=');
criteria.Add(data[0], data[1]);
}
Func <Student, bool> parsedCriteria = parser.ParseCriteria(criteria);
var output = service.GetFiltered(parsedCriteria).ToList();
var sb = new StringBuilder();
output.ForEach(x =>
sb.Append(
String.Format("{0} {1} {2} {3}", x.Type.ToString(), x.Name, x.Gender.ToString(), x.LastModified.ToString())
));
Console.Write(sb.ToString());
}
private void TestParse1()
{
string TEXT = @"k1:v1";
var succeed = CriteriaParser.TryParse(TEXT.AsSpan(), out var result);
AssertResult(result, "k1", "v1");
TEXT = @"k1.k2:v1";
succeed = CriteriaParser.TryParse(TEXT.AsSpan(), out result);
AssertResult(result, "k1.k2", "v1");
TEXT = @" k1: v1 +";
succeed = CriteriaParser.TryParse(TEXT.AsSpan(), out result);
AssertResult(result, "k1", "v1");
TEXT = @" k1 : v 1 + ";
succeed = CriteriaParser.TryParse(TEXT.AsSpan(), out result);
AssertResult(result, "k1", "v 1");
TEXT = @" k1 : v: 1 + ";
succeed = CriteriaParser.TryParse(TEXT.AsSpan(), out result);
AssertResult(result, "k1", "v: 1");
TEXT = @" k1 : v:\+ 1 + ";
succeed = CriteriaParser.TryParse(TEXT.AsSpan(), out result);
AssertResult(result, "k1", "v:+ 1");
public void PopulateCollectionAsync <T>(string criteria, string order = null, Action afterPopulation = null) where T : class, IBusinessObject, new()
{
this.RunAsyncOperationStartedHandler();
this.PopulateCollectionAsync <T>(CriteriaParser.CreateCriteria(criteria), OrderCriteria.FromString(order));
this.RunAsyncOperationCompleteHandler();
if (afterPopulation != null)
{
afterPopulation();
}
}
public void TestCreateLogicalOperator_Or_UnTrimmed()
{
//---------------Set up test pack-------------------
const string operatorString = " or ";
//---------------Execute Test ----------------------
Criteria.LogicalOp op = CriteriaParser.CreateLogicalOperator(operatorString);
//---------------Test Result -----------------------
Assert.AreEqual(Criteria.LogicalOp.Or, op);
}
public void TestCreateLogicalOperator_VariedCase()
{
//---------------Set up test pack-------------------
const string operatorString = "AnD";
//---------------Execute Test ----------------------
Criteria.LogicalOp op = CriteriaParser.CreateLogicalOperator(operatorString);
//---------------Test Result -----------------------
Assert.AreEqual(Criteria.LogicalOp.And, op);
}
public void TestCreateOperator_LessThanEqual()
{
//---------------Set up test pack-------------------
const string operatorString = "<=";
//---------------Execute Test ----------------------
Criteria.ComparisonOp comparisonOp = CriteriaParser.CreateComparisonOperator(operatorString);
//---------------Test Result -----------------------
Assert.AreEqual(Criteria.ComparisonOp.LessThanEqual, comparisonOp);
}
public void Test_CreateCriteria_Simple_PropNameDiff()
{
//---------------Set up test pack-------------------
const string propName = "OtherPropName";
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
Criteria criteria = CriteriaParser.CreateCriteria(propName + " = surnameValue");
string criteriaAsString = criteria.ToString();
StringAssert.AreEqualIgnoringCase(propName + " = 'surnameValue'", criteriaAsString);
}
public void Test_CreateCriteria_TwoParts_WithOr()
{
//---------------Set up test pack-------------------
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
Criteria criteria = CriteriaParser.CreateCriteria("FirstName = firstNameValue or Surname = surnameValue");
string criteriaAsString = criteria.ToString();
//---------------Test Result -----------------------
StringAssert.AreEqualIgnoringCase("(FirstName = 'firstNameValue') OR (Surname = 'surnameValue')", criteriaAsString);
}
public void Test_CreateCriteria_ThreeParts_WithBrackets()
{
//---------------Set up test pack-------------------
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
Criteria criteria = CriteriaParser.CreateCriteria("(FirstName = firstNameValue and MiddleName = middleNameValue) and Surname = surnameValue");
string criteriaAsString = criteria.ToString();
//---------------Test Result -----------------------
StringAssert.AreEqualIgnoringCase("((FirstName = 'firstNameValue') AND (MiddleName = 'middleNameValue')) AND (Surname = 'surnameValue')", criteriaAsString);
}
public void Test_CreateCriteria_Simple()
{
//---------------Set up test pack-------------------
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
Criteria criteria = CriteriaParser.CreateCriteria("Surname = surnameValue");
string criteriaAsString = criteria.ToString();
//---------------Test Result -----------------------
StringAssert.AreEqualIgnoringCase("Surname = 'surnameValue'", criteriaAsString);
}
private BOSequenceNumberLocking LoadSequenceNumber(string numberType)
{
var searchCriteria = string.Format("NumberType = '{0}'", numberType);
var criteria = CriteriaParser.CreateCriteria(searchCriteria);
var sequenceBOSequenceNumber =
BORegistry.DataAccessor.BusinessObjectLoader.GetBusinessObject <BOSequenceNumberLocking>(criteria);
if (sequenceBOSequenceNumber == null)
{
sequenceBOSequenceNumber = CreateSequenceForType(numberType);
}
return(sequenceBOSequenceNumber);
}
public void Test_CreateCriteria_Simple_WithIn_MultipleValues_QuoteInsideValue()
{
//---------------Set up test pack-------------------
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
Criteria criteria = CriteriaParser.CreateCriteria("Surname in ('Bob, \' Bob2', 'Name2', 'Name3')");
string criteriaAsString = criteria.ToString();
//---------------Test Result -----------------------
Assert.AreEqual(Criteria.ComparisonOp.In, criteria.ComparisonOperator);
StringAssert.AreEqualIgnoringCase("Surname in ('Bob, \' Bob2', 'Name2', 'Name3')", criteriaAsString);
}
public void Test_CreateCriteria_Simple_WithIsNot()
{
//---------------Set up test pack-------------------
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
Criteria criteria = CriteriaParser.CreateCriteria("Surname Is Not Null");
string criteriaAsString = criteria.ToString();
//---------------Test Result -----------------------
Assert.AreEqual(Criteria.ComparisonOp.IsNot, criteria.ComparisonOperator);
StringAssert.AreEqualIgnoringCase("Surname IS NOT NULL", criteriaAsString);
}
/// <summary>
/// Validates if a string is a valid DevExpress Criteria, that can be used with rules or other filter controls
/// </summary>
/// <param name="filterString">The string that will be tested as a valid criteria</param>
/// <param name="IgnoreNullOrEmpty">Indicates if null or empty strings are ignored (default is false)</param>
/// <returns>True or false depending if the string is valid</returns>
public static bool ValidateStringAsFilterCriteria(string filterString, bool IgnoreNullOrEmpty = false)
{
if (string.IsNullOrEmpty(filterString) && !IgnoreNullOrEmpty)
{
return(false);
}
CriteriaParser.Parse(filterString, out OperandValue[] opps);
if (opps.Any(o => o.Value == null))
{
return(false);
}
return(true);
}
public void Test_CreateCriteria_FourParts_WithBrackets_MultipleOperators()
{
//---------------Set up test pack-------------------
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
Criteria criteria = CriteriaParser.CreateCriteria("(FirstName < firstNameValue and MiddleName >= middleNameValue) " +
"or (Surname > surnameValue and Nickname <> nicknameValue)");
string criteriaAsString = criteria.ToString();
//---------------Test Result -----------------------
StringAssert.AreEqualIgnoringCase("((FirstName < 'firstNameValue') AND (MiddleName >= 'middleNameValue')) " +
"OR ((Surname > 'surnameValue') AND (Nickname <> 'nicknameValue'))", criteriaAsString);
}
public void Test_CreateCriteria_FourParts()
{
//---------------Set up test pack-------------------
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
Criteria criteria = CriteriaParser.CreateCriteria("FirstName = firstNameValue and MiddleName = middleNameValue " +
"and Surname = surnameValue and Nickname = nicknameValue");
string criteriaAsString = criteria.ToString();
//---------------Test Result -----------------------
StringAssert.AreEqualIgnoringCase("(FirstName = 'firstNameValue') AND ((MiddleName = 'middleNameValue') " +
"AND ((Surname = 'surnameValue') AND (Nickname = 'nicknameValue')))", criteriaAsString);
}
public void Test_CreateCriteria_Simple_WithNotIn()
{
//---------------Set up test pack-------------------
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
Criteria criteria = CriteriaParser.CreateCriteria("Surname not in ('Bob')");
string criteriaAsString = criteria.ToString();
//---------------Test Result -----------------------
Assert.AreEqual(Criteria.ComparisonOp.NotIn, criteria.ComparisonOperator);
StringAssert.AreEqualIgnoringCase("Surname NOT IN ('Bob')", criteriaAsString);
}
public void Test_CreateCriteria_Simple_WithGreaterThanEqual()
{
//---------------Set up test pack-------------------
string surnameValue = Guid.NewGuid().ToString("N");
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
Criteria criteria = CriteriaParser.CreateCriteria("Surname >= " + surnameValue + "");
string criteriaAsString = criteria.ToString();
//---------------Test Result -----------------------
Assert.AreEqual(Criteria.ComparisonOp.GreaterThanEqual, criteria.ComparisonOperator);
StringAssert.AreEqualIgnoringCase("Surname >= '" + surnameValue + "'", criteriaAsString);
}
public void SpeakerIsHappyIsTrue()
{
var parser = new CriteriaParser();
var s = new Character(null, null)
{
Mood = Mood.Happy
};
var st = new Character(null, null)
{
Mood = Mood.Sad
};
var result = parser.IsValid(s, st, "Speaker.Mood.Happy");
Assert.IsTrue(result);
}
public void SpokenToIsAngryIsFalse()
{
var parser = new CriteriaParser();
var s = new Character(null, null)
{
Mood = Mood.Happy
};
var st = new Character(null, null)
{
Mood = Mood.Melancholy
};
var result = parser.IsValid(s, st, "SpokenTo.Mood.Angry");
Assert.IsFalse(result);
}
public void TestParse()
{
var succeed = CriteriaParser.TryParse(" \t", out var result);
Assert.False(succeed);
Assert.Null(result);
succeed = CriteriaParser.TryParse("checked", out result);
Assert.True(succeed);
Assert.Single(result);
Assert.Equal("checked", result[0].Key);
Assert.Null(result[0].Value);
this.TestParse1();
this.TestParse2();
}
public void Test_CreateCriteria_Invalid()
{
//---------------Set up test pack-------------------
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
try
{
CriteriaParser.CreateCriteria("surnameValue");
Assert.Fail("expected Err");
}
//---------------Test Result -----------------------
catch (HabaneroDeveloperException ex)
{
StringAssert.Contains("The criteria string surnameValue is not a valid criteria string", ex.DeveloperMessage);
}
//---------------Test Result -----------------------
}
public void Test_CreateCriteria_Simple_WithInvalid()
{
//---------------Set up test pack-------------------
string surnameValue = Guid.NewGuid().ToString("N");
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
try
{
CriteriaParser.CreateCriteria("Surname INALID " + surnameValue + "");
Assert.Fail("expected Err");
}
//---------------Test Result -----------------------
catch (HabaneroDeveloperException ex)
{
StringAssert.Contains("is not a valid criteria string", ex.DeveloperMessage);
}
}
public void Test_InvalidOperatorString()
{
//---------------Set up test pack-------------------
const string operatorString = "INVALID";
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
try
{
CriteriaParser.CreateComparisonOperator(operatorString);
Assert.Fail("Should fail and throw an error.");
}
catch (HabaneroDeveloperException ex)
{
StringAssert.Contains("Invalid operator ", ex.DeveloperMessage);
StringAssert.Contains(operatorString, ex.DeveloperMessage);
}
//---------------Test Result -----------------------
}
public void PopulateCollectionAsync <T>(string criteria, string order, Action afterPopulation = null) where T : class, IBusinessObject, new()
{
this.PopulateCollectionAsync <T>(CriteriaParser.CreateCriteria(criteria), OrderCriteria.FromString(order), afterPopulation);
}
/// <summary>
/// Loads a business object of the type identified by a <see cref="ClassDef"/>, using the criteria given
/// </summary>
/// <param name="classDef">The ClassDef of the object to load.</param>
/// <param name="criteriaString">The criteria to use to load the business object must be of formst "PropName = criteriaValue" e.g. "Surname = Powell"</param>
/// <returns>The business object that was found. If none was found, null is returned. If more than one is found an error is raised</returns>
public IBusinessObject GetBusinessObject(IClassDef classDef, string criteriaString)
{
Criteria criteriaObject = CriteriaParser.CreateCriteria(criteriaString);
return(GetBusinessObjectShared(classDef, criteriaObject));
}
public void Populate <T>(string criteria) where T : class, IBusinessObject, new()
{
this.Populate <T>(CriteriaParser.CreateCriteria(criteria));
}
public void PopulateObjectAsync <T>(string criteria, Action afterPopulation = null) where T : class, IBusinessObject, new()
{
this.PopulateObjectAsync <T>(CriteriaParser.CreateCriteria(criteria), afterPopulation);
}
