public async Task <(bool isValid, IDictionary <string, string> errors)> ValidateQuestionPage(FormType formType, string formKey, InFlightPage inFlightPage)
{
var form = await _formRepository.GetForm(formKey);
var node = form.Nodes.FindByKey(new Key(inFlightPage.NodeId));
var questions = node.Value switch
{
TaskQuestionPageFormNode questionPageFormNode => ((TaskQuestionPage)_staticFormProvider.GetPage(
formType, StaticKey.ForTaskQuestionPage(questionPageFormNode.TaskId, questionPageFormNode.PageId))).Questions,
PostTaskFormNode postTaskFormNode => ((ConsentPage)_staticFormProvider.GetPage(
formType, StaticKey.ForPostTaskPage(postTaskFormNode.TaskId))).Questions,
_ => throw new UnexpectedNodeTypeException <TaskQuestionPageFormNode, PostTaskFormNode>(node.Value)
};
var errors = new Dictionary <string, string>();
foreach (var question in questions)
{
var answer = inFlightPage.Questions[questions.IndexOf(question)];
var result = question.Validator?.Validate(answer);
if (result is null || result.IsValid)
{
continue;
}
errors.Add(question.Id, result.Errors.First().ErrorMessage);
}
return(isValid : !errors.Any(), errors : errors);
}
public Task <PhysicalResponse> Handle(FormType formType, string formKey, GraphNode <Key, FormNode> node)
{
var summaryFormNode = node.AssertType <TaskSummaryFormNode>();
var postTaskNode = node.Neighbors.FindByKey(Key.ForPostTaskPage(summaryFormNode.TaskId));
var taskList = postTaskNode.Neighbors.FindByKey(Key.ForTaskList());
var taskRouter = taskList.Neighbors.FindByKey(Key.ForDecisionTaskRouter(summaryFormNode.TaskId)).AssertType <TaskRouterFormNode>();
var taskItemRouter = node.Neighbors.First(GraphNodePredicates.IsTaskItemRouterNode);
var taskItemIds = taskRouter.TaskItemIds.OrderBy(x => x).ToList();
var taskItemRouterValue = taskItemRouter.AssertType <TaskItemRouterFormNode>();
var repeatIndex = taskItemIds.IndexOf(taskItemRouterValue.RepeatIndex);
var staticSummaryPage = _staticFormProvider.GetPage(formType, StaticKey.ForTaskSummary(summaryFormNode.TaskId)) as SummaryPage;
var task = _staticFormProvider.GetTask(formType, StaticKey.ForTaskNode(summaryFormNode.TaskId));
var taskItemGroup = _summaryService.GetTaskItemSummary(taskItemRouter, task);
var flattenedTaskGroupings = taskItemGroup.FlattenTaskGroupings();
return(Task.FromResult(new TaskSummaryResponse
{
Page = staticSummaryPage,
NextNodeId = postTaskNode.Key.Value,
TaskGroupings = flattenedTaskGroupings,
} as PhysicalResponse));
}
public Task <PhysicalResponse> Handle(FormType formType, string formKey, GraphNode <Key, FormNode> node)
{
var postTaskFormNode = node.AssertType <PostTaskFormNode>();
var taskListNode = node.Neighbors.First(GraphNodePredicates.IsAnyTaskListNode);
var taskSummaryNodes = node.Neighbors.Where(GraphNodePredicates.IsAnyTaskSummaryNode);
var taskItemNodes = taskSummaryNodes.Select(x => x.Neighbors.First(GraphNodePredicates.IsTaskItemRouterNode));
var taskRouterKey = Key.ForDecisionTaskRouter(postTaskFormNode.TaskId);
var postTaskPage = _staticFormProvider.GetPage(formType, StaticKey.ForPostTaskPage(postTaskFormNode.TaskId)) as PostTaskPage;
return(Task.FromResult(postTaskPage switch
{
ConsentPage consentPage => new ConsentPageResponse
{
Page = consentPage,
NextNodeId = null,
} as PhysicalResponse,
RepeatTaskPage repeatTaskPage => new RepeatTaskResponse
{
Page = repeatTaskPage,
NextNodeId = taskListNode.Key.Value,
TaskItemSummaryNodeIds = taskSummaryNodes.Select(x => x.Key.Value),
TaskItemNodeIds = taskItemNodes.Select(x => x.Key.Value),
TaskId = postTaskFormNode.TaskId,
TaskRouterNodeId = taskRouterKey.Value
},
_ => throw new NotImplementedException()
}));
public Task <PhysicalResponse> Handle(FormType formType, string formKey, GraphNode <Key, FormNode> node)
{
var preTaskFromNode = node.AssertType <PreTaskFormNode>();
var preTaskPage = _staticFormProvider.GetPage(formType, StaticKey.ForPreTaskPage(preTaskFromNode.TaskId)) as PreTaskPage;
var taskItemNode = node.Neighbors.First(GraphNodePredicates.IsTaskItemRouterNode);
return(Task.FromResult(new PreTaskResponse
{
NextNodeId = taskItemNode.Key.Value,
PreTaskPage = preTaskPage
} as PhysicalResponse));
}
public async Task Handle(FormType formType, string formKey, string nodeId)
{
var form = await _formRepository.GetForm(formKey);
var taskQuestionPageNode = form.Nodes.FindByKey(new Key(nodeId));
var taskQuestionPage = (TaskQuestionPageFormNode)taskQuestionPageNode.Value;
var staticPage = (TaskQuestionPage)_staticFormProvider.GetPage(formType, StaticKey.ForTaskQuestionPage(taskQuestionPage.TaskId, taskQuestionPage.PageId));
if (staticPage.Effects.Any())
{
foreach (var effect in staticPage.Effects)
{
await _effectHandlers.First(x => x.EffectTypes == effect.EffectTypes).Handle(effect, form, taskQuestionPageNode);
}
}
await _formRepository.SaveForm(formKey, form);
}
public async Task <PhysicalResponse> Handle(FormType formType, string formKey, GraphNode <Key, FormNode> node)
{
var questionPageFormNode = node.AssertType <TaskQuestionPageFormNode>();
var answersDictionary = questionPageFormNode.Questions.ToDictionary(x => x.Id, x => x.Answer);
var questionPage = (TaskQuestionPage)_staticFormProvider.GetPage(formType, StaticKey.ForTaskQuestionPage(questionPageFormNode.TaskId, questionPageFormNode.PageId));
var(questionNumber, totalQuestions) = await _formService.GetQuestionNumber(formKey, node.Key.Value);
return(new TaskPageResponse
{
NodeId = node.Key.Value,
TaskQuestionPage = questionPage,
Answers = answersDictionary,
QuestionCount = totalQuestions,
QuestionNumber = questionNumber
});
}
public Task <PhysicalResponse> Handle(FormType formType, string formKey, GraphNode <Key, FormNode> node)
{
var postSubTaskFormNode = node.AssertType <PostSubTaskFormNode>();
var itemRouter = node.Neighbors.First(GraphNodePredicates.IsSubTaskRouterNode);
var postTaskPage = _staticFormProvider.GetPage(formType,
StaticKey.ForPostSubTaskPage(postSubTaskFormNode.TaskId, postSubTaskFormNode.SubTaskId)) as
RepeatTaskPage;
var taskItemNodeIds = node.Neighbors.Where(GraphNodePredicates.IsSubTaskItemRouterNode).Select(x => x.Key.Value);
// Next node can be any node except for the a SubTaskItem or the SubTaskRouter of the current SubTask
var nextNode = node.Neighbors.First(x => !x.IsSubTaskItemRouterNode() && !(x.IsSubTaskRouterNode(out var str) && str.SubTaskId == postSubTaskFormNode.SubTaskId));
return(Task.FromResult(new RepeatSubTaskResponse
{
NextNodeId = nextNode.Key.Value,
Page = postTaskPage,
TaskItemNodeIds = taskItemNodeIds,
SubTaskRouterNodeId = itemRouter.Key.Value
} as PhysicalResponse));
}
