/// <summary>
/// Removes a Quiz by Id and any associated objects. Updates log.
/// </summary>
/// <param name="id">The id of the quiz</param>
public void DeleteQuiz(int id)
{
_logger.LogInformation($"Deleting Quiz with ID {id}");
Entities.Quiz quiz = _dbContext.Quiz.Find(id);
_dbContext.Remove(quiz);
_dbContext.SaveChanges();
}
public override void CommandBody(SqlCommand cmd)
{
cmd.CommandText = StoredProcedureName;
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add("@CreatorId", SqlDbType.BigInt).Value = _userId;
using (SqlDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
Entities.Quiz item = reader.GetSearchQuiz();
_result.Quizzes.Add(item);
}
reader.NextResult();
List <Tuple <long, long> > restrictions = new List <Tuple <long, long> >();
while (reader.Read())
{
Tuple <long, long> item = reader.GetRestrictionEntry();
restrictions.Add(item);
}
_result.Quizzes.ForEach(q => q.Targets = restrictions.Where(t => t.Item1 == q.Id).Select(t => t.Item2).ToList());
}
}
public async Task InsertAsync(Quiz quiz)
{
var quizToAdd =
new Entities.Quiz
{
Name = quiz.Name,
CreationTimestamp = quiz.CreationTimestamp,
UserId = quiz.UserId,
IsPublic = quiz.IsPublic,
TopicId = quiz.TopicId,
ImageUrl = quiz.ImageUrl
};
var questions =
quiz.Questions
.Select(question => new Entities.Question
{
Text = question.Text,
IsMultipleChoice = question.IsMultipleChoice,
QuizId = quiz.Id
}).ToList();
var answers =
quiz.Questions
.SelectMany(question => question.Answers.Select(answer => new
{
QuestionId = question.Id,
Answer = answer
}))
.Select(answer => new Entities.Answer
{
Text = answer.Answer.Text,
IsCorrect = answer.Answer.IsCorrect,
QuestionId = answer.QuestionId
}).ToList();
using (var transaction = _context.Database.BeginTransaction())
{
try {
await _context.Quizzes
.AddAsync(quizToAdd)
.ConfigureAwait(false);
await _context.Questions
.AddRangeAsync(questions)
.ConfigureAwait(false);
await _context.Answers
.AddRangeAsync(answers)
.ConfigureAwait(false);
transaction.Commit();
}
catch (Exception)
{
transaction.Dispose();
}
}
}
public string deleteOldLeftOverQuestions(Entities.Quiz _updatedQuiz)
{
string _deletionResult = "Questions Deleted Successfully";
try
{
List <FarmworkersWebAPI.Entities.QuizQuestion> _oldQuestions =
_context.QuizQuestions.
Where(q => q.QuizID.Equals(_updatedQuiz.QuizID) &&
q.QuizVersion.Equals(_updatedQuiz.QuizVersion) &&
q.IsActive.Equals("1")).ToList();
if (_oldQuestions.Count > _updatedQuiz.QuizQuestions.Count && _updatedQuiz.QuizQuestions.Count != 0)
{
for (int i = _updatedQuiz.QuizQuestions.Count + 1; i <= _oldQuestions.Count; i++)
{
Entities.QuizQuestion _questionToDelete = new Entities.QuizQuestion();
FarmworkersWebAPI.Entities.QuizQuestion original = _context.QuizQuestions.
Where(q => q.QuizID.Equals(_updatedQuiz.QuizID) &&
q.QuizVersion.Equals(_updatedQuiz.QuizVersion) &&
q.QuestionID.Equals(i)).FirstOrDefault();
_questionToDelete.QuizID = _updatedQuiz.QuizID;
_questionToDelete.QuizVersion = _updatedQuiz.QuizVersion;
_questionToDelete.QuestionID = i;
_questionToDelete.Question = original.Question;
_questionToDelete.IsActive = "0";
_questionToDelete.DateModified = original.DateModified;
_context.Entry(original).CurrentValues.SetValues(_questionToDelete);
_context.SaveChanges();
}
}
}
catch (Exception ex)
{
return(InternalServerError(ex).ToString());
}
return(_deletionResult);
}
public IHttpActionResult EFInsertQuiz(ViewModels.QuizForm _quizInformation)
{
_context.Configuration.ProxyCreationEnabled = false;
Entities.Quiz _quizReceived = new Entities.Quiz();
Entities.Quiz _quiz = new Entities.Quiz();
try
{
//The incoming format coming from the Front-End is changed so it is adjusted to the Format in the data base.
_quizReceived = EFhandleIncomingQuizFormat(_quizInformation);
_quiz = _context.Quizs.Add(_quizReceived);
_context.SaveChanges();
if (_quizInformation.RelatedSource != null)
{
Entities.QuizEducationalContent _educationalContentLinkToQuiz = new Entities.QuizEducationalContent();
_educationalContentLinkToQuiz.QuizID = _quiz.QuizID;
_educationalContentLinkToQuiz.QuizVersion = _quiz.QuizVersion;
_educationalContentLinkToQuiz.EducationalContentID = int.Parse(_quizInformation.RelatedSource);
int _educationalContentID = int.Parse(_quizInformation.RelatedSource);
_context.QuizEducationalContents.Add(_educationalContentLinkToQuiz);
_context.SaveChanges();
_quiz.EducationalContents = _context.EducationalContents.Where(ec => ec.IDEducationalContent.Equals(_educationalContentID)).ToList();
}
return(Ok(_quiz));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
/// <summary>
/// Add a quiz, including any associated objects. Updates log.
/// </summary>
/// <param name="quiz">The quiz</param>
public async Task <int> CreateQuiz(Library.Models.Quiz quiz)
{
if (quiz is null)
{
throw new ArgumentNullException(nameof(quiz));
}
_logger.LogInformation($"Adding quiz");
Entities.Quiz entity = Mapper.Map(quiz);
entity.Time = DateTime.Now;
_dbContext.Add(entity);
await _dbContext.SaveChangesAsync();
//update user completed quizzes
Entities.User userEntity = _dbContext.User.Where(u => u.UserId == entity.UserId).First();
if (userEntity != null)
{
userEntity.CompletedQuizzes += 1;
await _dbContext.SaveChangesAsync();
}
return(quiz.QuizId);
}
public async Task <bool> EditQuiz(Library.Models.Quiz quiz)
{
try
{
if (quiz == null)
{
throw new ArgumentException();
}
Entities.Quiz existing = await _dbContext.Quiz.FindAsync(quiz.QuizId);
Entities.Quiz newQuiz = Mapper.Map(quiz);
_dbContext.Entry(existing).CurrentValues.SetValues(newQuiz);
_dbContext.SaveChanges();
return(true);
}
catch (Exception ex)
{
_logger.LogError(ex.ToString());
return(false);
}
}
public IHttpActionResult EFupdateQuiz(ViewModels.QuizForm _quizInformation)
{
//The incoming format coming from the Front-End is changed so it is adjusted to the Format in the data base.
Entities.Quiz _updatedQuiz = EFhandleIncomingQuizFormat(_quizInformation);
if (_updatedQuiz.QuizID < 0)
{
return(Ok("Quiz ID can not be negative"));
}
if (_updatedQuiz.QuizID == 0)
{
return(Ok("Quiz ID Not Specified"));
}
_context.Configuration.ProxyCreationEnabled = false;
try
{
FarmworkersWebAPI.Entities.Quiz original = _context.Quizs.
Where(q => q.QuizID.Equals(_updatedQuiz.QuizID) && q.QuizVersion.Equals(_updatedQuiz.QuizVersion)).FirstOrDefault();
//***NOT Entity Framework
Quiz _updated = new Quiz();
///***********************
if (original != null)
{
//Update Quiz Base Information
_context.Entry(original).CurrentValues.SetValues(_updatedQuiz);
_context.SaveChanges();
//Determine if there are less questions in this quiz update than in the previous version
//If there are less questions in the new update, the ones left over from the previous version
//will be deleted
string _deletionResult = deleteOldLeftOverQuestions(_updatedQuiz);
if (_deletionResult != "Questions Deleted Successfully")
{
return(Ok(_deletionResult));
}
foreach (FarmworkersWebAPI.Entities.QuizQuestion _question in _updatedQuiz.QuizQuestions)
{
string _updateResult = EFupdateQuizQuestion(_question);
if (_updateResult != "Question Updated Successfully")
{
return(Ok(_updateResult));
}
}
_context.SaveChanges();
if (_quizInformation.RelatedSource != null)
{
Entities.QuizEducationalContent _updatedEducationalContentLinkToQuiz = new Entities.QuizEducationalContent();
Entities.QuizEducationalContent _originalEducationalContentLinkToQuiz = new Entities.QuizEducationalContent();
_originalEducationalContentLinkToQuiz = _context.QuizEducationalContents.Where(qec => qec.QuizID.Equals(_quizInformation.QuizID) && qec.QuizVersion.Equals(_quizInformation.Quizversion)).FirstOrDefault();
_updatedEducationalContentLinkToQuiz.QuizID = _quizInformation.QuizID;
_updatedEducationalContentLinkToQuiz.QuizVersion = _quizInformation.Quizversion;
_updatedEducationalContentLinkToQuiz.EducationalContentID = int.Parse(_quizInformation.RelatedSource);
if (_originalEducationalContentLinkToQuiz != null)
{
_context.Entry(_originalEducationalContentLinkToQuiz).CurrentValues.SetValues(_updatedEducationalContentLinkToQuiz);
}
else
{
_context.QuizEducationalContents.Add(_updatedEducationalContentLinkToQuiz);
_context.SaveChanges();
}
}
//***NOT Entity Framework (Because Only Need Questions Marked as Activo, not InActive).
_updated = _updated.readQuizByIDAndVersion(_updatedQuiz.QuizID.ToString(), _updatedQuiz.QuizVersion.ToString());
///***********************
return(Ok(_updated));
}
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
return(Ok("Quiz Not Found"));
}
//Utility Function
public Entities.Quiz EFhandleIncomingQuizFormat(ViewModels.QuizForm _quiz)
{
Entities.Quiz _quizCorrectFormat = new Entities.Quiz();
Entities.QuizQuestion _quizQuestionCorrectFormat = new Entities.QuizQuestion();
Entities.QuizAnswer _quizAnswerCorrectFormat = new Entities.QuizAnswer();
List <Entities.QuizQuestion> _quizQuestionsLISTCorrectFormat = new List <Entities.QuizQuestion>();
List <Entities.QuizAnswer> _questionAnswersLISTCorrectFormat = new List <Entities.QuizAnswer>();
try
{
_quizCorrectFormat.QuizID = _quiz.QuizID;
_quizCorrectFormat.QuizVersion = _quiz.Quizversion;
_quizCorrectFormat.QuizName = _quiz.Name;
_quizCorrectFormat.QuizDescription = _quiz.QuizDescription;
_quizCorrectFormat.Scale = _quiz.Scale;
_quizCorrectFormat.IsActive = _quiz.Status;
_quizCorrectFormat.DateModified = _quiz.LastModifiedDate;
foreach (ViewModels.QuizQuestionForm _question in _quiz.QuizQuestions)
{
_quizQuestionCorrectFormat = new Entities.QuizQuestion();
_quizQuestionCorrectFormat.QuizID = _quiz.QuizID;
_quizQuestionCorrectFormat.QuizVersion = _quiz.Quizversion;
_quizQuestionCorrectFormat.QuestionID = _question.QuestionID;
_quizQuestionCorrectFormat.Question = _question.Question;
_quizQuestionCorrectFormat.IsActive = "1";
_quizQuestionCorrectFormat.DateModified = _quiz.LastModifiedDate;
string _correctAnswer = _question.CorrectA;
_questionAnswersLISTCorrectFormat = new List <Entities.QuizAnswer>();
foreach (ViewModels.QuizAnswerForm _answer in _question.Answers)
{
_quizAnswerCorrectFormat = new Entities.QuizAnswer();
_quizAnswerCorrectFormat.QuizID = _quiz.QuizID;
_quizAnswerCorrectFormat.QuizVersion = _quiz.Quizversion;
_quizAnswerCorrectFormat.QuestionID = _question.QuestionID;
_quizAnswerCorrectFormat.AnswerID = _answer.AnswerID;
_quizAnswerCorrectFormat.Answer = _answer.Answer;
_quizAnswerCorrectFormat.IsCorrect = _answer.AnswerID.ToString() == _question.CorrectA ? 1 : 0;
_quizAnswerCorrectFormat.IsActive = "1";
_quizAnswerCorrectFormat.DateModified = _quiz.LastModifiedDate;
//Add Answer to Answer List
_questionAnswersLISTCorrectFormat.Add(_quizAnswerCorrectFormat);
}
//Add List of Answers to a Single Question
_quizQuestionCorrectFormat.QuizAnswers = _questionAnswersLISTCorrectFormat;
//Add Complete Question with Answers, to the Question List
_quizQuestionsLISTCorrectFormat.Add(_quizQuestionCorrectFormat);
}
_quizCorrectFormat.QuizQuestions = _quizQuestionsLISTCorrectFormat;
}
catch (Exception ex)
{
throw ex;
}
return(_quizCorrectFormat);
}
public void CreateTestAsync_InvalidTest_ExceptionThrown()
{
var invalidTest = new Entities.Quiz();
A.CallTo(() => _entityValidator.ValidateEntity<IQuizModel>(invalidTest))
.Returns(
new EntityValidationResult(
false,
new[]
{
new ValidationResult("Name required", new[] { "Name" }),
new ValidationResult("Questions must be not empty", new[] { "Questions" })
}));
var aggregateException = Assert.Throws<AggregateException>(() => _quizManagementService.CreateQuizAsync(invalidTest).Wait());
var exception = (InvalidQuizException)aggregateException.GetBaseException();
Assert.True(exception.ValidationResults.Any(x => x.MemberNames.First() == "Name"));
Assert.True(exception.ValidationResults.Any(x => x.MemberNames.First() == "Questions"));
}
public SaveQuizCommand(Entities.Quiz quiz)
{
StoredProcedureName = SeedStoredProcedures.SaveQuiz;
_quiz = quiz;
}
