public IEnumerable <ValidationMetaData> Validate(
DomainId <IQuestionnaireRootNode> rootNode)
{
var untypedOperators = GetUntypedOperators();
foreach (var untypedOperator in untypedOperators)
{
var leftName = m_domainItemLocator
.Get <IUntypedVariableNode>(untypedOperator.LeftExpression.Id)
.VariableName;
var rightName = m_domainItemLocator
.Get <IUntypedVariableNode>(untypedOperator.RightExpression.Id)
.VariableName;
if (m_variableService.AreCompatible(leftName, rightName))
{
var type = m_variableService.GetQuestionType(leftName);
if (!type.IsValidOperation(untypedOperator))
{
yield return(IncompatableOperationError(untypedOperator, leftName, rightName));
}
continue;
}
yield return(IncompatibleTypeError(leftName, rightName, untypedOperator));
}
}
public bool Evaluate(DomainId <IBooleanLogicNode> predicate)
{
var node = m_domainItemLocator.Get <IBooleanLogicNode>(predicate.Id);
dynamic d = node;
return(this.Evaluate(d));
}
public decimal Calculate(
DomainId <ICalculationNode> calculationNode)
{
var node = m_domainItemLocator.Get <ICalculationNode>(calculationNode.Id);
dynamic d = node;
return(this.Evaluate(d));
}
public static DomainId <T> To <T>(
this DomainId <IAstNode> node,
IDomainItemLocator domainItemLocator) where T : IAstNode
{
var domainItem = domainItemLocator.Get <T>(node.Id);
return(new DomainId <T>(domainItem.Id));
}
private void Visit(IQuestionnaireRootNode node)
{
m_writer.WriteLine($"questionaire: {node.QuestionnaireName}");
foreach (var statementId in node.Statements)
{
var statement = m_domainItemLocator.Get <IStatementNode>(statementId.Id);
VisitSubExpression(statement);
}
}
public IEnumerable <IQuestionNode> Extract(
DomainId <ICalculationNode> calculationNode)
{
m_variableList.Clear();
var node = m_domainItemLocator.Get <ICalculationNode>(calculationNode.Id);
dynamic d = node;
this.Evaluate(d);
return(m_variableList);
}
public void WhenRepeatedQuestionDifferentTypes_ProducesTheCorrectMetaData(
string invalidDescription,
IEnumerable <IQuestionType> expectedSourceTypes,
string errorMessage)
{
CreateAndValidateForm(invalidDescription);
var results = ResultsFor <DuplicateVariableValidationMetaData>();
var actualTypes = results
.Select(x => m_domainItemLocator.Get <IQuestionNode>(x.Source.Id))
.Select(x => x.QuestionType);
AssertThatSeverityLevelIsError(results);
AssertThatErrorMessagesMatch(errorMessage, results);
Assert.IsTrue(
actualTypes.All(q => expectedSourceTypes.Any()),
@"The types of the underlying source objects did not match the expected types");
}
public DomainId <IQuestionOutputItem> CreateQuestionOutputItem(
DomainId <IQuestionNode> variable,
string value,
bool isVisible,
bool isReadonly)
{
var question = m_domainItemLocator
.Get <IQuestionNode>(variable.Id);
var questionOutputItem = new QuestionOutputItem(
m_ids.Next,
variable,
question.QuestionName,
question.QuestionText,
question.QuestionType,
value,
isVisible,
isReadonly);
return(DomainItemRegistration <IQuestionOutputItem>(
questionOutputItem));
}
public T ToDomainItem(IDomainItemLocator domainItemLocator)
{
return(domainItemLocator.Get <T>(Id));
}
private Type GetQuestionType(Guid questionId)
{
return(m_domainItemLocator
.Get <IQuestionNode>(questionId)
?.QuestionType);
}
