public IEnumerable <ValidationMetaData> Validate(
DomainId <IStyleSheetRootNode> rootNode)
{
var styleSheet = m_domainItemLocator
.GetAll <IStyleSheetRootNode>()
.FirstOrDefault();
if (!AllWidgetsValid(styleSheet))
{
yield return new CorrectWidgetValidationMetaData
{
Source = m_domainItemLocator.GetRef <IStyleSheetRootNode>(styleSheet.Id),
Message = $@"The stylesheet '{styleSheet.Name}' has an invalid widget"
}
}
;
var pages = m_domainItemLocator
.GetAll <IPageNode>()
.ToList();
foreach (var page in pages)
{
if (AllWidgetsValid(page))
{
continue;
}
yield return(new CorrectWidgetValidationMetaData
{
Source = m_domainItemLocator.GetRef <IPageNode>(page.Id),
Message = $@"The page '{page.Name}' has an invalid widget"
});
}
var sections = m_domainItemLocator
.GetAll <ISectionNode>()
.ToList();
foreach (var section in sections)
{
if (AllWidgetsValid(section))
{
continue;
}
yield return(new CorrectWidgetValidationMetaData
{
Source = m_domainItemLocator.GetRef <ISectionNode>(section.Id),
Message = $@"The section '{section.Name}' has an invalid widget"
});
}
}
public IEnumerable <ValidationMetaData> Validate(
DomainId <IQuestionnaireRootNode> rootNode)
{
var questionNodes = m_domainItemLocator
.GetAll <IQuestionNode>()
.ToList();
var questionNameAndTypes = questionNodes
.Select(x => new { x.QuestionName, x.QuestionType })
.ToList();
foreach (var questionNode in questionNodes)
{
var mismatchCount = questionNameAndTypes
.Count(x =>
x.QuestionName == questionNode.QuestionName &&
x.QuestionType.GetType() != questionNode.QuestionType.GetType());
if (mismatchCount > 1)
{
var validationData = new DuplicateVariableValidationMetaData
{
Source = m_domainItemLocator.GetRef <IQuestionNode>(questionNode.Id),
Message =
$@"The Question identifier '{
questionNode.QuestionName
}' is used multiple times with different types"
};
yield return(validationData);
}
}
}
public IEnumerable <ValidationMetaData> Validate(
DomainId <IStyleSheetRootNode> rootNode)
{
var qlsQuestionNodes = m_domainItemLocator
.GetAll <IQlsQuestionNode>()
.ToList();
var questionNames = m_domainItemLocator
.GetAll <IQuestionOutputItem>()
.Select(x => x.QuestionName)
.ToList();
foreach (var qlsQuestionNode in qlsQuestionNodes)
{
if (questionNames.Contains(qlsQuestionNode.Name))
{
continue;
}
var validationData = new UnknownQuestionValidationMetaData
{
Source = m_domainItemLocator.GetRef <IQlsQuestionNode>(qlsQuestionNode.Id),
Message = $@"The stylesheet question '{qlsQuestionNode.Name}' is not a valid question"
};
yield return(validationData);
}
}
public IEnumerable <ValidationMetaData> Validate(
DomainId <IQuestionnaireRootNode> rootNode)
{
var variableNodes = m_domainItemLocator
.GetAll <IVariableNode>();
var questionNodes = m_domainItemLocator
.GetAll <IQuestionNode>()
.ToList();
foreach (var variableNode in variableNodes)
{
var nameIsDefined = questionNodes
.Any(x => x.QuestionName == variableNode.VariableName);
if (!nameIsDefined)
{
yield return new UndefinedVariableValidationMetaData
{
Message = $"The variable '{variableNode.VariableName}' has not been defined",
Source = m_domainItemLocator.GetRef <IVariableNode>(variableNode.Id)
}
}
;
}
}
}
public IEnumerable <ValidationMetaData> Validate(
DomainId <IStyleSheetRootNode> rootNode)
{
var qlsQuestionNames = m_domainItemLocator
.GetAll <IQlsQuestionNode>()
.Select(x => x.Name)
.ToList();
var questionNodes = m_domainItemLocator
.GetAll <IQuestionOutputItem>()
.ToList();
foreach (var questionNode in questionNodes)
{
if (qlsQuestionNames.Contains(questionNode.QuestionName))
{
continue;
}
if (TypeHasDefault(questionNode))
{
continue;
}
var validationData = new UncoveredQuestionValidationMetaData
{
Source = m_domainItemLocator.GetRef <IQuestionOutputItem>(questionNode.Id),
Message = $@"The question '{questionNode.QuestionName}' does not have a style"
};
yield return(validationData);
}
}
public IEnumerable <ValidationMetaData> Validate(
DomainId <IQuestionnaireRootNode> rootNode)
{
var questionNodes = m_domainItemLocator
.GetAll <IQuestionNode>()
.ToList();
var duplicateTexts = questionNodes
.GroupBy(x => x.QuestionText)
.Where(g => g.Count() > 1)
.Select(y => y.Key)
.ToList();
foreach (var questionNode in questionNodes)
{
if (duplicateTexts.All(x => x != questionNode.QuestionText))
{
continue;
}
var validationData = new DuplicateTextValidationMetaData
{
Source = m_domainItemLocator.GetRef <IQuestionNode>(questionNode.Id),
Message = $@"The text '{questionNode.QuestionText}' is used multiple times"
};
yield return(validationData);
}
}
private ValidationMetaData IncompatibleTypeError(string leftName, string rightName,
IRelationalLogicNode untypedOperator)
{
var leftType = m_variableService.GetQuestionType(leftName);
var rightType = m_variableService.GetQuestionType(rightName);
var leftTypeText = leftType.GetTypeDisplay();
var rightTypeText = rightType.GetTypeDisplay();
return(new UnkownTypeExpressionValidationMetaData
{
Message =
$@"The expression '{untypedOperator.Definition}' contains the {leftTypeText} variable " +
$@"'{leftName}' and {rightTypeText} variable '{rightName}'. The types {leftTypeText} " +
$@"and {rightTypeText} cannot be compared.",
Source = m_domainItemLocator.GetRef <IRelationalLogicNode>(untypedOperator.Id)
});
}
public IEnumerable <ValidationMetaData> Validate(
DomainId <IQuestionnaireRootNode> rootNode)
{
var questionNodes = m_domainItemLocator
.GetAll <ICalculatedQuestionNode>()
.ToList();
foreach (var questionNode in questionNodes)
{
var noUsedVariables = new List <string>();
if (IsCyclic(noUsedVariables, questionNode))
{
yield return new CyclicDependencyValidationMetaData
{
Message = $"a cirular dependency was found",
Source = m_domainItemLocator.GetRef <IQuestionNode>(questionNode.Id)
}
}
;
}
}
public Reference <IQuestionnaireOutputItem> Visit(
Reference <IQuestionnaireRootNode> questionnaireNode)
{
var node = questionnaireNode
.ToDomainItem(m_domainItemLocator);
var questions = new List <Reference <IQuestionOutputItem> >();
foreach (var statement in node.Statements)
{
if (m_domainItemLocator.Exists <IUserInputQuestionNode>(statement.Id))
{
var domainItem = m_domainItemLocator
.GetRef <IUserInputQuestionNode>(statement.Id);
var questionRef = Visit(domainItem);
questions.Add(questionRef);
}
}
return(m_outputItemFactory.CreateQuestionnaireOutputItem(
node.QuestionnaireName,
questions));
}
protected IEnumerable <ValidationMetaData> Validate <TNode, TData>(
DomainId <IQuestionnaireRootNode> questionnaireRootNode,
Func <IQuestionType, bool> correctTypePredicate,
string comparisonType,
string expectedType)
where TNode : IVariableNode
where TData : ValidationMetaData, new()
{
var booleanVariableNodes = m_domainItemLocator
.GetAll <TNode>();
var questionNodes = m_domainItemLocator
.GetAll <IQuestionNode>()
.ToList();
foreach (var variableNode in booleanVariableNodes)
{
var type = questionNodes
.FirstOrDefault(x => x.QuestionName == variableNode.VariableName)
?.QuestionType;
if (type == null || correctTypePredicate(type))
{
yield return new TData
{
Message =
$@"The variable '{variableNode.VariableName}' is in a {comparisonType} but is not a {
expectedType
}, it is '{type}'",
Source = m_domainItemLocator.GetRef <TNode>(variableNode.Id)
}
}
;
}
}
}
