public void StaticDependency_Relationships(string script, string expectedReferences)
{
var settings = CreateBuilderSettings("AA_Manager");
IExpressionCompiler compiler = Factory.ExpressionCompiler;
IExpression expr = compiler.Compile(script, settings);
CalculationDependencies dependencies = compiler.GetCalculationDependencies(expr);
var expected = expectedReferences
.Split(',', StringSplitOptions.RemoveEmptyEntries)
.Select(alias => new EntityRef(alias).Id)
.ToList();
Assert.That(dependencies.Relationships, Is.EquivalentTo(expected));
}
/// <summary>
/// Creates the evaluator for a single calculated field.
/// </summary>
/// <param name="calculatedField">Entity for the calculated field.</param>
/// <param name="settings">Settings.</param>
/// <returns></returns>
private CalculatedFieldMetadata GetSingleCalculatedFieldMetadata(Field calculatedField, CalculatedFieldSettings settings)
{
string calculation = null;
IExpression expression = null;
ParseException exception = null;
BuilderSettings builderSettings;
try
{
// Get calculation
calculation = calculatedField.FieldCalculation;
if (string.IsNullOrEmpty(calculation))
{
throw new ArgumentException("The field has no calculation script. It may not be a calculated field.");
}
// Get settings
builderSettings = CreateBuilderSettingsForField(calculatedField, settings);
// Compile
expression = _expressionCompiler.Compile(calculation, builderSettings);
// Register cache invalidations
if (CacheContext.IsSet())
{
CalculationDependencies dependencies = _expressionCompiler.GetCalculationDependencies(expression);
using (CacheContext cacheContext = CacheContext.GetContext())
{
cacheContext.Entities.Add(calculatedField.Id);
cacheContext.Entities.Add(dependencies.IdentifiedEntities);
cacheContext.Entities.Add(builderSettings.RootContextType.EntityTypeId);
}
}
}
catch (InvalidMemberParseException ex)
{
exception = ex;
// If a parse-exception resulted from being unable to look up a member name, then it may be corrected by renaming some arbitrary field or relationship
// that could not be otherwise detected by dependencies.IdentifiedEntities. So invalidate parse exceptions if any field/relationship changes.
if (CacheContext.IsSet())
{
using (CacheContext cacheContext = CacheContext.GetContext())
{
cacheContext.Entities.Add(ex.TypeId);
// TODO: ideally just listen for all fields/relationships attached to type
var fieldTypes = PerTenantEntityTypeCache.Instance.GetDescendantsAndSelf(new EntityRef("core:field").Id);
cacheContext.EntityTypes.Add(fieldTypes);
cacheContext.EntityTypes.Add(new EntityRef("core:relationship").Id);
}
}
}
catch (ParseException ex)
{
exception = ex;
}
// Build metadata
CalculatedFieldMetadata metadata = new CalculatedFieldMetadata(calculatedField.Id, calculation, expression, exception);
return(metadata);
}
