private string GenerateQuestion(QuestionTreeNode node, int level)
{
return(String.Format(
"node [question,label=right:{{{3}}}] {{{0}?}}{1}{2}",
node.QuestionAttribute,
Environment.NewLine,
String.Join(Environment.NewLine, node.Answers
.Select(a => String.Format("child {{ {0} }}",
Generate(node[a], a, level + 1)))
.ToArray()),
String.Join(@" \\ ", node.Data.GroupBy(d => d.Answer).Select(
g => g.Key + ": \\{{" + String.Join(", ", g.Select(d => d.ToString())) + "\\}}"))));
}
private string Generate(ITreeNode node, string answer, int level)
{
StringBuilder sb = new StringBuilder();
if (node is AnswerTreeNode)
{
AnswerTreeNode answerTreeNode = node as AnswerTreeNode;
sb.Append(GenerateAnswer(answerTreeNode));
}
else if (node is QuestionTreeNode)
{
QuestionTreeNode questionTreeNode = node as QuestionTreeNode;
sb.Append(GenerateQuestion(questionTreeNode, level));
}
if (answer != null)
{
sb.AppendFormat(
"{0}edge from parent node [left] {{{1}}}",
Environment.NewLine,
answer);
}
return(sb.ToString().Indent(level, " "));
}
public static void ShouldBeEquivalentTo(this QuestionTreeNode actual, QuestionTreeNode expected)
{
if (actual == null)
{
expected.Should().BeNull();
return;
}
actual.Id.Should().Be(expected.Id);
actual.Text.Should().Be(expected.Text);
actual.Type.Should().Be(expected.Type);
if (actual.Children == null)
{
expected.Children.Should().BeNull();
return;
}
actual.Children.Count.Should().Be(expected.Children.Count);
actual.Children.FirstOrDefault(x => x.Type == QuestionAnswer.Positive).ShouldBeEquivalentTo(expected.Children.FirstOrDefault(x => x.Type == QuestionAnswer.Positive));
actual.Children.FirstOrDefault(x => x.Type == QuestionAnswer.Negative).ShouldBeEquivalentTo(expected.Children.FirstOrDefault(x => x.Type == QuestionAnswer.Negative));
}
public void ShouldReturnTree()
{
//arrange
var context = TestDbContextCreator.CreateSqlServer();
using (context.Database.BeginTransaction())
{
context.Questions.RemoveRange(context.Questions);
context.SaveChanges();
context.Database.ExecuteSqlRaw(@"set IDENTITY_INSERT [Questions] on
insert into Questions
(Id, [Text], [PositiveAnswerQuestionId], [NegativeAnswerQuestionId])
values
(1, 'Do I want a doughnut?', 2, 3),
(2, 'Do I deserve it?', 4, 5),
(3, 'Maybe you want an apple?', null, null),
(4, 'Are you sure?', 6, 7),
(5, 'Is it a good doughnut?', 8, 9),
(6, 'Are you really sure?', 10, 11),
(7, 'Do jumping jacks first.', null, null),
(8, 'What are you waiting for? Grab it now.', null, null),
(9, 'Wait `till you find a sinful, unforgettable doughnut.', null, null),
(10, 'Get it.', null, null),
(11, 'Why not to take a cake?', null, null)
set IDENTITY_INSERT[Questions] off");
context.SaveChanges();
var sut = new QuestionsService(context);
var expected = new QuestionTreeNode
{
Id = 1,
Text = "Do I want a doughnut?",
Type = null,
Children = new List <QuestionTreeNode>
{
new QuestionTreeNode
{
Id = 2,
Text = "Do I deserve it?",
Type = QuestionAnswer.Positive,
Children = new List <QuestionTreeNode>
{
new QuestionTreeNode
{
Id = 4,
Text = "Are you sure?",
Type = QuestionAnswer.Positive,
Children = new List <QuestionTreeNode>
{
new QuestionTreeNode
{
Id = 6,
Text = "Are you really sure?",
Type = QuestionAnswer.Positive,
Children = new List <QuestionTreeNode>
{
new QuestionTreeNode
{
Id = 10,
Text = "Get it.",
Type = QuestionAnswer.Positive
},
new QuestionTreeNode
{
Id = 11,
Text = "Why not to take a cake?",
Type = QuestionAnswer.Negative
}
}
},
new QuestionTreeNode
{
Id = 7,
Text = "Do jumping jacks first.",
Type = QuestionAnswer.Negative
}
}
},
new QuestionTreeNode
{
Id = 5,
Text = "Is it a good doughnut?",
Type = QuestionAnswer.Negative,
Children = new List <QuestionTreeNode>
{
new QuestionTreeNode
{
Id = 8,
Text = "What are you waiting for? Grab it now.",
Type = QuestionAnswer.Positive
},
new QuestionTreeNode
{
Id = 9,
Text = "Wait `till you find a sinful, unforgettable doughnut.",
Type = QuestionAnswer.Negative
}
}
}
}
},
new QuestionTreeNode
{
Id = 3,
Text = "Maybe you want an apple?",
Type = QuestionAnswer.Negative
}
}
};
//arrange
var actual = sut.GetQuestionsTree();
//assert
actual.ShouldBeEquivalentTo(expected);
}
}
public QuestionTreeNode GetQuestionsTree()
{
void FillCteResult(QuestionTreeNode node, QuestionEntity currentEntity, Queue <QuestionEntity> entities)
{
if (currentEntity.PositiveAnswerQuestionId.HasValue || currentEntity.NegativeAnswerQuestionId.HasValue)
{
node.Children = new List <QuestionTreeNode>();
}
else
{
return;
}
QuestionEntity positiveEntity = null;
QuestionTreeNode positiveNode = null;
QuestionEntity negativeEntity = null;
QuestionTreeNode negativeNode = null;
if (currentEntity.PositiveAnswerQuestionId.HasValue)
{
positiveEntity = entities.Dequeue();
positiveNode = positiveEntity.ToQuestionTreeNode(QuestionAnswer.Positive);
node.Children.Add(positiveNode);
}
if (currentEntity.NegativeAnswerQuestionId.HasValue)
{
negativeEntity = entities.Dequeue();
negativeNode = negativeEntity.ToQuestionTreeNode(QuestionAnswer.Negative);
node.Children.Add(negativeNode);
}
if (negativeNode != null)
{
FillCteResult(negativeNode, negativeEntity, entities);
}
if (positiveEntity != null)
{
FillCteResult(positiveNode, positiveEntity, entities);
}
}
var firstQuestion = GetFirstQuestionEntityAsNoTracking();
if (firstQuestion == null)
{
return(null);
}
var query = _context.Questions.FromSqlRaw("exec GetQuestionsTree {0}", firstQuestion.Id).AsNoTracking();
var entities = new Queue <QuestionEntity>(query);
var root = entities.Dequeue();
var result = root.ToQuestionTreeNode(null);
FillCteResult(result, root, entities);
return(result);
}
