protected override void Test(IOrganizationService service)
{
var qryExpression = new QueryExpressionBuilder <Account>()
.Build();
Assert.AreEqual(null, qryExpression.TopCount);
}
protected override void Test(IOrganizationService service)
{
var qryExpression = new QueryExpressionBuilder <Account>()
.With.DatabaseLock(false)
.With.RecordLimit(10)
.Select(cols => new { cols.AccountNumber, cols.Name })
.LeftJoin <Contact>("primarycontactid", "contactid", c => c
.InnerJoin <SystemUser>("ownerid", "systemuserid", u => u
.With.Alias("owner")
.Select(cols => new { cols.SystemUserId })))
.Build();
var parsed = qryExpression.ToReadableText();
var linkEntity = qryExpression.LinkEntities[0];
linkEntity = linkEntity.LinkEntities[0];
Assert.AreEqual(JoinOperator.Inner, linkEntity.JoinOperator);
Assert.AreEqual("contact", linkEntity.LinkFromEntityName);
Assert.AreEqual("systemuser", linkEntity.LinkToEntityName);
Assert.AreEqual("ownerid", linkEntity.LinkFromAttributeName);
Assert.AreEqual("systemuserid", linkEntity.LinkToAttributeName);
Assert.AreEqual("owner", linkEntity.EntityAlias);
}
protected override void Execute(IPluginExecutionContext context, IOrganizationService orgService)
{
var target = GetTargetEntityReference(context);
var relatedEntityId = GetFirstRelatedEntityId(context);
var relationship = GetRelationship(context);
if (target?.Id != null && relatedEntityId != null && relationship != null)
{
var query = QueryExpressionBuilder.GetSelfRelationsQuery(new GetSelfRelationsQueryParameter()
{
RelationName = relationship.SchemaName,
EntityName = target.LogicalName,
RecordOneId = relatedEntityId.Value,
RecordTwoId = target.Id
});
var queryResults = orgService.RetrieveMultiple(query).Entities.ToList();
if (queryResults.Count == 0)
{
var relatedEntities = new EntityReferenceCollection
{
new EntityReference(target.LogicalName, target.Id)
};
var mirroredRelationship = new Relationship(relationship.SchemaName);
mirroredRelationship.PrimaryEntityRole = EntityRole.Referencing;
orgService.Associate(target.LogicalName, relatedEntityId.Value, mirroredRelationship, relatedEntities);
}
}
}
public void TestWriteLookupWhereAnd()
{
var query = QueryExpressionBuilder.BuildQuery <Patient>(o => o.Names.Where(p => p.NameUse.Mnemonic == "Legal").Any(p => p.Component.Any(n => n.Value == "Smith")));
var expression = CreateQueryString(query.ToArray());
Assert.AreEqual("name[Legal].component.value=Smith", expression);
}
public void TestWriteLookupApproximately()
{
var query = QueryExpressionBuilder.BuildQuery <Patient>(o => o.GenderConcept.Mnemonic.Contains("M"));
var expression = CreateQueryString(query.ToArray());
Assert.AreEqual("genderConcept.mnemonic=~M", expression);
}
public void TestWriteLookupAny()
{
var query = QueryExpressionBuilder.BuildQuery <Patient>(o => o.Names.Any(p => p.NameUse.Mnemonic == "Legal"));
var expression = CreateQueryString(query.ToArray());
Assert.AreEqual("name.use.mnemonic=Legal", expression);
}
protected override void Test(IOrganizationService service)
{
var qryExpression = new QueryExpressionBuilder <Account>()
.Build();
Assert.AreEqual(false, qryExpression.NoLock);
}
public void TestWriteLookupNotEqual()
{
var query = QueryExpressionBuilder.BuildQuery <Patient>(o => o.GenderConcept.Mnemonic != "Male");
var expression = CreateQueryString(query.ToArray());
Assert.AreEqual("genderConcept.mnemonic=%21Male", expression);
}
public void Optimize(IQuery q, object predicate, MethodBase filterMethod)
{
// TODO: cache predicate expressions here
var builder = new QueryExpressionBuilder();
var expression = builder.FromMethod(filterMethod);
new SODAQueryBuilder().OptimizeQuery(expression, q, predicate, _classFactory, new CecilReferenceResolver());
}
public void TestWriteNonSerializedProperty()
{
var query = QueryExpressionBuilder.BuildQuery <Patient>(o => o.Extensions.Any(e => e.ExtensionDisplay == "1"));
var expression = CreateQueryString(query.ToArray());
Assert.AreEqual("extension.display=1", expression);
}
protected override void Test(IOrganizationService service)
{
var qryExpression = new QueryExpressionBuilder <Account>()
.Select("*")
.Build();
Assert.AreEqual(true, qryExpression.ColumnSet.AllColumns);
}
public void TestWriteSimpleExtendedFilter()
{
QueryFilterExtensions.AddExtendedFilter(new SimpleQueryExtension());
var query = QueryExpressionBuilder.BuildQuery <Patient>(o => o.Identifiers.Any(i => i.Value.TestExpression() <= 2));
var expression = CreateQueryString(query.ToArray());
Assert.AreEqual("identifier.value=%3A%28test%29%3C%3D2", expression);
}
public static IEnumerable <T> Select <T>(this IRequest request, Action <IQueryExpressionBuilder> query) where T : class
{
var builder = new QueryExpressionBuilder();
query(builder);
return(request.Select <T>(builder.Build()));
}
public void TestWriteGuardByUuid()
{
Guid id = Guid.Empty;
var query = QueryExpressionBuilder.BuildQuery <Patient>(o => o.Relationships.Where(g => g.RelationshipTypeKey == EntityRelationshipTypeKeys.Mother).Any(r => r.TargetEntity.StatusConcept.Mnemonic == "ACTIVE"));
var expression = CreateQueryString(query.ToArray());
Assert.AreEqual("relationship[29ff64e5-b564-411a-92c7-6818c02a9e48].target.statusConcept.mnemonic=ACTIVE", expression);
}
public static void CreateView(this IQuery query, ObjectName viewName, IEnumerable <string> columnNames, Action <IQueryExpressionBuilder> queryExpression)
{
var builder = new QueryExpressionBuilder();
queryExpression(builder);
query.CreateView(viewName, columnNames, builder.Build());
}
public static ISelectStatementBuilder Query(this ISelectStatementBuilder builder, Action <IQueryExpressionBuilder> query)
{
var queryBuilder = new QueryExpressionBuilder();
query(queryBuilder);
return(builder.Query(queryBuilder.Build()));
}
public void TestWriteLookupByKey()
{
Guid id = Guid.Empty;
var query = QueryExpressionBuilder.BuildQuery <Patient>(o => o.Key == id);
var expression = CreateQueryString(query.ToArray());
Assert.AreEqual("id=00000000-0000-0000-0000-000000000000", expression);
}
public void TestWriteLookupLessThan()
{
DateTime dt = DateTime.MinValue;
var query = QueryExpressionBuilder.BuildQuery <Patient>(o => o.DateOfBirth < dt);
var expression = CreateQueryString(query.ToArray());
Assert.AreEqual("dateOfBirth=%3C0001-01-01T00%3A00%3A00.0000000", expression);
}
public void TestWriteLookupAnd()
{
Guid id = Guid.Empty;
var query = QueryExpressionBuilder.BuildQuery <Patient>(o => o.Key == id && o.GenderConcept.Mnemonic == "Male");
var expression = CreateQueryString(query.ToArray());
Assert.AreEqual("id=00000000-0000-0000-0000-000000000000&genderConcept.mnemonic=Male", expression);
}
public void TestChainedWriter()
{
Guid id = Guid.Empty;
var query = QueryExpressionBuilder.BuildQuery <Place>(o => o.ClassConcept.Mnemonic == "GenderCode" && o.StatusConcept.Mnemonic == "ACTIVE");
var expression = CreateQueryString(query.ToArray());
Assert.AreEqual("classConcept.mnemonic=GenderCode&statusConcept.mnemonic=ACTIVE", expression);
}
public void TestChainedWriter2()
{
Guid id = Guid.Empty;
var query = QueryExpressionBuilder.BuildQuery <Concept>(o => o.ConceptSets.Any(p => p.Mnemonic == "GenderCode"));
var expression = CreateQueryString(query.ToArray());
Assert.AreEqual("conceptSet.mnemonic=GenderCode", expression);
}
protected override void Test(IOrganizationService service)
{
var qryExpression = new QueryExpressionBuilder <Account>()
.Select("accountnumber", "name")
.Build();
Assert.AreEqual(false, qryExpression.ColumnSet.AllColumns);
Assert.AreEqual(2, qryExpression.ColumnSet.Columns.Count);
}
/// <summary>
/// Interceptor for querying
/// </summary>
private void AdtPatientPassthroughInterceptor_Querying(object sender, QueryRequestEventArgs <Patient> e)
{
e.Cancel = true;
var parmMap = s_map.Map.FirstOrDefault(o => o.Trigger == "Q22");
var nvc = QueryExpressionBuilder.BuildQuery(e.Query);
e.Results = this.SendQuery(new NameValueCollection(nvc.ToArray()), e.Count ?? 25, out int tr);
e.TotalResults = tr;
}
public void TestWriteSelfParameterRef()
{
QueryFilterExtensions.AddExtendedFilter(new SimpleQueryExtensionEx());
DateTime other = DateTime.Parse("1980-01-01");
TimeSpan myTime = new TimeSpan(1, 0, 0, 0);
var query = QueryExpressionBuilder.BuildQuery <Patient>(o => o.DateOfBirth.Value.TestExpressionEx(o.CreationTime.DateTime) < myTime);
var expression = CreateQueryString(query.ToArray());
Assert.AreEqual("dateOfBirth=%3A%28testEx%7C%22%24_.creationTime%22%29%3C1.00%3A00%3A00", expression);
}
protected override void Test(IOrganizationService service)
{
service = new OrganizationServiceBuilder(service)
.Build();
var plugin = new Sample.FieldEncryptionPlugin(null, null);
plugin.Container.Implement <ICache>().Using <Fakes.FakeCacheProvider>().WithOverwrite();
plugin.Container.Implement <ISecretProviderFactory>().Using <Fakes.FakeSecretProviderFactory <Fakes.FakeSecretProvider> >().WithOverwrite();
var testQry = new QueryExpressionBuilder <Contact>()
.Select("department")
.WhereAll(e => e
.IsActive()
.WhereAll(e1 => e1
.Attribute("fullname").Is(ConditionOperator.Like, "# " + TestData.DecryptedValue + "%")))
.Build();
var executionContext = new PluginExecutionContextBuilder()
.WithRegisteredEvent(20, "RetrieveMultiple", Contact.EntityLogicalName)
.WithInputParameter("Query", testQry)
.Build();
var serviceProvider = new ServiceProviderBuilder(
service,
executionContext,
new DebugLogger()).Build();
plugin.Execute(serviceProvider);
var context = (IPluginExecutionContext)serviceProvider.GetService(typeof(IPluginExecutionContext));
// get query and verify that it is modified as expected.
var outQuery = context.InputParameters["Query"] as QueryExpression;
var criteria = outQuery.Criteria;
Assert.AreEqual(LogicalOperator.Or, criteria.FilterOperator);
Assert.AreEqual(0, criteria.Conditions.Count);
Assert.AreEqual(1, criteria.Filters.Count);
// check sub filter
criteria = criteria.Filters[0];
Assert.AreEqual(LogicalOperator.And, criteria.FilterOperator);
Assert.AreEqual(2, criteria.Conditions.Count);
Assert.AreEqual(0, criteria.Filters.Count);
Assert.AreEqual("department", criteria.Conditions[0].AttributeName);
Assert.AreEqual(TestData.EncryptedValue, criteria.Conditions[0].Values[0]);
Assert.AreEqual("statecode", criteria.Conditions[1].AttributeName);
Assert.AreEqual(0, criteria.Conditions[1].Values[0]);
}
public void TestAgeFilterEx()
{
QueryFilterExtensions.AddExtendedFilter(new AgeQueryFilterExtension());
var filterQuery = NameValueCollection.ParseQueryString("dateOfBirth=:(age|2020-01-01)<P3Y");
var expr = QueryExpressionParser.BuildLinqExpression <Patient>(filterQuery);
Assert.IsTrue(expr.ToString().Contains("Age"));
// Parse it back
var nvc = QueryExpressionBuilder.BuildQuery(expr);
}
public void TestNonSerializedParse()
{
String expected = "o => o.Extensions.Any(extension => extension.ExtensionDisplay == \"1\")";
NameValueCollection httpQueryParameters = new NameValueCollection();
httpQueryParameters.Add("extension.display", "1");
var expr = QueryExpressionParser.BuildLinqExpression <Patient>(httpQueryParameters);
var pexpr = new NameValueCollection(QueryExpressionBuilder.BuildQuery <Patient>(expr, true).ToArray());
Assert.AreEqual(httpQueryParameters.ToString(), pexpr.ToString());
}
public void TestOrGuardParse()
{
String expected = "o => o.Names.Where(guard => (guard.NameUse.Mnemonic == \"L\")).Any(name => name.Component.Where(guard => (guard.ComponentType == null)).Any(component => (component.Value == \"John\")))";
NameValueCollection httpQueryParameters = new NameValueCollection();
httpQueryParameters.Add("name[Legal|OfficialRecord].component[Given|Family].value", "John");
var expr = QueryExpressionParser.BuildLinqExpression <Patient>(httpQueryParameters);
var pexpr = new NameValueCollection(QueryExpressionBuilder.BuildQuery <Patient>(expr, true).ToArray());
Assert.AreEqual(httpQueryParameters.ToString(), pexpr.ToString());
}
protected override void Test(IOrganizationService service)
{
var qryExpression = new QueryExpressionBuilder <Account>()
.Select(a => new { a.Id, a.Name, a.AccountNumber })
.Build();
Assert.AreEqual(false, qryExpression.ColumnSet.AllColumns);
Assert.AreEqual(3, qryExpression.ColumnSet.Columns.Count);
Assert.IsTrue(qryExpression.ColumnSet.Columns.Contains("accountid"));
Assert.IsTrue(qryExpression.ColumnSet.Columns.Contains("name"));
Assert.IsTrue(qryExpression.ColumnSet.Columns.Contains("accountnumber"));
}
public void TestCrossAssemblyActivateCallIsIgnored()
{
const string helperAssemblyCode = @"
using Db4objects.Db4o.TA;
using Db4objects.Db4o.Activation;
public class ActivatorUtil
{
public static void ActivateForRead(IActivatable item)
{
item.Activate(ActivationPurpose.Read);
}
}" ;
const string assemblyCode = @"
using Db4objects.Db4o.TA;
using Db4objects.Db4o.Activation;
public class ActivatableItem : IActivatable
{
public void Bind(IActivator activator) {}
public void Activate(ActivationPurpose purpose) {}
public string name;
}
public class Predicates
{
public bool ByName(ActivatableItem item)
{
ActivatorUtil.ActivateForRead(item);
return item.name.StartsWith(""foo"");
}
}" ;
CompilationServices.EmitAssembly(AssemblyPathFor("ActivatorHelper.dll"), new[] { Db4oAssemblyPath() },
helperAssemblyCode);
var crossNQAssemblyPath = AssemblyPathFor("CrossNQ.dll");
CompilationServices.EmitAssembly(crossNQAssemblyPath,
new[] { Db4oAssemblyPath(), AssemblyPathFor("ActivatorHelper.dll") }, assemblyCode);
var assembly = Assembly.LoadFrom(crossNQAssemblyPath);
var type = assembly.GetType("Predicates");
var expression =
new QueryExpressionBuilder().FromMethod(type.GetMethod("ByName",
BindingFlags.Instance | BindingFlags.InvokeMethod | BindingFlags.Public));
AssertSimpleComparisionAgainstConstant(expression, "foo");
}
protected override void Test(IOrganizationService service)
{
var qryExpression = new QueryExpressionBuilder <Account>()
.WhereAny(a => a
.IsActive()
.Attribute("accountnumber").IsEqualTo("test"))
.Build();
var criteria = qryExpression.Criteria;
Assert.AreEqual(LogicalOperator.Or, criteria.FilterOperator);
Assert.AreEqual(2, criteria.Conditions.Count);
}
public void TestCrossAssemblyActivateCallIsIgnored()
{
const string helperAssemblyCode = @"
using Db4objects.Db4o.TA;
using Db4objects.Db4o.Activation;
public class ActivatorUtil
{
public static void ActivateForRead(IActivatable item)
{
item.Activate(ActivationPurpose.Read);
}
}";
const string assemblyCode = @"
using Db4objects.Db4o.TA;
using Db4objects.Db4o.Activation;
public class ActivatableItem : IActivatable
{
public void Bind(IActivator activator) {}
public void Activate(ActivationPurpose purpose) {}
public string name;
}
public class Predicates
{
public bool ByName(ActivatableItem item)
{
ActivatorUtil.ActivateForRead(item);
return item.name.StartsWith(""foo"");
}
}";
CompilationServices.EmitAssembly(AssemblyPathFor("ActivatorHelper.dll"), new[] {Db4oAssemblyPath()},
helperAssemblyCode);
var crossNQAssemblyPath = AssemblyPathFor("CrossNQ.dll");
CompilationServices.EmitAssembly(crossNQAssemblyPath,
new[] {Db4oAssemblyPath(), AssemblyPathFor("ActivatorHelper.dll")}, assemblyCode);
var assembly = Assembly.LoadFrom(crossNQAssemblyPath);
var type = assembly.GetType("Predicates");
var expression =
new QueryExpressionBuilder().FromMethod(type.GetMethod("ByName",
BindingFlags.Instance | BindingFlags.InvokeMethod | BindingFlags.Public));
AssertSimpleComparisionAgainstConstant(expression, "foo");
}
