private void radioBtn_UnChecked(object sender, RoutedEventArgs e)
{
ToggleButton radioBtn = sender as ToggleButton;
if (radioBtn == null)
{
return;
}
QuestionOption option = radioBtn.Tag as QuestionOption;
if (option == null)
{
return;
}
if (this.selectableQuestion is MCQuestion ||
this.selectableQuestion is TFQuestion)
{
}
else if (this.selectableQuestion is MRQuestion)
{
if (this.response.OptionIdList.Contains(option.Id))
{
this.response.OptionIdList.Remove(option.Id);
}
}
}
public static void Initializer(QuizContext context)
{
context.Database.EnsureCreated();
if (context.QuestionOptions.Any())
{
return; // DB has been seeded
}
var question_and_Answers = new QuestionOption[]
{
new QuestionOption {
Question = "What animal kills the most humans every year?", Option1 = "Mosquitoes", Option2 = "Humans", Option3 = "Scorpions", CorrectAnswer = "Mosquitoes"
},
new QuestionOption {
Question = "Which planet has the longest day?", Option1 = "Jupiter", Option2 = "Saturn", Option3 = "Venus", CorrectAnswer = "Venus"
},
new QuestionOption {
Question = "What percentage of DNA do humans share with bananas?", Option1 = "50%", Option2 = "70%", Option3 = "40%", CorrectAnswer = "50%"
},
new QuestionOption {
Question = "When were oreos invented?", Option1 = "1987", Option2 = "1912", Option3 = "1953", CorrectAnswer = "1912"
},
new QuestionOption {
Question = "what is the tallest structure in the world?", Option1 = "Shanghai Tower", Option2 = "Burj Khalifa", Option3 = "One World Trade Center", CorrectAnswer = "Burj Khalifa"
}
};
foreach (var question in question_and_Answers)
{
context.QuestionOptions.Add(question);
}
context.SaveChanges();
}
public int AddQuestionOption(QuestionOption questionOption)
{
context.QuestionOptions.Add(questionOption);
context.Entry(questionOption.Question).State = Microsoft.EntityFrameworkCore.EntityState.Unchanged;
context.SaveChanges();
return(questionOption.QuestionOptionId);
}
internal QuestionOption CreateOption(int index)
{
QuestionOption option = new QuestionOption();
option.Index = index;
return(option);
}
public ActionResult CreateQuestion()
{
int questionTypeId = int.Parse(HttpContext.Request.Form["QuestionType_Id"]);
// Get the question type model in order to continue saving
var questionType = _context.QuestionType.SingleOrDefault(q => q.Id == questionTypeId);
var question = new Question {
QuestionString = HttpContext.Request.Form["QuestionString"].ToString(), QuestionType = questionType
};
_context.Question.Add(question);
_context.SaveChanges();
// get json encoded options from input field
var jsonOptions = HttpContext.Request.Form["questionOptionsInput"].ToString();
// convert jsonOptions to a c# array
var questionOptions = JValue.Parse(jsonOptions);
foreach (var option in questionOptions)
{
var questionOption = new QuestionOption {
Option = (string)option, Question = question
};
_context.QuestionOption.Add(questionOption);
_context.SaveChanges();
}
return(RedirectToAction("Questions"));
}
public ActionResult AddQuestionOption(DataModel data)
{
data.Survey = surveyService.GetSurvey(data.Survey.Id);
data.Question = questionService.GetQuestionById(data.Question.QuestionId);
if (data.QuestionOption.QuestionOptionText == null)
{
ViewBag.question = questionService.GetCountQuestion(data.Survey.Id);
ViewBag.option = questionService.GetCountQuestionOptionByQuestionId(data.Question.QuestionId) + 1;
ViewBag.errorQuestionOption = "Complete question option text!";
return(View("Views/Question/QuestionOption.cshtml", data));
}
QuestionOption questionOption = new QuestionOption();
questionOption.Question = data.Question;
questionOption.QuestionOptionText = data.QuestionOption.QuestionOptionText;
questionService.AddQuestionOption(questionOption);
DataModel model = new DataModel();
model.Survey = data.Survey;
model.Question = data.Question;
ModelState.Clear();
ViewBag.option = questionService.GetCountQuestionOptionByQuestionId(model.Question.QuestionId) + 1;
ViewBag.question = questionService.GetCountQuestion(model.Survey.Id);
return(View("Views/Question/QuestionOption.cshtml", model));
}
public async Task ReadFunctionalityRetrievesQuestionOptionAndCorrespondingQuestionAndTest()
{
Test test;
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
test = new Test()
{
TestName = "Test1"
};
Question question = new Question {
Test = test, QuestionText = "TestQuestion1"
};
QuestionOption questionOption = new QuestionOption()
{
OptionText = "TestOption1", Question = question
};
await context.Set <Test>().AddAsync(test);
await context.Set <Question>().AddAsync(question);
await context.Set <QuestionOption>().AddAsync(questionOption);
await context.SaveChangesAsync();
}
Test retrievedTest = await testService.Get(test.Id);
Question retrievedQuestion = retrievedTest.Questions.ToList()[0];
QuestionOption retrievedQuestionOption = retrievedQuestion.QuestionOptions.ToList()[0];
Assert.AreEqual("Test1", retrievedTest.TestName);
Assert.AreEqual("TestQuestion1", retrievedQuestion.QuestionText);
Assert.AreEqual("TestOption1", retrievedQuestionOption.OptionText);
}
public QuestionOption Create(QuestionOption question)
{
_context.QuestionOptions.Add(question);
_context.SaveChanges();
return(question);
}
private void radioBtn_Checked(object sender, RoutedEventArgs e)
{
RadioButton radioBtn = sender as RadioButton;
if (radioBtn == null)
{
return;
}
QuestionOption option = radioBtn.Tag as QuestionOption;
if (option == null)
{
return;
}
this.isCorrect = option.IsCorrect;
if (this.response.OptionIdList.Count == 0)
{
this.response.OptionIdList.Add(option.Id);
}
else
{
this.response.OptionIdList[0] = option.Id;
}
}
public async Task <IActionResult> Edit(int id, [Bind("QuestionOptionId,QuestionId,OptionValue,IsCorrect")] QuestionOption questionOption)
{
if (id != questionOption.QuestionOptionId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(questionOption);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!QuestionOptionExists(questionOption.QuestionOptionId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["QuestionId"] = new SelectList(_context.Questions, "QuestionId", "QuestionName", questionOption.QuestionId);
return(View(questionOption));
}
public ActionResult AddQuestions(EditQuizViewModel model)
{
Question question = new Question();
question.Text = model.NewQuestion.Text;
question.CorrectAnswerId = null;
question.QuizId = db.Quizes.Where(x => x.vId == model.QuizvId).First().Id;
db.Questions.Add(question);
db.SaveChanges();
foreach (var answer in model.NewQuestion.Answers)
{
var a = new QuestionOption
{
Text = answer.Text,
QuestionId = question.Id
};
db.QuestionOptions.Add(a);
db.SaveChanges();
if (answer.IsCorrect)
{
question.CorrectAnswerId = a.Id;
}
question.PossibleAnswers.Add(a);
db.SaveChanges();
}
return(AddQuestions(model.QuizvId));
}
public async Task TestCopyQuestion()
{
//Prepare
TestingContext context = new TestingContext();
InitContext(context);
ApplicationDbContext dbContext = context.GetSimple <ApplicationDbContext>();
Question question = dbContext.Questions.First();
context.AddPrincipalMock(question.User.UserId, Roles.User);
IQuestionService questionService = context.GetService <QuestionService>();
context.DependencyMap[typeof(IQuestionService)] = questionService;
IVersionService versionService = context.GetService <VersionService>();
//Act
int newId = await versionService.CopyQuestionAsync(question.Id);
//Assert
Assert.True(question.Id != newId);
Assert.True(newId > 0);
QuestionDto newQuestion = await questionService.GetQuestionAsync(newId);
Assert.Equal(question.Options.Count, newQuestion.Options.Count);
Assert.Equal(question.QuestionType, newQuestion.QuestionType);
for (int i = 0; i < question.Options.Count; i++)
{
QuestionOption optionSource = question.Options[i];
QuestionOptionDto optionDestination = newQuestion.Options[i];
Assert.NotEqual(optionSource.Id, optionDestination.Id);
Assert.True(optionDestination.Id > 0);
}
}
public QuestionOption GetQuestionOption(MySqlConnection connection, int id)
{
QuestionOption questionOption = null;
string query = "select * from question_option where id = " + id;
try
{
MySqlCommand command = new MySqlCommand(query, connection);
MySqlDataReader reader = command.ExecuteReader();
if (reader.HasRows)
{
if (reader.Read())
{
questionOption = new QuestionOption(reader.GetInt16("id"), reader.GetString("question_string"), reader.GetInt16("point"), reader.GetInt16("question_id"));
}
}
command.Dispose();
reader.Dispose();
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
return(questionOption);
}
private void AppendOption(QuestionOption option, int index)
{
StackPanel stackPanel = new StackPanel();
stackPanel.Orientation = Orientation.Horizontal;
stackPanel.Margin = new Thickness(20, 3, 0, 3);
Label indexLabel = new Label();
indexLabel.Content = string.Format("{0}. ", (char)('A' + index));
indexLabel.VerticalAlignment = System.Windows.VerticalAlignment.Center;
indexLabel.FontSize = 20;
stackPanel.Children.Add(indexLabel);
ToggleButton toggleButton = null;
if (this.selectableQuestion is MCQuestion)
{
toggleButton = new RadioButton();
((RadioButton)toggleButton).GroupName = this.selectableQuestion.Id;
}
else if (this.selectableQuestion is MRQuestion)
{
toggleButton = new CheckBox();
}
else if (this.selectableQuestion is TFQuestion)
{
toggleButton = new RadioButton();
((RadioButton)toggleButton).GroupName = this.selectableQuestion.Id;
}
toggleButton.VerticalAlignment = System.Windows.VerticalAlignment.Center;
toggleButton.Tag = option;
if (this.response != null)
{
if (this.response.OptionIdList.Count > 0)
{
if (option.Id == this.response.OptionIdList[0])
{
toggleButton.IsChecked = true;
this.isCorrect = true;
}
}
}
toggleButton.Checked += toggleButtonCheckedHandler;
toggleButton.Unchecked += this.toggleButtonUnCheckedHandler;
this.toggleButtonList.Add(toggleButton);
stackPanel.Children.Add(toggleButton);
Panel contentControl = CommonControlCreator.CreateContentControl(option.OptionContent, null, this.Foreground, null);
if (contentControl != null)
{
contentControl.VerticalAlignment = System.Windows.VerticalAlignment.Center;
contentControl.HorizontalAlignment = System.Windows.HorizontalAlignment.Left;
toggleButton.Content = contentControl;
}
this.optionPanel.Children.Add(stackPanel);
}
public async Task <bool> AddOption(QuestionOption newQuestionOption)
{
await _optionRepository.AddAsync(newQuestionOption);
var result = Task.Run(() => _optionRepository.SaveAll());
return(await result);
}
public ActionResult DeleteConfirmed(int id)
{
QuestionOption questionOption = db.QuestionOptions.Find(id);
db.QuestionOptions.Remove(questionOption);
db.SaveChanges();
return(RedirectToAction("Index"));
}
private GrpcQuestionOption GetGrpcQuestionOption(QuestionOption questionOption)
{
return(new GrpcQuestionOption()
{
Key = questionOption.Key,
Value = questionOption.Value
});
}
public QuestionOptionViewModel(int QuestionId, KwisspelEntities context)
{
_context = context;
_questionOption = new QuestionOption();
_questionOption.Questions_id = QuestionId;
_context.QuestionOptions.Add(_questionOption);
}
private void CreateTableQuestion(SectionBaseInfo info, Section section)
{
int minValue = 10;
int maxValue = 100;
if (info is SectionValueRangeInfo)
{
SectionValueRangeInfo rangeInfo = info as SectionValueRangeInfo;
minValue = decimal.ToInt32(rangeInfo.MinValue);
maxValue = decimal.ToInt32(rangeInfo.MaxValue);
}
Random rand = new Random((int)DateTime.Now.Ticks);
string questionText = "从表格中选择符合减法的性质条件的等式";
TableQuestion tableQuestion = ObjectCreator.CreateTableQuestion((content) =>
{
content.Content = questionText;
content.ContentType = ContentType.Text;
return;
},
() =>
{
List <QuestionOption> optionList = new List <QuestionOption>();
for (int j = 0; j < 36; j++)
{
if (rand.Next() % 2 == 0) // Create correct Option
{
decimal valueA = rand.Next(minValue, maxValue + 1);
decimal valueB = rand.Next(minValue, maxValue + 1);
QuestionOption option = new QuestionOption();
option.IsCorrect = true;
option.OptionContent.Content = string.Format("{0}×{1}={1}×{0}", valueA, valueB);
optionList.Add(option);
}
else
{
decimal valueA = rand.Next(minValue, maxValue + 1);
decimal valueB = rand.Next(minValue, maxValue + 1);
decimal valueC = rand.Next(minValue, decimal.ToInt32(valueA + valueB + 1));
decimal valueD = valueA + valueB - valueC;
QuestionOption option = new QuestionOption();
option.IsCorrect = (valueC == valueB) ? true : false;
option.OptionContent.Content = string.Format("{0}×{1}={2}×{3}", valueA, valueB, valueC, valueD);
optionList.Add(option);
}
}
return(optionList);
}
);
// tableQuestion.Solution.Content = string.Format("加数{0}与加数{1}的和是{2}，所以正确答案是{2}。", valueA, valueB, result);
section.QuestionCollection.Add(tableQuestion);
}
public ActionResult Create(Models.Survey survey)
{
if (ModelState.IsValid)
{
if (Request.Form["Template"] != null)
{
var model = new Models.Survey();
model.EndDate = survey.EndDate;
model.SurveyTitle = survey.SurveyTitle;
model.TimeLimit = survey.TimeLimit;
//int userID = db.Users.Where(t => t.UserEmailID.Equals(User.Identity.Name)).FirstOrDefault().UserID;
model.UserID = survey.UserID;
foreach (var item in db.Questions.Where(t => t.SurveyID == survey.SurveyID).ToList())
{
Question q = new Question();
q.QuestionIndex = item.QuestionIndex;
q.QuestionText = item.QuestionText;
q.OptionCount = item.OptionCount;
q.QuestionTypeID = item.QuestionTypeID;
q.SurveyID = model.SurveyID;
foreach (var itm in db.QuestionOptions.Where(o => o.QuestionID == item.QuestionID).ToList())
{
QuestionOption qo = new QuestionOption();
qo.IsSurveyLogicText = itm.IsSurveyLogicText;
qo.QuestionID = q.QuestionID;
qo.QuestionOptionText = itm.QuestionOptionText;
qo.SurveyLogicText = itm.SurveyLogicText;
q.QuestionOptions.Add(qo);
}
model.Questions.Add(q);
}
db.Surveys.Add(model);
db.SaveChanges();
return(RedirectToAction("Index"));
}
if (survey.SurveyID == 0)
{
db.Surveys.Add(survey);
}
else
{
db.Entry(survey).State = EntityState.Modified;
}
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.UserID = new SelectList(db.Users, "UserID", "UserEmailID", survey.UserID);
return(View(survey));
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
QuestionOption questionOption = await db.QuestionOptions.FindAsync(id);
db.QuestionOptions.Remove(questionOption);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public async Task <QuestionOption> AddOption(Question question, QuestionOption option)
{
option.Type = question.Type;
question.Options.Add(option);
await _context.SaveChangesAsync();
return(option);
}
public async Task <IActionResult> DeleteConfirmed(int id)
{
QuestionOption questionOption = await _context.QuestionOption.SingleAsync(m => m.Id == id);
_context.QuestionOption.Remove(questionOption);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
//
// GET: /QuestionOption/Details/5
public ActionResult Details(int id = 0)
{
QuestionOption questionoption = db.QuestionOption.Find(id);
if (questionoption == null)
{
return(HttpNotFound());
}
return(View(questionoption));
}
public static OptionModel Create(QuestionOption o)
=> new OptionModel
{
Id = o.Id,
Title = o.Title,
Description = o.Description,
SelectedBy = o.Answers
.Select(a => AnswerModel.Create(a.Signup))
.ToList()
};
public async Task <IActionResult> Edit(QuestionOption questionOption)
{
if (ModelState.IsValid)
{
_context.Update(questionOption);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(questionOption));
}
//
// GET: /QuestionOption/Edit/5
public ActionResult Edit(int id = 0)
{
QuestionOption questionoption = db.QuestionOption.Find(id);
if (questionoption == null)
{
return(HttpNotFound());
}
ViewBag.QuestionID = new SelectList(db.QuestionPool, "QuestionID", "Question", questionoption.QuestionID);
return(View(questionoption));
}
public ActionResult Edit(QuestionOption questionoption)
{
if (ModelState.IsValid)
{
db.Entry(questionoption).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.QuestionID = new SelectList(db.QuestionPool, "QuestionID", "Question", questionoption.QuestionID);
return(View(questionoption));
}
public ActionResult AddOption(QuestionOption questionOption, Question question)
{
db.QuestionOption.Add(questionOption);
var v = db.Question.OrderByDescending(t => t.QuestionOptionID).First();
ViewBag.yolla = v.QuestionOptionID;
db.SaveChanges();
var model = db.QuestionOption.ToList();
return(View(model));
}
public ActionResult Edit([Bind(Include = "IdOption,NomOption,NomChoix,IdQuestion,IsGood")] QuestionOption questionOption)
{
if (ModelState.IsValid)
{
db.Entry(questionOption).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.IdQuestion = new SelectList(db.Questions, "IdQuestion", "LibelleQuestion", questionOption.IdQuestion);
return(View(questionOption));
}
public object Deserialize(JsonValue json, JsonMapper mapper)
{
QuestionOption option = null;
if ( json != null && !json.IsNull )
{
option = new QuestionOption();
option.ID = json.ContainsName("id" ) ? json.GetValue<string>("id" ) : String.Empty;
option.Name = json.ContainsName("name" ) ? json.GetValue<string>("name" ) : String.Empty;
option.Votes = json.ContainsName("votes" ) ? json.GetValue<int >("votes") : 0;
option.CreatedTime = json.ContainsName("created_time") ? JsonUtils.ToDateTime(json.GetValue<string>("created_time"), "yyyy-MM-ddTHH:mm:ss") : DateTime.MinValue;
option.From = mapper.Deserialize<Reference>(json.GetValue("from" ));
option.Object = mapper.Deserialize<Page >(json.GetValue("object"));
}
return option;
}
public void TestQuestionWithQuestionType5()
{
#region Arrange
const string qtype = "Drop Down";
var question = GetValid(9);
question.QuestionType = Repository.OfType<QuestionType>().Queryable.Where(a => a.Name == qtype).First();
var questionOption = new QuestionOption("TaDa");
question.AddQuestionOption(questionOption);
#endregion Arrange
#region Act
QuestionRepository.DbContext.BeginTransaction();
QuestionRepository.EnsurePersistent(question);
QuestionRepository.DbContext.CommitTransaction();
#endregion Act
#region Assert
Assert.AreEqual(qtype, question.QuestionType.Name);
Assert.IsFalse(question.IsTransient());
Assert.IsTrue(question.IsValid());
#endregion Assert
}
