public QuizQuestion ToQuestion(Author author)
{
var solutionText = Children.Count > 0 ? Children[0].Content : null;
var correctLetter = "";
if (!string.IsNullOrWhiteSpace(solutionText))
{
var match = Regex.Match(solutionText, "Odpowiedź[:]? ([A-Z])", RegexOptions.Multiline);
correctLetter = match.Groups[1].Value.ToLower();
}
var matchGroup = Regex.Matches(Content, @"^([a-zA-Z])[\.\)] (.*)$", RegexOptions.Multiline);
var answers = new List<QuizAnswer>();
foreach (Match m in matchGroup)
{
var isCorrect = m.Groups[1].Value.ToLower() == correctLetter;
var answer = new QuizAnswer
{Content = m.Groups[2].Value, IsCorrect = isCorrect, Author = author};
answers.Add(answer);
}
Content = Regex.Replace(Content, @"^([a-zA-Z])[\.\)] (.*)$", "", RegexOptions.Multiline);
var solution = Children.Count > 0 ? Children[0].Content.Trim() : null;
if (!string.IsNullOrWhiteSpace(solution))
solution = Regex.Replace(solution, @"^Odpowiedź[:]? [A-Z]$", "", RegexOptions.Multiline);
var question = new QuizQuestion
{Content = Content.Trim(), Solution = solution, Answers = answers, Author = author};
return question;
}
public int createQuizAnswer(QuizAnswer qa) // Insert.
{
SqlConnection conn = null;
int toReturn = 0;
try
{
conn = new SqlConnection();
conn.ConnectionString = ConfigurationManager.ConnectionStrings["DBConnectionString"].ConnectionString;
conn.Open();
SqlCommand comm = new SqlCommand();
comm.Connection = conn;
comm.CommandText = "Insert into [QuizAnswer] (quizQuestionID, answer) OUTPUT INSERTED.quizAnswerID VALUES (@quizQuestionID, @answer)";
comm.Parameters.AddWithValue("@quizQuestionID", qa.getQuizQuestion().getQuizQuestionID());
comm.Parameters.AddWithValue("@answer", qa.getAnswer());
toReturn = (Int32)comm.ExecuteScalar();
}
catch (SqlException ex)
{
throw ex;
}
finally
{
conn.Close();
}
return(toReturn);
}
public QuizAnswer getCorrectQuizAnswerByID(int quizAnswerID)
{
SqlConnection conn = new SqlConnection();
QuizAnswer toReturn = null;
try
{
conn = new SqlConnection();
string connstr = ConfigurationManager.ConnectionStrings["DBConnectionString"].ToString();
conn.ConnectionString = connstr;
conn.Open();
SqlCommand comm = new SqlCommand();
comm.Connection = conn;
comm.CommandText = "select * from [QuizAnswer] where quizAnswerID=@quizAnswerID";
comm.Parameters.AddWithValue("@quizAnswerID", quizAnswerID);
SqlDataReader dr = comm.ExecuteReader();
while (dr.Read())
{
toReturn = new QuizAnswer();
toReturn.setAnswer((string)dr["answer"]);
}
dr.Close();
}
catch (SqlException ex)
{
throw ex;
}
finally
{
conn.Close();
}
return(toReturn);
}
public bool UpdateQuizAnswer(QuizAnswer quizAnswer, out string message)
{
if (quizAnswer == null || quizAnswer.Sid == 0)
{
message = Constants.ValueIsEmpty(Constants.QuizAnswer);
return(false);
}
try
{
using (var unitOfWork = new UnitOfWork(new ActiveLearningContext()))
{
var quitAnswerToUpdate = unitOfWork.QuizAnswers.Get(quizAnswer.Sid);
Util.CopyNonNullProperty(quizAnswer, quitAnswerToUpdate);
quitAnswerToUpdate.UpdateDT = DateTime.Now;
using (TransactionScope scope = new TransactionScope())
{
unitOfWork.Complete();
scope.Complete();
}
message = string.Empty;
return(true);
}
}
catch (Exception ex)
{
ExceptionLog(ex);
message = Constants.OperationFailedDuringUpdatingValue(Constants.QuizAnswer);
return(false);
}
}
public ActionResult Index(FormCollection collection)
{
var usrid = User.Identity.GetUserId();
var time = DateTime.Now;
foreach (var item in collection.AllKeys)
{
if (item.StartsWith("radio_"))
{
var ans = int.Parse(collection[item].Split('_')[1]);
var qns = int.Parse(item.Split('_')[1]);
var userans = db.QuizAnswers.Where(u => u.UserProfile.Id == usrid && u.QuestionID == qns).SingleOrDefault();
if (userans == null)
{
userans = new QuizAnswer();
userans.UserProfile = db.Users.Find(usrid);
userans.QuestionID = qns;
userans.Answer = ans;
userans.AnswerDate = time;
db.QuizAnswers.Add(userans);
db.SaveChanges();
}
}
}
return(RedirectToAction("Result"));
}
public async Task <bool> StoreAsync(QuizAnswer answer)
{
try
{
using (var unitOfWork = new UnitOfWork(new ActiveLearningContext()))
{
answer.CreateDT = DateTime.Now;
unitOfWork.QuizAnswers.Add(answer);
await unitOfWork.CompleteAsync();
var selectedOption = await unitOfWork.QuizOptions.SingleOrDefaultAsync(o => o.Sid == answer.QuizOptionSid && o.QuizQuestionSid == answer.QuizQuestionSid && !o.DeleteDT.HasValue);
return(selectedOption.IsCorrect);
}
}
catch (Exception ex)
{
ExceptionLog(ex);
return(false);
}
//this.db.QuizAnswers.Add(answer);
//await this.db.SaveChangesAsync();
//var selectedOption = await this.db.QuizOptions.FirstOrDefaultAsync(o => o.Sid == answer.QuizOptionSid
// && o.QuizQuestionSid == answer.QuizQuestionSid);
}
public async Task <ActionResult <QuizItem> > PostQuizItem([FromBody] QuizItem quizItem)
{
_context.QuizItem.Add(quizItem);
await _context.SaveChangesAsync();
if (quizItem.Answers != null && quizItem.Answers.Any())
{
foreach (var item in quizItem.Answers)
{
var answer = new QuizAnswer
{
Answer = item,
QuizItemId = quizItem.QuizItemId
};
_context.QuizAnswers.Add(answer);
}
await _context.SaveChangesAsync();
}
if (quizItem.Options != null && quizItem.Options.Any())
{
foreach (var item in quizItem.Options)
{
var option = new QuizOption
{
Option = item,
QuizItemId = quizItem.QuizItemId
};
_context.QuizOptions.Add(option);
}
await _context.SaveChangesAsync();
}
return(CreatedAtAction("GetQuizItem", new { id = quizItem.QuizItemId }, quizItem));
}
public List <QuizAnswer> getAllQuizAnswersByQuizQuestionID(int quizQuestionID)
{
SqlConnection conn = new SqlConnection();
List <QuizAnswer> toReturn = new List <QuizAnswer>();
try
{
conn = new SqlConnection();
string connstr = ConfigurationManager.ConnectionStrings["DBConnectionString"].ToString();
conn.ConnectionString = connstr;
conn.Open();
SqlCommand comm = new SqlCommand();
comm.Connection = conn;
comm.CommandText = "select * from [QuizAnswer] where quizQuestionID=@quizQuestionID";
comm.Parameters.AddWithValue("@quizQuestionID", quizQuestionID);
SqlDataReader dr = comm.ExecuteReader();
while (dr.Read())
{
QuizAnswer qa = new QuizAnswer();
qa.setQuizAnswerID((int)dr["quizAnswerID"]);
qa.setAnswer((string)dr["answer"]);
toReturn.Add(qa);
}
dr.Close();
}
catch (SqlException ex)
{
throw ex;
}
finally
{
conn.Close();
}
return(toReturn);
}
public ActionResult DeleteConfirmed(int id)
{
QuizAnswer quizAnswer = db.QuizAnswers.Find(id);
db.QuizAnswers.Remove(quizAnswer);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public static QuizAnswerViewModel Parse(QuizAnswer quizAnswer)
{
return(new QuizAnswerViewModel()
{
Id = quizAnswer.Id,
Answer = quizAnswer.Answer,
QuizQuestionId = quizAnswer.QuizQuestionId
});
}
public ActionResult Create([FromBody] QuizAnswerViewModel vm)
{
var c = new QuizAnswer(vm.Answer, vm.QuizQuestionId);
var res = _bo.Create(c);
var code = res.Success ? HttpStatusCode.OK : HttpStatusCode.InternalServerError;
return(new ObjectResult(code));
}
public bool DeleteQuizAnswer(QuizAnswer quizAnswer, out string message)
{
if (quizAnswer == null)
{
message = Constants.ValueIsEmpty(Constants.QuizAnswer);
return(false);
}
return(DeleteQuizAnswer(quizAnswer.Sid, out message));
}
public async Task <IActionResult> PutQuizItem([FromBody] QuizItem quizItem)
{
var dbItem = _context.QuizItem.Find(quizItem.QuizItemId);
_context.Entry(dbItem).State = EntityState.Detached;
if (dbItem == null)
{
return(BadRequest());
}
_context.Entry(quizItem).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
if (quizItem.Answers != null && quizItem.Answers.Any())
{
var oldAnswers = _context.QuizAnswers.Where(a => a.QuizItemId == quizItem.QuizItemId);
_context.QuizAnswers.RemoveRange(oldAnswers);
_context.SaveChanges();
foreach (var item in quizItem.Answers)
{
var answer = new QuizAnswer
{
Answer = item,
QuizItemId = quizItem.QuizItemId
};
_context.QuizAnswers.Add(answer);
}
await _context.SaveChangesAsync();
}
if (quizItem.Options != null && quizItem.Options.Any())
{
var oldOptions = _context.QuizOptions.Where(a => a.QuizItemId == quizItem.QuizItemId);
_context.QuizOptions.RemoveRange(oldOptions);
_context.SaveChanges();
foreach (var item in quizItem.Options)
{
var option = new QuizOption
{
Option = item,
QuizItemId = quizItem.QuizItemId
};
_context.QuizOptions.Add(option);
}
await _context.SaveChangesAsync();
}
}
catch (DbUpdateConcurrencyException)
{
}
return(Ok("Updated successfully!"));
}
protected void btnNext_Click(object sender, EventArgs e)
{
if (rblAnswers.SelectedIndex != -1)
{
int quizID = Convert.ToInt32(Request.QueryString["id"]);
User currentUser = (User)Session["currentUser"];
//handle question counter
int counter = (int)Session["questionCounter"];
counter++;
lblQnNum.Text = counter.ToString();
Session["questionCounter"] = counter;
//handle remaining questions
List <QuizQuestion> remainingQuestions = (List <QuizQuestion>)Session["remainingQuestions"];
remainingQuestions.RemoveAt(0);
Session["remainingQuestions"] = remainingQuestions;
//handle current question and answer
QuizResultHistory currentAnswer = new QuizResultHistory();
QuizResultHistoryDAO qrhDAO = new QuizResultHistoryDAO();
QuizQuestionDAO qqDAO = new QuizQuestionDAO();
QuizQuestion currentQuestion = (QuizQuestion)Session["previousQuestion"];
QuizAnswer currentSelectedAnswer = new QuizAnswer(Convert.ToInt32(rblAnswers.SelectedValue), currentQuestion, rblAnswers.SelectedItem.Text);
int attempt = qrhDAO.getAttemptForQuiz(currentQuestion.getQuizQuestionID());
attempt++;
currentAnswer.setAttempt(attempt);
currentAnswer.setUserID(currentUser.getUserID());
currentAnswer.setQuestion(currentQuestion);
currentAnswer.setAnswer(currentSelectedAnswer);
currentAnswer.setQuizID(quizID);
List <QuizResultHistory> userAnswers = (List <QuizResultHistory>)Session["userAnswers"];
userAnswers.Add(currentAnswer);
Session["userAnswers"] = userAnswers;
if (remainingQuestions.Count > 0)
{
//handle displaying next qn
QuizQuestion nextQuestion = remainingQuestions[0];
Session["previousQuestion"] = nextQuestion;
QuizAnswerDAO qaDAO = new QuizAnswerDAO();
List <QuizAnswer> nextPossibleAnswers = qaDAO.getAllQuizAnswersByQuizQuestionID(nextQuestion.getQuizQuestionID());
lblQuestion.Text = nextQuestion.getQuestion();
rblAnswers.Items.Clear();
foreach (QuizAnswer qa in nextPossibleAnswers)
{
rblAnswers.Items.Add(new ListItem(qa.getAnswer(), qa.getQuizAnswerID().ToString()));
}
}
if (remainingQuestions.Count == 1)
{
btnFinish.Visible = true;
btnNext.Visible = false;
}
}
}
public async Task <ActionResult <QuizAnswer> > Get(int id)
{
QuizAnswer quizAnswerModel = await db.QuizAnswerModels.FirstOrDefaultAsync(x => x.Id == id);
if (quizAnswerModel == null)
{
return(NotFound());
}
return(quizAnswerModel);
}
public AnswerResult AnswerQuestion(QuizAnswer answer)
{
CurrentQuestion.TimeAnswered = DateTime.Now;
CurrentQuestion.AnsweredAnswer = CurrentQuestion.Answers.First(a => a.AnswerId == answer.AnswerId);
var duration = (int)(CurrentQuestion.TimeAnswered - CurrentQuestion.TimeAsked).TotalSeconds;
AskedQuestions.Add(CurrentQuestion);
CurrentQuestion = null;
return(new AnswerResult(answer.Correct, duration));
}
public void CreateAnswer(int questionId, string text, bool isCorrect)
{
var answer = new QuizAnswer
{
QuestionId = questionId,
Text = text,
IsCorrect = isCorrect
};
_quizAnswerRepository.Insert(answer);
}
// GET: QuizAnswers
public ActionResult Index(int sessionId, int questionId = 0, int direction = 1)
{
AskQuizQuestionViewModel newQuestion = new AskQuizQuestionViewModel();
if (questionId == 0)
{
newQuestion = GetFirstUnansweredQuestion(sessionId);
}
else
{
newQuestion = GetNextQuestion(sessionId, questionId, direction);
}
//use newQuestion to populate view for display.
//ERROR Something about coming through here the second time is causing a context error with QuizQuestion.
db.Entry(newQuestion.Question).Collection(q => q.Choices).Load();
EditQuizAnswerViewModel view = new EditQuizAnswerViewModel()
{
SessionId = sessionId,
QuestionId = newQuestion.Question.ID,
CurrentQuestionNum = newQuestion.CurrentQuestionNum,
TotalQuestions = quizQuestions.Count(),
QuestionText = newQuestion.Question.Text,
};
//Now see if the user has already supplied an answer.
string userId = User.Identity.GetUserId();
QuizAnswer quizAnswer = db.QuizAnswers.SingleOrDefault(ans => ans.QuestionID == view.QuestionId && ans.AnswererID == userId);
if (quizAnswer != null)
{
view.StudentAnswer = quizAnswer.Text;
}
//Using the stripped down QuizChoiceViewModel to remove the "IsCorrect" flag from the data
//sent to the viewe page.
ICollection <QuizChoiceViewModel> quizChoices = new List <QuizChoiceViewModel>();
foreach (var choice in newQuestion.Question.Choices)
{
QuizChoiceViewModel newChoice = new QuizChoiceViewModel()
{
ID = choice.ID,
Text = choice.Text
};
quizChoices.Add(newChoice);
}
view.QuestionChoices = quizChoices;
return(View(view));
}
public ActionResult Edit([Bind(Include = "ID,QuestionID,Text,AnswererID,IsCorrect")] QuizAnswer quizAnswer)
{
if (ModelState.IsValid)
{
db.Entry(quizAnswer).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.AnswererID = new SelectList(db.Users, "Id", "Email", quizAnswer.AnswererID);
ViewBag.QuestionID = new SelectList(db.QuizQuestions, "ID", "Text", quizAnswer.QuestionID);
return(View(quizAnswer));
}
public async Task <ActionResult <QuizAnswer> > Post(QuizAnswer item)
{
if (item == null)
{
return(BadRequest());
}
db.QuizAnswerModels.Add(item);
await db.SaveChangesAsync();
return(Ok(item));
}
public JsonResult Post([FromBody] QuizAnswer answer)
{
//if artist and title are the same as posted, return true
if (answer.Artist.Equals(SongReturned.Artist, StringComparison.CurrentCultureIgnoreCase) && answer.Title.Equals(SongReturned.Title, StringComparison.CurrentCultureIgnoreCase))
{
return(Json(new { isCorrect = true }));
}
else
{
return(Json(new { isCorrect = false }));
}
}
// Add answer
public async Task <QuizAnswer> AddAnswer(QuizAnswer item)
{
HttpClient client = GetClient();
var response = await client.PostAsync(Url + "quizanswer/", new StringContent(JsonSerializer.Serialize(item), Encoding.UTF8, "application/json"));
if (response.StatusCode != HttpStatusCode.OK)
{
return(null);
}
return(JsonSerializer.Deserialize <QuizAnswer>(await response.Content.ReadAsStringAsync(), options));
}
public void CheckAnswer(QuizAnswer answer)
{
QuizBrain.answers thisAnswer = answer.myAnswer;
if (thisAnswer == correctAnswer)
{
QuizBrain.instance.CheckAnswer(true);
}
else
{
QuizBrain.instance.CheckAnswer(false);
}
}
public void Answer(int questionId, int answer, int userId)
{
QuizAnswer ans = new QuizAnswer();
ans.QuestionID = questionId;
ans.ChoiceSelected = answer;
ans.UserID = userId;
ans.IsCorrect = isAnwerCorrect(questionId, answer);
ans.ObsInd = "N";
_uow.QuizAnswerRepository.Insert(ans);
_uow.Save();
}
public bool Create(QuizAnswer quizQuestion)
{
try
{
db.QuizAnswers.Add(quizQuestion);
db.SaveChanges();
return(true);
}
catch (Exception)
{
return(true);
}
}
public ActionResult CreateQuestion(QuizQuestionModel model)
{
var numberOfAnswers = model.Answers.Where(a => !String.IsNullOrWhiteSpace(a.Text)).Count();
if (numberOfAnswers < 2)
{
ModelState.AddModelError("", "Question requires two or more answers");
}
if (model.SelectedAnswer + 1 > numberOfAnswers)
{
ModelState.AddModelError("", "The selected answer does not have a corresponding answer");
}
if (!ModelState.IsValid)
{
return(View(model));
}
// Set the correct answer
model.Answers[model.SelectedAnswer].IsCorrect = true;
model.SelectedAnswer = 0;
var answers = new List <QuizAnswer>();
foreach (var answer in model.Answers)
{
if (!String.IsNullOrWhiteSpace(answer.Text))
{
var item = new QuizAnswer
{
IsCorrect = answer.IsCorrect,
Text = answer.Text
};
answers.Add(item);
}
}
var questionId = _quizService.CreateQuestion(model.QuizId, model.Question, model.Points, answers);
for (int i = 0; i < answers.Count; i++)
{
//activity log
_studentActivityService.InsertActivity("Quiz.Create.Question.Answer", "ActivityLog.Quiz.Create.Question.Answer");
}
//activity log
_studentActivityService.InsertActivity("Quiz.Create.Question", "ActivityLog.Quiz.Create.Question");
return(RedirectToAction("Edit", new { id = model.QuizId }));
}
// GET: QuizAnswers/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
QuizAnswer quizAnswer = db.QuizAnswers.Find(id);
if (quizAnswer == null)
{
return(HttpNotFound());
}
return(View(quizAnswer));
}
public async Task <ActionResult> Post([FromBody] QuizAnswer songToAdd)
{
int songID = await _dbDataService.GetItemCount <Song>();
Song newSong = new Song();
newSong.Artist = songToAdd.Artist;
newSong.Title = songToAdd.Title;
newSong.SongID = songID + 1;
_dbDataService.PostToDB(newSong);
return(Json(new { added = true }));
}
public async Task <ActionResult <QuizAnswer> > Delete(int id)
{
QuizAnswer quizAnswerModel = db.QuizAnswerModels.FirstOrDefault(x => x.Id == id);
if (quizAnswerModel == null)
{
return(NotFound());
}
db.QuizAnswerModels.Remove(quizAnswerModel);
await db.SaveChangesAsync();
return(Ok(quizAnswerModel));
}
public async Task <ActionResult <MinQuestion> > PostQuizQuestions([FromBody] MinQuestion Question)
{
// Confirm we have a valid user and token
if (await Question.APIUserTokenCheckAsync(_context) == false)
{
return(Unauthorized());
}
// Now let's create an empty question and put only our valid properties onto it.
var emptyQuestion = new QuizQuestion
{
Created = DateTime.Now,
Modified = DateTime.Now,
BibleId = Question.BibleId,
Points = Question.Points,
BookNumber = Question.BookNumber,
Chapter = Question.Chapter,
StartVerse = Question.StartVerse,
EndVerse = Question.EndVerse,
Question = Question.Question,
Owner = Question.Owner,
Source = Question.Source
};
_context.QuizQuestions.Add(emptyQuestion);
// now we need to add the Answer if there are any
foreach (string AnswerString in Question.Answers)
{
if (AnswerString.Length > 0)
{
QuizAnswer Answer = new QuizAnswer
{
Created = DateTime.Now,
Modified = DateTime.Now,
Question = emptyQuestion,
Answer = AnswerString,
IsPrimary = true
};
_context.QuizAnswers.Add(Answer);
// Register that this question has an answer.
emptyQuestion.IsAnswered = true;
}
}
await _context.SaveChangesAsync();
MinQuestion returnQuestion = new MinQuestion(emptyQuestion);
return(CreatedAtAction("GetQuizQuestion", new { id = returnQuestion.Id }, returnQuestion));
}