public async Task <IActionResult> CreateQuestion(CreateQuestionViewModel model)
{
if (ModelState.IsValid)
{
string categoryName = model.qq_cat;
var qcid = (from x in _context.quiz_Categories where x.qc_type == categoryName select x.qc_Id);
var quizeQuestion = new Quiz_question
{
qc_Id = qcid.First(),
qq_question = model.qq_question,
qq_opta = model.qq_opta,
qq_optb = model.qq_optb,
qq_optc = model.qq_optc,
qq_optd = model.qq_optd,
qq_ans = model.qq_ans
};
var result = _QuestionRepository.AddQuestion(quizeQuestion);
if (result == null)
{
ModelState.AddModelError("", result.ToString());
}
}
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> Create(CreateQuestionViewModel model)
{
try
{
CreateQuestionCommand command = new CreateQuestionCommand()
{
Name = model.Name,
Description = model.Description,
Email = model.Email
};
var result = await QuestionService.CreateQuestionAsync(command);
if (result.Succeeded)
{
return(RedirectToAction("Questions"));
}
else
{
return(View());
}
}
catch (Exception exception)
{
Logger.LogError(exception, "Error while creating question");
return(View());
}
}
public async Task CreateAsync(CreateQuestionViewModel input)
{
Question question = new Question
{
Value = input.QuestionValue,
DifficultId = input.DifficultId,
CategoryId = input.CategoryId,
StageId = input.StageId,
Description = input.Description,
AddedByUserId = input.UserId,
};
foreach (var inputAnswer in input.Answers)
{
var answer = this.answerRepository.All().FirstOrDefault(a => a.Value == inputAnswer.AnswerValue);
bool isCorrect = inputAnswer.IsTrue == "on";
if (answer == null)
{
answer = new Answer()
{
Value = inputAnswer.AnswerValue,
};
}
question.Answers.Add(new QuestionAnswer {
Answer = answer, IsCorrect = isCorrect
});
}
await this.questionsRepository.AddAsync(question);
await this.questionsRepository.SaveChangesAsync();
}
public async Task <IActionResult> CreateQuestion(CreateQuestionViewModel model)
{
if (ModelState.IsValid)
{
Question quest = new Question {
TestId = model.TestId, Text = model.Text, Type = model.Type
};
await db.Questions.AddAsync(quest);
Variant v1 = new Variant {
QuestionId = quest.Id, IsCorrect = model.Var1IsCorrect, Text = model.Variant1
};
Variant v2 = new Variant {
QuestionId = quest.Id, IsCorrect = model.Var2IsCorrect, Text = model.Variant2
};
Variant v3 = new Variant {
QuestionId = quest.Id, IsCorrect = model.Var3IsCorrect, Text = model.Variant3
};
Variant v4 = new Variant {
QuestionId = quest.Id, IsCorrect = model.Var4IsCorrect, Text = model.Variant4
};
await db.Variants.AddRangeAsync(v1, v2, v3, v4);
await db.SaveChangesAsync();
return(RedirectToAction("Questions", new { id = model.TestId }));
}
return(View(model));
}
public IActionResult AddQuestion(CreateQuestionViewModel question)
{
if (!ModelState.IsValid)
{
return(View(question));
}
var answers = new List <Answer>
{
new Answer {
Text = question.Answer1, Correct = question.CorrectAnswer1
},
new Answer {
Text = question.Answer2, Correct = question.CorrectAnswer2
},
new Answer {
Text = question.Answer3, Correct = question.CorrectAnswer3
},
new Answer {
Text = question.Answer4, Correct = question.CorrectAnswer4
}
};
var newQuestion = new Question
{
Title = question.Title,
QuizId = question.QuizId,
Answers = answers
};
_repo.AddQuestion(question.QuizId, newQuestion);
return(RedirectToAction(nameof(AddQuestion), new { quizId = question.QuizId }));
}
public void PollPassedToQuestionCreateView()
{
// Arrange
var fakeDB = new FakePollContext();
fakeDB.Polls = new FakePollSet();
fakeDB.Questions = new FakeDbSet <Question>();
var poll = new Poll {
ID = 1, Title = "Hello"
};
fakeDB.Polls.Add(poll);
var poll2 = new Poll {
ID = 2, Title = "world"
};
fakeDB.Polls.Add(poll2);
QuestionsController controller = new QuestionsController(fakeDB);
// Act
ViewResult result = controller.Create("1") as ViewResult;
CreateQuestionViewModel generatedViewModel = result.ViewData.Model as CreateQuestionViewModel;
// Assert
Assert.AreEqual(generatedViewModel.PollTitle, "Hello");
}
public ActionResult AddAnswers(CreateQuestionViewModel model)
{
try
{
// TODO: Add insert logic here しのぶ kek
String question = model.QuestionText;
String[] answers = model.RawAnswers.Split(';');
Response.Write(question);
//Response.Write(answers[0]);
Question temp = new Models.Question(question, new DateTime(2019, 7, 5), new DateTime(2019, 7, 6));
DataProvider.InsertQuestion(temp);
foreach (String answer in answers)
{
DataProvider.InsertOriginalAnswer(new OriginalAnswer(answer, temp));
}
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public CreateQuizViewModel CreateQuizViewModelFromQuizDTO(QuizDTO quiz)
{
CreateQuizViewModel viewModel = new CreateQuizViewModel();
viewModel.Id = quiz.Id;
viewModel.Description = quiz.Description;
viewModel.Title = quiz.Title;
viewModel.Path = quiz.FilePath;
int i = 0;
foreach (var q in quiz.Questions)
{
CreateQuestionViewModel questionViewModel = new CreateQuestionViewModel();
questionViewModel.Question = q.Question;
int j = 0;
foreach (var a in quiz.Questions[i].Answers)
{
CreateAnswerViewModel answerViewModel = new CreateAnswerViewModel();
questionViewModel.Answers.Add(answerViewModel);
questionViewModel.Answers[j].Answer = a.Answer;
questionViewModel.Answers[j].isCorrect = a.isCorrect;
j++;
}
i++;
}
return(viewModel);
}
public ActionResult Create(CreateQuestionViewModel viewmodel)
{
Poll poll = db.Polls.Find(viewmodel.PollID);
ICollection <Answer> Answers = new List <Answer> {
};
foreach (string answerText in viewmodel.Answers)
{
Answers.Add(new Answer {
Text = answerText
});
}
if (ModelState.IsValid)
{
Question question = new Question
{
Text = viewmodel.QuestionText,
Answers = Answers,
PollID = poll.ID
};
db.Questions.Add(question);
db.SaveChanges();
return(RedirectToAction("Edit", "Polls", new { id = poll.ID }));
}
return(View(viewmodel));
}
public IActionResult AddQuestion(int quizId)
{
var quiz = _context.Quizes
.Include(q => q.Questions)
.ThenInclude(qw => qw.Answers)
.SingleOrDefault(row => row.Id == quizId);
if (quiz == null)
{
return(RedirectToAction(nameof(Error)));
}
string quizName = quiz.Name;
var newModel = new CreateQuestionViewModel
{
QuizId = quizId,
QuizName = quizName,
Answers = new List <AnswerViewModel>
{
new AnswerViewModel(),
new AnswerViewModel(),
new AnswerViewModel()
}
};
return(View(newModel));
}
public ActionResult CreateQuestion(CreateQuestionViewModel model)
{
if (!ModelState.IsValid)
{
return(View("CreateQuestion", model));
}
Human human = _context.Humen.Find(model.humanId);
Question question = new Question()
{
QuestNumber = model.Number,
MainQuestion = model.MainQuestion,
Answer1 = model.Answer1,
Answer2 = model.Answer2,
Answer3 = model.Answer3,
Answer4 = model.Answer4,
CorrectAns = model.CorrectAns,
human = human
};
_context.Questions.Add(question);
_context.SaveChanges();
return(RedirectToAction("CreateQuestion", "CreateQuestion", new { id = model.humanId }));
}
public ActionResult AddQuestion(CreateQuestionViewModel model, FormCollection form)
{
//return Content(Convert.ToInt32(form["selectC"]).ToString());
if (ModelState.IsValid)
{
try
{
TestQuestion q = new TestQuestion()
{
QuestionContent = model.questionArea,
TestTypeID = model.TestTypeID,
modifyUser = User.Identity.Name,
modifyDateTime = DateTime.Now
};
TestAnswer a1 = new TestAnswer()
{
AnswerContent = model.answerA,
TestQuestion = q,
AnswerProperty = (model.answerRight == 1)? true :false
};
TestAnswer a2 = new TestAnswer()
{
AnswerContent = model.answerB,
TestQuestion = q,
AnswerProperty = (model.answerRight == 2) ? true : false
};
TestAnswer a3 = new TestAnswer()
{
AnswerContent = model.answerC,
TestQuestion = q,
AnswerProperty = (model.answerRight == 3) ? true : false
};
TestAnswer a4 = new TestAnswer()
{
AnswerContent = model.answerD,
TestQuestion = q,
AnswerProperty = (model.answerRight == 4) ? true : false
};
offlineDB.TestQuestion.Add(q);
offlineDB.TestAnswer.Add(a1);
offlineDB.TestAnswer.Add(a2);
offlineDB.TestAnswer.Add(a3);
offlineDB.TestAnswer.Add(a4);
offlineDB.SaveChanges();
return(RedirectToAction("Index"));
}
catch
{
ModelState.AddModelError("", "出现错误");
ViewBag.Store_System = new SelectList(offlineDB.TestType, "Id", "CustomName");
return(View(model));
}
}
else
{
ModelState.AddModelError("", "出现错误");
ViewBag.Store_System = new SelectList(offlineDB.TestType, "Id", "CustomName");
return(View(model));
}
}
public ActionResult AddQuestion()
{
CreateQuestionViewModel model = new CreateQuestionViewModel();
ViewBag.Store_System = new SelectList(offlineDB.TestType, "Id", "CustomName");
return(View(model));
}
public async Task <IActionResult> Create(CreateQuestionViewModel model)
{
if (ModelState.IsValid)
{
await SendQuestionToApi(model.Question);
}
return(RedirectToAction("Index"));
}
public void Init()
{
ListOfCourses = courseService.GetCourses();
QuestionTypeDropDown.ItemsSource = Enum.GetValues(typeof(QuestionType));
GradeLevelDropDown.ItemsSource = Enum.GetValues(typeof(GradeLevel));
viewModel = new CreateQuestionViewModel();
}
public IActionResult CreateQuestion(CreateQuestionViewModel cqvm)
{
if (ModelState.IsValid)
{
_db.GetCollection <Question>("questions").Insert(cqvm.Question);
RedirectToAction("Index");
}
return(View(cqvm));
}
public IActionResult Create()
{
var viewModel = new CreateQuestionViewModel
{
Referer = Request.Headers["Referer"].ToString()
};
return(View(viewModel));
}
public IActionResult Create()
{
var viewModel = new CreateQuestionViewModel
{
Faculties = this._facultyService.GetAll().ToList(),
};
return(this.View(viewModel));
}
public IActionResult Create(CreateQuestionViewModel vm)
{
var question = questionRepository.getAll()
.Where(x => x.Title.ToLower().Contains(vm.Title))
.FirstOrDefault();
if (question != null)
{
ModelState.AddModelError("errors", "ასეთი კითხვა უკვე არსებობს");
var tests = testRepository.getAll();
return(View(tests));
}
question = new Question()
{
TestId = vm.TestId,
Title = vm.Title,
Score = vm.Score
};
questionRepository.Add(question);
var questionId = questionRepository.getAll()
.FirstOrDefault(x => x.Title.Equals(question.Title)).Id;
List <Answer> answers = new List <Answer>();
for (int i = 0; i < vm.Titles.Length; i++)
{
int find = 0;
foreach (var index in vm.Corrects)
{
if (index == i)
{
find = 1 - find;
break;
}
}
Answer answer = new Answer
{
QuestionId = questionId,
Title = vm.Titles[i],
Correct = find
};
answers.Add(answer);
}
foreach (var answer in answers)
{
answerRepository.Add(answer);
}
return(RedirectToAction("Index", "Home"));
}
public IActionResult Create()
{
CreateQuestionViewModel model = new CreateQuestionViewModel
{
CategoriesItems = this.listsService.GetAllCategoriesAsSelectList(),
DifficultsItems = this.listsService.GetAllDifficultsAsSelectList(),
StagesItems = this.listsService.GetAllStagesAsSelectList(),
};
return(this.View(model));
}
public async Task <IActionResult> Create(CreateQuestionViewModel viewModel)
{
if (!this.ModelState.IsValid)
{
return(this.View(viewModel));
}
await this.questionsService.CreateQuestionAsync(viewModel);
return(this.RedirectToAction("Details", "Exams", new { id = viewModel.ExamId }));
}
public ActionResult CreateQuestion()
{
var model = new CreateQuestionViewModel
{
PropertyParameter = new AnswerPropertyModel(),
ClassData = new SelectList(this.ClassData, "Course_ID", "Course_Name"),
HW_ExamData = null,
sparatestring = App_Start.constants.segmentsCut
};
return(View(model));
}
// GET: Questions/Create
public ActionResult Create()
{
CreateQuestionViewModel viewModel = new CreateQuestionViewModel()
{
Categories = _context.Categories.Select(x => new SelectListItem()
{
Value = x.Id.ToString(), Text = x.Name
})
};
return(View(viewModel));
}
public static QuestionDTO Map(CreateQuestionViewModel viewmodel)
{
QuestionDTO dto = new QuestionDTO
{
Question = viewmodel.Question
};
foreach (var answer in viewmodel.Answers)
{
dto.Answers.Add(DTOMapper.Map(answer));
}
return(dto);
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
quizParams = (QuizParams)e.Parameter; // get parameter
Frame rootFrame = Window.Current.Content as Frame;
if (quizParams != null)
{
ViewModel = new CreateQuestionViewModel();
}
ViewModel.Initialize(quizParams);
DataContext = ViewModel;
}
public async Task <ActionResult> Create(CreateQuestionViewModel viewModel)
{
if (ModelState.IsValid)
{
Category selectedCategory = await db.Categories.SingleAsync(x => x.Id == viewModel.SelectedCategory);
db.Questions.Add(new Question(viewModel.Title, viewModel.Text, selectedCategory));
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(viewModel));
}
public async Task <ActionResult> Edit(Guid id, CreateQuestionViewModel viewModel)
{
if (ModelState.IsValid)
{
var question = await _context.Questions.FindAsync(id);
Mapper.Map(viewModel, question);
_context.Update(question);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(viewModel));
}
public IActionResult AddQuestion(CreateQuestionViewModel model)
{
var question = new TestingQuestion
{
Text = model.Text,
AnswerOptions = model.AnswerOption,
CorrectAnswer = model.CorrectAnswer,
TestId = model.TestId
};
_context.Questions.Add(question);
_context.SaveChanges();
return(RedirectToRoute("testlist"));
}
private static void SetupQuestions(AddQuizQuestionsViewModel viewModel)
{
for (int i = 0; i < 10; i++)
{
CreateQuestionViewModel q = new CreateQuestionViewModel();
List <CreateAnswerViewModel> answers = new List <CreateAnswerViewModel>();
for (int j = 0; j < 4; j++)
{
CreateAnswerViewModel a = new CreateAnswerViewModel();
answers.Add(a);
}
q.Answers = answers;
viewModel.Questions.Add(q);
}
}
public IActionResult Create(CreateQuestionViewModel questionVM)
{
if (!ModelState.IsValid)
{
return(View(questionVM));
}
_questionRepository.Create(questionVM.Question);
if (!String.IsNullOrEmpty(questionVM.Referer))
{
return(Redirect(questionVM.Referer));
}
return(RedirectToAction("List"));
}
