public override SQ.Entity OnBuildQueryNode(QueryBuilderContext context, bool allowReuse)
{
if (context.Settings.ContextEntity == null)
{
return(null);
}
var contextEntity = context.Settings.ContextEntity;
SQ.Entity result;
if (allowReuse)
{
result = contextEntity;
}
else
{
var proxy = new SQ.JoinToSelfEntity( );
proxy.EntityTypeId = contextEntity.EntityTypeId; // just in case
result = proxy;
}
AddChildNodes(context, result, allowReuse);
return(result);
}
public override SQ.Entity OnBuildQueryNode(QueryBuilderContext context, bool allowReuse)
{
// Find a node
if (ChildContainer.ChildEntityNodes.Count > 1)
{
throw new Exception("Cross-join in report calculations are unsupported.");
}
SQ.Entity reportNode;
if (ChildContainer.ChildEntityNodes.Count == 0)
{
reportNode = new SingleRowNode( );
}
else
{
reportNode = ChildContainer.ChildEntityNodes.Single( ).BuildQueryNode(context, false);
}
// Attach conditions
ScalarExpression condition = Right.BuildQuery(context);
if (reportNode.Conditions == null)
{
reportNode.Conditions = new List <ScalarExpression>();
}
reportNode.Conditions.Add(condition);
return(reportNode);
}
public void Build <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var softDeletesQuery = ctx.GetSourceAs <ISoftDeletesQuery>();
if (softDeletesQuery == null || softDeletesQuery.IncludeSoftDeletes)
{
return;
}
var idsQuery = ctx.GetSourceAs <IIdentityQuery>();
var opt = ctx.GetOptionsAs <IElasticQueryOptions>();
if (opt == null || !opt.SupportsSoftDeletes || (idsQuery != null && idsQuery.Ids.Count > 0))
{
return;
}
var missingFilter = new MissingFilter {
Field = Deleted
};
var termFilter = new TermFilter {
Field = Deleted, Value = softDeletesQuery.IncludeSoftDeletes
};
ctx.Filter &= (new FilterContainer(missingFilter) || new FilterContainer(termFilter));
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var stackIds = ctx.Source.GetStacks();
var excludedStackIds = ctx.Source.GetExcludedStacks();
if (stackIds.Count == 1)
{
ctx.Filter &= Query <T> .Term(_stackIdFieldName, stackIds.Single());
}
else if (stackIds.Count > 1)
{
ctx.Filter &= Query <T> .Terms(d => d.Field(_stackIdFieldName).Terms(stackIds));
}
if (excludedStackIds.Count == 1)
{
ctx.Filter &= Query <T> .Bool(b => b.MustNot(Query <T> .Term(_stackIdFieldName, excludedStackIds.Single())));
}
else if (excludedStackIds.Count > 1)
{
ctx.Filter &= Query <T> .Bool(b => b.MustNot(Query <T> .Terms(d => d.Field(_stackIdFieldName).Terms(excludedStackIds))));
}
return(Task.CompletedTask);
}
/// <summary>
/// Returns a tree node that is representative of an entity or.
/// </summary>
/// <param name="context">Context information about this query building session, including the target structured query object.</param>
/// <param name="allowReuse">A dedicated node should be returned because the caller intends on disturbing it.</param>
/// <returns>A query node that can be used within the query.</returns>
public override SQ.Entity OnBuildQueryNode(QueryBuilderContext context, bool allowReuse)
{
SQ.Entity result = context.ResolveParameterNode(ParameterName);
AddChildNodes(context, result, allowReuse);
return(result);
}
protected void AddChildNodes(QueryBuilderContext context, SQ.Entity parent, bool allowReuse)
{
context.ParentNodeStack.Push(parent);
foreach (var node in ChildContainer.ChildEntityNodes)
{
node.BuildQueryNode(context, allowReuse);
}
context.ParentNodeStack.Pop();
}
protected override ScalarExpression OnBuildQuery(QueryBuilderContext context)
{
var result = new SQ.ResourceExpression
{
NodeId = context.GetNode(this).NodeId,
FieldId = new EntityRef("core:name")
};
return(result);
}
protected override ScalarExpression OnBuildQuery(QueryBuilderContext context)
{
var queryNode = context.GetNode(Argument);
var result = new EDC.ReadiNow.Metadata.Query.Structured.IdExpression
{
NodeId = queryNode.NodeId
};
return(result);
}
/// <summary>
/// Convert the expression tree into a structured query expression.
/// </summary>
/// <param name="context">Context information about this query building session, including the target structured query object.</param>
/// <param name="allowReuse">if set to <c>true</c> [allow reuse].</param>
/// <returns>
/// A query node that can be used within the query.
/// </returns>
public EDC.ReadiNow.Metadata.Query.Structured.Entity BuildQueryNode(QueryBuilderContext context, bool allowReuse)
{
EDC.ReadiNow.Metadata.Query.Structured.Entity result;
if (!context.NodeCache.TryGetValue(this, out result))
{
result = OnBuildQueryNode(context, allowReuse);
context.NodeCache[this] = result;
}
return(result);
}
/// <summary>
/// Convert the expression tree into a structured query expression.
/// </summary>
/// <param name="context">Context information about this query building session, including the target structured query object.</param>
/// <returns>A scalar expression that can be used within the query.</returns>
public ScalarExpression BuildQuery(QueryBuilderContext context)
{
ScalarExpression result = OnBuildQuery(context);
//if (!context.ExpressionCache.TryGetValue(this, out result))
//{
// result = OnBuildQuery(context);
// context.ExpressionCache[this] = result;
//}
return(result);
}
protected override ScalarExpression OnBuildQuery(QueryBuilderContext context)
{
if (ResultType.Type != DataType.String)
{
throw new InvalidOperationException(ResultType.Type.ToString());
}
ScalarExpression argument = Argument.BuildQuery(context);
var result = CastToString(argument);
return(result);
}
protected override void DisposeCore()
{
lock (_lockObject)
{
_connectionDbRepository = null;
_projectsRepository = null;
_projectsShareRepository = null;
_queriesRepository = null;
_usersRepository = null;
}
QueryBuilderContext.Dispose();
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var emailAddress = ctx.Source.GetEmailAddress();
if (String.IsNullOrEmpty(emailAddress))
{
return(Task.CompletedTask);
}
ctx.Filter &= Query <Employee> .Term(f => f.EmailAddress, emailAddress);
return(Task.CompletedTask);
}
protected override ScalarExpression OnBuildQuery(QueryBuilderContext context)
{
var result = new ComparisonExpression
{
Operator = InvertResult ? ComparisonOperator.IsNotNull : ComparisonOperator.IsNull,
Expressions = new List <ScalarExpression>
{
Left.BuildQuery(context)
}
};
return(result);
}
public void Build <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var organizationIdQuery = ctx.GetSourceAs <IOrganizationIdQuery>();
if (organizationIdQuery?.OrganizationIds == null || organizationIdQuery.OrganizationIds.Count <= 0)
{
return;
}
ctx.Filter &= new TermsFilter {
Terms = organizationIdQuery.OrganizationIds, Field = "organization"
};
}
public void Build <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var sfq = ctx.GetSourceAs <IExceptionlessSystemFilterQuery>();
if (sfq == null)
{
return;
}
var allowedOrganizations = sfq.Organizations.Where(o => o.HasPremiumFeatures || (!o.HasPremiumFeatures && !sfq.UsesPremiumFeatures)).ToList();
if (allowedOrganizations.Count == 0)
{
ctx.Filter &= Filter <T> .Term("organization", "none");
return;
}
string field = GetDateField(ctx.GetOptionsAs <IElasticQueryOptions>());
if (sfq.Stack != null)
{
var organization = sfq.Organizations.Single(o => o.Id == sfq.Stack.OrganizationId);
ctx.Filter &= (Filter <T> .Term("stack", sfq.Stack.Id) && GetRetentionFilter <T>(field, organization.RetentionDays));
return;
}
FilterContainer container = null;
if (sfq.Projects?.Count > 0)
{
foreach (var project in sfq.Projects)
{
var organization = sfq.Organizations.Single(o => o.Id == project.OrganizationId);
container |= (Filter <T> .Term("project", project.Id) && GetRetentionFilter <T>(field, organization.RetentionDays));
}
ctx.Filter &= container;
return;
}
if (sfq.Organizations?.Count > 0)
{
foreach (var organization in sfq.Organizations)
{
container |= (Filter <T> .Term("organization", organization.Id) && GetRetentionFilter <T>(field, organization.RetentionDays));
}
ctx.Filter &= container;
}
}
protected override ScalarExpression OnBuildQuery(QueryBuilderContext context)
{
// In SQL, return 'false' for null literals.
if (ResultType.Type == DataType.Bool)
{
TypedValue falseValue = new TypedValue();
falseValue.Type = DatabaseType.BoolType;
falseValue.Value = false;
return(new LiteralExpression {
Value = falseValue
});
}
return(base.OnBuildQuery(context));
}
protected override ScalarExpression OnBuildQuery(QueryBuilderContext context)
{
var result = new CalculationExpression
{
Operator = CalculationOperator.DateName,
DateTimePart = DateTimePart,
Expressions = new List <ScalarExpression>
{
Argument.BuildQuery(context)
}
};
return(result);
}
protected override ScalarExpression OnBuildQuery(QueryBuilderContext context)
{
if (ResultType.IsList)
{
throw new InvalidOperationException();
}
var result = new LiteralExpression
{
Value = TypedValueHelper.FromDataType(ResultType.Type, Value)
};
return(result);
}
/// <summary>
/// Convert the expression tree into a structured query expression.
/// </summary>
/// <param name="context">Context information about this query building session, including the target structured query object.</param>
/// <returns>A scalar expression that can be used within the query.</returns>
protected virtual ScalarExpression OnBuildQuery(QueryBuilderContext context)
{
// Reflect for attributes
Type type = GetType();
var queryEngAttribute = GetQueryEngineOperator(type);
if (queryEngAttribute == null)
{
throw new NotImplementedException(type.Name);
}
// Build arguments
var arguments = new List <ScalarExpression>();
foreach (ExpressionNode argument in Arguments)
{
ScalarExpression queryExpr = argument.BuildQuery(context);
arguments.Add(queryExpr);
}
// Generic Calculation Expression
if (queryEngAttribute.CalculationOperator != null)
{
var result = new CalculationExpression();
result.Operator = queryEngAttribute.CalculationOperator.Value;
result.Expressions = arguments;
return(result);
}
// Generic Comparison Expression
if (queryEngAttribute.ComparisonOperator != null)
{
var result = new ComparisonExpression();
result.Operator = queryEngAttribute.ComparisonOperator.Value;
result.Expressions = arguments;
return(result);
}
// Generic Comparison Expression
if (queryEngAttribute.LogicalOperator != null)
{
var result = new LogicalExpression();
result.Operator = queryEngAttribute.LogicalOperator.Value;
result.Expressions = arguments;
return(result);
}
throw new InvalidOperationException(type.Name);
}
/// <summary>
/// Returns a tree node that is representative of an entity or.
/// </summary>
/// <param name="context">Context information about this query building session, including the target structured query object.</param>
/// <param name="allowReuse">A dedicated node should be returned because the caller intends on disturbing it.</param>
/// <returns>A query node that can be used within the query.</returns>
public override SQ.Entity OnBuildQueryNode(QueryBuilderContext context, bool allowReuse)
{
IEntity instance = Instance.Entity;
long typeId = instance.TypeIds.First( );
if (context.ParentNode == null)
{
throw new Exception("No context.");
}
// Look for an existing relationship node in the tree that we can reuse
SQ.CustomJoinNode result = !allowReuse ? null :
context.ParentNode
.RelatedEntities
.OfType <SQ.CustomJoinNode>( )
.FirstOrDefault(cj => IsMatch(cj, Instance.Id) && cj.EntityTypeId.Id == typeId);
// New node
if (result == null)
{
result = new SQ.CustomJoinNode
{
EntityTypeId = typeId,
JoinPredicateScript = "true"
};
SQ.ScalarExpression predicate = new SQ.ComparisonExpression
{
Operator = SQ.ComparisonOperator.Equal,
Expressions =
{
new SQ.IdExpression
{
NodeId = result.NodeId
},
new SQ.LiteralExpression
{
Value = TypedValueHelper.FromDataType(ResultType.Type, Instance.Id)
}
}
};
result.Conditions = new List <SQ.ScalarExpression> {
predicate
};
}
context.ParentNode.RelatedEntities.Add(result);
AddChildNodes(context, result, allowReuse);
return(result);
}
protected override ScalarExpression OnBuildQuery(QueryBuilderContext context)
{
var aggregateNode = context.GetNode(this);
var result = new EDC.ReadiNow.Metadata.Query.Structured.AggregateExpression
{
NodeId = aggregateNode.NodeId,
AggregateMethod = Method
};
if (Method != AggregateMethod.Count)
{
result.Expression = Argument.BuildQuery(context);
}
return(result);
}
protected override ScalarExpression OnBuildQuery(QueryBuilderContext context)
{
ScalarExpression condition = Arguments[0].BuildQuery(context);
ScalarExpression ifTrue = Arguments[1].BuildQuery(context);
ScalarExpression ifFalse = Arguments[2].BuildQuery(context);
var result = new IfElseExpression
{
BooleanExpression = condition,
IfBlockExpression = ifTrue,
ElseBlockExpression = ifFalse
};
return(result);
}
private IQueryable <Product> ApplyOrdering(QueryBuilderContext ctx, IQueryable <Product> query)
{
var ordered = false;
foreach (var sort in ctx.SearchQuery.Sorting)
{
if (sort.FieldName.IsEmpty())
{
// Sort by relevance.
if (ctx.CategoryId > 0)
{
query = OrderBy(ref ordered, query, x => x.ProductCategories.Where(pc => pc.CategoryId == ctx.CategoryId.Value).FirstOrDefault().DisplayOrder);
}
else if (ctx.ManufacturerId > 0)
{
query = OrderBy(ref ordered, query, x => x.ProductManufacturers.Where(pm => pm.ManufacturerId == ctx.ManufacturerId.Value).FirstOrDefault().DisplayOrder);
}
}
else if (sort.FieldName == "createdon")
{
query = OrderBy(ref ordered, query, x => x.CreatedOnUtc, sort.Descending);
}
else if (sort.FieldName == "name")
{
query = OrderBy(ref ordered, query, x => x.Name, sort.Descending);
}
else if (sort.FieldName == "price")
{
query = OrderBy(ref ordered, query, x => x.Price, sort.Descending);
}
}
if (!ordered)
{
if (FindFilter(ctx.SearchQuery.Filters, "parentid") != null)
{
query = query.OrderBy(x => x.DisplayOrder);
}
else
{
query = query.OrderBy(x => x.Id);
}
}
return(query);
}
protected override ScalarExpression OnBuildQuery(QueryBuilderContext context)
{
var result = new CalculationExpression
{
Operator = CalculationOperator.DateAdd,
DateTimePart = DateTimePart,
InputType = InputType.Type,
Expressions = new List <ScalarExpression>
{
// Caution.. CalculationOperator.DateAdd was implemented backwards
Right.BuildQuery(context),
Left.BuildQuery(context)
}
};
return(result);
}
protected virtual IQueryable <Product> ApplySearchTerm(QueryBuilderContext ctx, IQueryable <Product> query)
{
var term = ctx.SearchQuery.Term;
var fields = ctx.SearchQuery.Fields;
var languageId = ctx.SearchQuery.LanguageId ?? 0;
if (term.HasValue() && fields != null && fields.Length != 0 && fields.Any(x => x.HasValue()))
{
ctx.IsGroupingRequired = true;
var lpQuery = _db.LocalizedProperties.AsNoTracking();
// SearchMode.ExactMatch doesn't make sense here
if (ctx.SearchQuery.Mode == SearchMode.StartsWith)
{
query =
from p in query
join lp in lpQuery on p.Id equals lp.EntityId into plp
from lp in plp.DefaultIfEmpty()
where
(fields.Contains("name") && p.Name.StartsWith(term)) ||
(fields.Contains("sku") && p.Sku.StartsWith(term)) ||
(fields.Contains("shortdescription") && p.ShortDescription.StartsWith(term)) ||
(languageId != 0 && lp.LanguageId == languageId && lp.LocaleKeyGroup == "Product" && lp.LocaleKey == "Name" && lp.LocaleValue.StartsWith(term)) ||
(languageId != 0 && lp.LanguageId == languageId && lp.LocaleKeyGroup == "Product" && lp.LocaleKey == "ShortDescription" && lp.LocaleValue.StartsWith(term))
select p;
}
else
{
query =
from p in query
join lp in lpQuery on p.Id equals lp.EntityId into plp
from lp in plp.DefaultIfEmpty()
where
(fields.Contains("name") && p.Name.Contains(term)) ||
(fields.Contains("sku") && p.Sku.Contains(term)) ||
(fields.Contains("shortdescription") && p.ShortDescription.Contains(term)) ||
(languageId != 0 && lp.LanguageId == languageId && lp.LocaleKeyGroup == "Product" && lp.LocaleKey == "Name" && lp.LocaleValue.Contains(term)) ||
(languageId != 0 && lp.LanguageId == languageId && lp.LocaleKeyGroup == "Product" && lp.LocaleKey == "ShortDescription" && lp.LocaleValue.Contains(term))
select p;
}
}
return(query);
}
public void Build <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var organizationIdQuery = ctx.GetSourceAs <IOrganizationIdQuery>();
if (organizationIdQuery?.OrganizationIds == null || organizationIdQuery.OrganizationIds.Count <= 0)
{
return;
}
if (organizationIdQuery.OrganizationIds.Count == 1)
{
ctx.Filter &= Filter <T> .Term("organization", organizationIdQuery.OrganizationIds.First());
}
else
{
ctx.Filter &= Filter <T> .Terms("organization", organizationIdQuery.OrganizationIds.ToArray());
}
}
public void Build <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var projectIdQuery = ctx.GetSourceAs <IProjectIdQuery>();
if (projectIdQuery?.ProjectIds == null || projectIdQuery.ProjectIds.Count <= 0)
{
return;
}
if (projectIdQuery.ProjectIds.Count == 1)
{
ctx.Filter &= Filter <T> .Term("project", projectIdQuery.ProjectIds.First());
}
else
{
ctx.Filter &= Filter <T> .Terms("project", projectIdQuery.ProjectIds.ToArray());
}
}
public void Build <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var stackIdQuery = ctx.GetSourceAs <IStackIdQuery>();
if (stackIdQuery?.StackIds == null || stackIdQuery.StackIds.Count <= 0)
{
return;
}
if (stackIdQuery.StackIds.Count == 1)
{
ctx.Filter &= Filter <T> .Term("stack", stackIdQuery.StackIds.First());
}
else
{
ctx.Filter &= Filter <T> .Terms("stack", stackIdQuery.StackIds.ToArray());
}
}
/// <summary>
/// Returns a tree node that is representative of an entity or.
/// </summary>
/// <param name="context">Context information about this query building session, including the target structured query object.</param>
/// <param name="allowReuse">A dedicated node should be returned because the caller intends on disturbing it.</param>
/// <returns>A query node that can be used within the query.</returns>
public override SQ.Entity OnBuildQueryNode(QueryBuilderContext context, bool allowReuse)
{
if (context.ParentNode == null)
{
throw new Exception("No context.");
}
// New node
SQ.CustomJoinNode result = new SQ.CustomJoinNode
{
EntityTypeId = EntityTypeId,
JoinPredicateScript = "true"
};
context.ParentNode.RelatedEntities.Add(result);
AddChildNodes(context, result, allowReuse);
return(result);
}
