Example #1
0
        private void AddTask(Graph <Key, FormNode> graph, GraphNode <Key, FormNode> taskListNode, Models.Static.Task task, int repeatIndex)
        {
            if (!taskListNode.IsAnyTaskListNode())
            {
                throw new UnexpectedNodeTypeException <TaskListFormNode, TaskListGhost>(taskListNode.Value);
            }

            var taskRouterNode = new GraphNode <Key, FormNode>(Key.ForDecisionTaskRouter(task.Id), new TaskRouterFormNode(task.Id));

            var preTaskNode = task.PreTaskPage is null
                ? new GraphNode <Key, FormNode>(Key.ForPreTaskPage(task.Id), new PreTaskGhost())
                : new GraphNode <Key, FormNode>(Key.ForPreTaskPage(task.Id), new PreTaskFormNode(task.Id));

            var postTaskNode = task.PostTaskPage is null
                ? new GraphNode <Key, FormNode>(Key.ForPostTaskPage(task.Id), new PostTaskGhost())
                : new GraphNode <Key, FormNode>(Key.ForPostTaskPage(task.Id), new PostTaskFormNode(task.Id));

            graph.AddNode(taskRouterNode);
            graph.AddNode(preTaskNode);
            graph.AddNode(postTaskNode);

            var allTaskNodes = AddTaskItem(graph, taskRouterNode, preTaskNode, postTaskNode, task, repeatIndex);

            foreach (var(_, (node, nextKey)) in allTaskNodes)
            {
                if (nextKey is null)
                {
                    continue;
                }
                if (nextKey.Value == Key.EmptyKey().Value)
                {
                    continue;
                }
                var(nextNode, _) = allTaskNodes[nextKey];
                graph.AddDirectedEdge(node, nextNode);
            }

            // Add the Task edges
            graph.AddDirectedEdge(taskListNode, taskRouterNode);
            graph.AddDirectedEdge(taskRouterNode, preTaskNode);
            graph.AddDirectedEdge(taskRouterNode, postTaskNode, EdgeCosts.TaskToPostTaskCost);
            graph.AddDirectedEdge(postTaskNode, taskListNode);
        }
Example #2
0
        private Dictionary <Key, (GraphNode <Key, FormNode>, Key)> AddTaskItem(Graph <Key, FormNode> graph, GraphNode <Key, FormNode> taskRouterNode,
                                                                               GraphNode <Key, FormNode> preTaskNode, GraphNode <Key, FormNode> postTaskNode, Models.Static.Task task,
                                                                               int repeatIndex)
        {
            taskRouterNode.AssertType <TaskRouterFormNode>();

            var nodes = new Dictionary <Key, (GraphNode <Key, FormNode>, Key)>();

            var taskItemRouter = new GraphNode <Key, FormNode>(Key.ForDecisionTaskItemRouter(task.Id, repeatIndex), new TaskItemRouterFormNode(task.Id, repeatIndex));
            var summaryNode    = task.SummaryPage is null
                ? new GraphNode <Key, FormNode>(Key.ForTaskSummary(task.Id, repeatIndex), new TaskSummaryGhost())
                : new GraphNode <Key, FormNode>(Key.ForTaskSummary(task.Id, repeatIndex), new TaskSummaryFormNode(task.Id));

            graph.AddNode(summaryNode);
            graph.AddNode(taskItemRouter);
            graph.AddDirectedEdge(taskRouterNode, taskItemRouter);
            graph.AddDirectedEdge(summaryNode, taskItemRouter);

            foreach (var taskItem in task.TaskItems)
            {
                if (taskItem is TaskQuestionPage || taskItem is TaskQuestionGhost)
                {
                    var(newNode, nextKey) = AddTaskQuestion(graph, task.Id, taskItem, new[] { repeatIndex });
                    nodes.Add(newNode.Key, (newNode, nextKey));
                    if (nextKey is null)
                    {
                        if (nodes.Remove(newNode.Key))
                        {
                            nodes.Add(newNode.Key, (newNode, Key.EmptyKey()));
                        }
                        graph.AddDirectedEdge(newNode, summaryNode);
                    }
                }

                if (taskItem is SubTask subTask)
                {
                    var newNodes = AddSubTask(graph, task.Id, subTask, new[] { repeatIndex });
                    nodes.AddRange(newNodes);
                    foreach (var(_, (newNode, newNodeNextKey)) in newNodes)
                    {
                        if (newNodeNextKey is null)
                        {
                            if (nodes.Remove(newNode.Key))
                            {
                                nodes.Add(newNode.Key, (newNode, Key.EmptyKey()));
                            }
                            graph.AddDirectedEdge(newNode, summaryNode);
                        }
                    }
                }
            }

            var(firstTaskItemNode, _) = nodes[Key.ForTaskItemPage(task.Id, task.TaskItems.First().Id, new[] { repeatIndex })];
            graph.AddDirectedEdge(taskItemRouter, firstTaskItemNode);
            graph.AddDirectedEdge(preTaskNode, taskItemRouter);

            graph.AddDirectedEdge(postTaskNode, summaryNode);
            graph.AddDirectedEdge(summaryNode, postTaskNode);

            nodes.Add(taskItemRouter.Key, (taskItemRouter, null));

            return(nodes);
        }