public async Task <IActionResult> Edit(int id, [Bind("QuestionRuleId,SubjectId,ScorePerQuestion,AnswerAllQuestion,TotalQuestion,UseUnlimitedTime,MaximumTime,StartDate,EndDate,NoOfAllowedAttempt,NoOfAttemptPerDay")] QuestionRule questionRule)
{
if (id != questionRule.QuestionRuleId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(questionRule);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!QuestionRuleExists(questionRule.QuestionRuleId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["SubjectId"] = new SelectList(_context.Subjects, "SubjectId", "SubjectId", questionRule.SubjectId);
return(View(questionRule));
}
public ActionResult DeleteConfirmed(int id)
{
QuestionRule questionRule = db.QuestionRules.Find(id);
db.QuestionRules.Remove(questionRule);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public override object Visit(QuestionRule expression, TypeAnalyzerEnvironment environment)
{
var questionType = this.qlQuestionMappings[expression.Name];
this.CheckWidgetTyping(expression.Widget, questionType);
return(base.Visit(expression, environment));
}
public ActionResult RuleParameters([Bind(Include = "QuestionID,RuleParam")] QuestionRule rules)
{
db.QuestionRules.Add(rules);
db.SaveChanges();
Session.Remove("QuestionID");
return(RedirectToAction("Create"));
}
public ActionResult Edit(QuestionRule questionRule)
{
if (ModelState.IsValid)
{
db.Entry(questionRule).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index", new { questionId = questionRule.QuestionId }));
}
ViewBag.QuestionId = new SelectList(db.Questions.Where(x => x.QuestionId == questionRule.QuestionId), "QuestionId", "Text", questionRule.QuestionId);
return(View(questionRule));
}
private StyleSheet GetStyleSheetWrapper(QuestionRule rule)
{
return(new StyleSheet("SampleStyleShett", new List <Page>
{
new Page("SamplePage", new List <Section>
{
new Section(new StringLiteral("Sample Section"), null, new List <QuestionRule> {
rule
})
})
}));
}
public ActionResult Create(QuestionRule questionRule)
{
if (ModelState.IsValid)
{
db.QuestionRules.Add(questionRule);
db.SaveChanges();
return(RedirectToAction("Index", new { questionId = questionRule.QuestionId }));
}
ViewBag.QuestionId = new SelectList(db.Questions, "QuestionId", "Text", questionRule.QuestionId);
return(View(questionRule));
}
public async Task <IActionResult> Create([Bind("QuestionRuleId,SubjectId,ScorePerQuestion,AnswerAllQuestion,TotalQuestion,UseUnlimitedTime,MaximumTime,StartDate,EndDate,NoOfAllowedAttempt,NoOfAttemptPerDay")] QuestionRule questionRule)
{
if (ModelState.IsValid)
{
_context.Add(questionRule);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["SubjectId"] = new SelectList(_context.Subjects, "SubjectId", "SubjectId", questionRule.SubjectId);
return(View(questionRule));
}
public override object Visit(QuestionRule rule, IFormAnalyzerEnvironment environment)
{
if (environment.SectionNames.Contains(rule.Identifier))
{
this.Report.Add(new DuplicateQuestionLabelMessage(rule));
}
else
{
environment.SectionNames.Add(rule.Identifier);
}
return(base.Visit(rule, environment));
}
public override object Visit(QuestionRule rule, IQuestionUsageEnviorment environment)
{
if (environment.HasQuestion(rule.Identifier))
{
environment.MarkQuestionAsUsed(rule.Identifier);
}
else
{
this.Report.Add(new UndeclaredQuestionMessage(rule.Identifier));
}
return(base.Visit(rule, environment));
}
public override object Visit(QuestionRule expression, FormAnalyzerEnvironment environment)
{
if (environment.SectionNames.Contains(expression.Name))
{
this.Report.Add(new DuplicateQuestionLabelMessage(expression));
}
else
{
environment.SectionNames.Add(expression.Name);
}
return(base.Visit(expression, environment));
}
public override object Visit(QuestionRule rule, ITypeAnalyzerEnvironment environment)
{
if (!this.qlQuestionMappings.ContainsKey(rule.Identifier))
{
this.Report.Add(new UndeclaredQuestionMessage(rule.Identifier));
return(base.Visit(rule, environment));
}
var questionType = this.qlQuestionMappings[rule.Identifier];
this.CheckWidgetTyping(rule.Widget, questionType, environment);
return(base.Visit(rule, environment));
}
// GET: QuestionRule/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
QuestionRule questionRule = db.QuestionRules.Find(id);
if (questionRule == null)
{
return(HttpNotFound());
}
return(View(questionRule));
}
// GET: QuestionRule/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
QuestionRule questionRule = db.QuestionRules.Find(id);
if (questionRule == null)
{
return(HttpNotFound());
}
ViewBag.QuestionId = new SelectList(db.Questions.Where(x => x.QuestionId == questionRule.QuestionId), "QuestionId", "Text", questionRule.QuestionId);
return(View(questionRule));
}
public void Analyze_ShouldDetectErrorIfInvalidQuestionRuleIsGiven(
Widget widget,
IList <ValueType> invalidTypes)
{
const string sampleQuestionName = "SampleQuestion";
var questionRule = new QuestionRule(sampleQuestionName, widget, null);
foreach (var invalidType in invalidTypes)
{
var typeAnamyzer = new TypeAnalyzer();
var sampleQuestionMapings = new Dictionary <string, ValueType>
{
{ sampleQuestionName, invalidType }
};
typeAnamyzer.Analyze(this.GetStyleSheetWrapper(questionRule), sampleQuestionMapings);
Assert.NotEmpty(typeAnamyzer.Report.AllMessages);
Assert.IsType <InvalidWidgetTypeMessage>(typeAnamyzer.Report.Errors.FirstOrDefault());
Assert.Equal(1, typeAnamyzer.Report.AllMessages.Count());
}
}
public QuestionRule(QuestionRule rule)
: base(rule)
{
AllowedValues = rule.AllowedValues;
Questions = rule.Questions;
}
public Questionnaire GetStoreModel()
{
// create store model questionnaire
var questionnaire = new Questionnaire
{
Category = _questionnairePostViewModel.Category,
Version = _questionnairePostViewModel.Version,
Questions = new Collection <Question>(),
QuestionRules = new Collection <QuestionRule>()
};
// create stopre model questions and questionrules
foreach (var viewModelQuestion in _questionnairePostViewModel.Questions)
{
var question = new Question
{
QuestionTemplate = new Collection <Template>(),
Name = viewModelQuestion.Key,
Type = viewModelQuestion.Type,
Version = viewModelQuestion.Version
};
var questionRule = new QuestionRule
{
ExpressionModel = new Collection <ExpressionModel>(),
Name = viewModelQuestion.Key,
HideQuestion = viewModelQuestion.HideExpression
};
if (viewModelQuestion.ExpressionProperties != null)
{
foreach (var(key, value) in viewModelQuestion.ExpressionProperties)
{
var expressionModel = new ExpressionModel
{
Key = key,
Expression = value
};
questionRule.ExpressionModel.Add(expressionModel);
}
}
var globalTemplate = viewModelQuestion.TemplateOptions;
foreach (var translation in globalTemplate.Translations)
{
// check if question is required
questionRule.Required = globalTemplate.Required;
// Add all templateswith different languages to the template
var questionTemplate = new Template
{
Description = translation.Description,
InputType = globalTemplate.Type,
Label = translation.Label,
Language = translation.Language,
Placeholder = translation.Placeholder,
Validations = new Collection <Validation>()
};
if (translation.Validation.Messages != null)
{
foreach (var(key, value) in translation.Validation.Messages)
{
var expressionModel = new Validation()
{
Type = key,
Message = value
};
questionTemplate.Validations.Add(expressionModel);
}
}
if (translation.MultipleChoiceOptions != null)
{
questionTemplate.SelectAllOption = translation.SelectAllOption;
questionTemplate.AllowedToSelectMultipleOptions = globalTemplate.Multiple;
questionTemplate.Options = new Collection <MultipleChoiceOption>();
foreach (var option in translation.MultipleChoiceOptions)
{
var multipleChoiceOption = new MultipleChoiceOption
{
Value = option.Value,
Label = option.Label
};
questionTemplate.Options.Add(multipleChoiceOption);
}
question.QuestionTemplate.Add(questionTemplate);
}
else
{
question.QuestionTemplate.Add(questionTemplate);
}
}
questionnaire.Questions.Add(question);
questionnaire.QuestionRules.Add(questionRule);
}
return(questionnaire);
}
public DuplicateQuestionLabelMessage(QuestionRule question)
: base($"Duplicate question label \"{question.Identifier}\" at: {question.SourceCode}")
{
}
public virtual TResult Visit(QuestionRule expression, TEnvironment environment)
{
expression.Properties?.ForEach(x => x.Accept(this, environment));
expression.Widget?.Accept(this, environment);
return(default(TResult));
}
