/// <summary>
/// Responsible for removing the question itself.
/// It also verifies authorization.
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public override ResultOperation Delete(int id)
{
try
{
using (IRepository repository = Repository.Repository.CreateRepository())
{
Domain.Question question = repository.GetQuestion(id);
if (question != null)
{
if (question.Quiz.Creator == repository.GetUser(this.currentUserId))
{
repository.DeleteQuestion(question);
return(true);
}
}
else
{
messages.Add("Question was not found.");
}
}
}
catch (Exception ex)
{
LogException(ex);
messages.Add(DefaultErrorMessage());
}
return(messages);
}
/// <summary>
/// Responsible for removing a option from a question.
/// Option can be TrueFalse, multiple choice or open ended.
/// </summary>
/// <param name="idQuestion"></param>
/// <param name="idOption"></param>
/// <returns></returns>
public ResultOperation DeleteQuestionOption(int idQuestion, int idOption)
{
try
{
using (IRepository repository = Repository.Repository.CreateRepository())
{
Domain.Question question = repository.GetQuestion(idQuestion);
if (question != null && question.Options.Any(r => r.Id == idOption))
{
if (question.Quiz.Creator == repository.GetUser(this.currentUserId))
{
question.Options.Remove(question.Options.FirstOrDefault(r => r.Id == idOption));
repository.SaveQuestion(question);
}
}
else
{
messages.Add("Question was not found.");
}
}
}
catch (Exception ex)
{
LogException(ex);
messages.Add(DefaultErrorMessage());
}
return(messages);
}
public List <Cholestabetes.Domain.Question> GetQuestionList(int screenID)
{
int lastQID = -1;
bool addQuestion = false;
List <Cholestabetes.Domain.Question> questionLst = new List <Domain.Question>();
foreach (sp_GetQuestionsAnswersByScreen_Result item in Entites.sp_GetQuestionsAnswersByScreen(screenID).ToList())
{
Domain.Question question = null;
if (lastQID != item.QuestionID)
{
question = new Domain.Question();
question.ID = item.QuestionID;
question.Required = item.QuestionRequired;
question.Sequence = item.QuestionSequence;
question.Text = item.QuestionText;
question.Type = item.QuestionType;
question.Screen = item.Screen.Value;
addQuestion = true;
}
else
{
question = questionLst[questionLst.Count - 1] as Domain.Question;
addQuestion = false;
}
//getting answers
Domain.Answer ans = new Domain.Answer();
ans.ID = item.AnswerID;
ans.QID = item.AnswerQuestionID;
ans.Text = item.AnswerText;
question.Answers.Add(ans);
if (addQuestion)
{
questionLst.Add(question);
}
lastQID = item.QuestionID;
}
return(questionLst);
}
/// <summary>
/// If the user is the creator, it saves the question.
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public override ResultOperation Save(Question entity)
{
try
{
using (IRepository repository = Repository.Repository.CreateRepository())
{
Domain.Quiz quiz = repository.GetQuiz(entity.IdQuiz);
if (quiz != null)
{
if (quiz.Creator == repository.GetUser(this.currentUserId))
{
Domain.Question question = new Domain.Question()
{
Id = entity.Id,
Description = entity.Description,
ImageURL = entity.ImageURL,
QuestionType = entity.QuestionType,
Options = entity.GetOptions()
};
if (entity.Id == 0)
{
quiz.Questions.Add(question);
}
repository.SaveQuestion(question);
entity.Id = question.Id;
return(true);
}
}
else
{
messages.Add("quiz was not found.");
}
}
}
catch (Exception ex)
{
LogException(ex);
messages.Add(DefaultErrorMessage());
}
return(messages);
}
/// <summary>
/// Get the generic options for a question.
/// It is used for questions that are multiple choice, open ended, or true false.
/// It also verifies authorization.
/// </summary>
/// <param name="idQuestion"></param>
/// <returns></returns>
public IList GetQuestionOptions(int idQuestion)
{
using (IRepository repository = Repository.Repository.CreateRepository())
{
Domain.Question question = repository.GetQuestion(idQuestion);
if (question != null)
{
if (question.Quiz.Creator == repository.GetUser(this.currentUserId))
{
return(question.Options);
}
}
}
return(new List <Domain.BaseQuestionOptionType>());
}
private async Task <bool> SaveAnswers(
Domain.Question question,
DateTime utcNow,
IEnumerable <AnswerData> answers, CancellationToken cancellationToken)
{
bool hasChanged = false;
var answerOptions = question.AnswerOptions;
var answerOptionsToAdd = answers
.Where(e => !e.Id.HasValue).Select(e => mapper.Map <AnswerData, Domain.AnswerOption>(e)).ToArray();
var answerOptionsToDelete = answerOptions.Where(ao => !answers.Any(a => a.Id == ao.Id)).ToArray();
var answerOptionsToUpdate =
(from answerOption in answerOptions
join answer in answers on answerOption.Id equals answer.Id
where answer.Id != null
select new { answerOption = answerOption, answer = answer }).ToArray();
if (answerOptionsToAdd.Length > 0 || answerOptionsToDelete.Length > 0 || answerOptionsToUpdate.Length > 0)
{
foreach (var answerOptionItem in answerOptionsToUpdate)
{
var answer = answerOptionItem.answer;
var answerOption = answerOptionItem.answerOption;
answerOption.Text = answer.Text ?? answerOption.Text;
answerOption.IsRight = answer.IsRight;
if (context.IsModified(answerOption))
{
hasChanged = true;
answerOption.UpdatedAt = utcNow;
}
}
foreach (var answerOption in answerOptionsToAdd)
{
hasChanged = true;
answerOption.QuestionId = question.Id;
answerOption.CreatedAt = utcNow;
answerOption.UpdatedAt = utcNow;
}
await context.AnswerOptions.AddRangeAsync(answerOptionsToAdd, cancellationToken);
context.AnswerOptions.RemoveRange(answerOptionsToDelete);
}
return(hasChanged);
}
public Domain.Question GetDomainObject(bool getParent)
{
Domain.Question dto = new Domain.Question();
dto.ID = this.QuestionID;
dto.Name = this.Name;
dto.Description = this.Description;
dto.DateCreated = this.DateCreated;
dto.DateModified = this.DateModified;
if (getParent)
{
dto.Level = Level.GetQuestionLevel(this.QuestionID);
dto.LevelID = dto.Level.ID;
dto.DimensionID = dto.Level.DimensionID;
}
return dto;
}
/// <summary>
/// Verifies authorization and returns the required question.
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public override Question Get(int id)
{
using (IRepository repository = Repository.Repository.CreateRepository())
{
Domain.Question question = repository.GetQuestion(id);
if (question != null)
{
if (question.Quiz.Creator == repository.GetUser(this.currentUserId))
{
return(new Question()
{
Description = question.Description,
Id = question.Id,
ImageURL = question.ImageURL,
QuestionType = question.QuestionType
});
}
}
}
return(null);
}
/// <summary>
/// Saves the options for a question.
/// </summary>
/// <param name="idQuestion"></param>
/// <param name="option"></param>
/// <returns></returns>
public ResultOperation SaveQuestionOptions(int idQuestion, Domain.MultipleChoice[] option)
{
try
{
using (IRepository repository = Repository.Repository.CreateRepository())
{
Domain.Question question = repository.GetQuestion(idQuestion);
if (question != null)
{
if (question.Quiz.Creator == repository.GetUser(this.currentUserId))
{
question.Options.Clear();
foreach (var item in option)
{
question.Options.Add(item);
}
repository.SaveQuestion(question);
}
}
else
{
messages.Add("Question was not found.");
}
}
}
catch (Exception ex)
{
LogException(ex);
messages.Add(DefaultErrorMessage());
}
return(messages);
}
public QuestionVM(Domain.Question question)
{
this._question = question;
}
public QuestionVM()
{
_question = new Domain.Question();
_question.Categorie = new Domain.QuestionCategory();
}
/// <summary>
/// Executes the default behavior for saving an aswer.
/// </summary>
/// <param name="savedAnswer"></param>
/// <param name="answer"></param>
/// <param name="repository"></param>
/// <param name="question"></param>
/// <param name="insert"></param>
/// <param name="update"></param>
private void SaveAnswer(Answer savedAnswer, AnswerModelViewBase answer, IRepository repository, Domain.Question question, Func <IRepository, AnswerQuestionOption> insert, Func <IRepository, AnswerQuestionOption, bool> update)
{
// If it came until here, we know that it is likely to be a valid request
savedAnswer.AnsweredAt = DateTime.Now; //Changing to know the last time the user answered
// Loading the last option that the user selected
AnswerQuestionOption answerOption = null;
if (savedAnswer.Answers != null)
{
answerOption = savedAnswer.Answers.FirstOrDefault(r => r.Question.Id == answer.Question.Id);
}
else
{
savedAnswer.Answers = new List <AnswerQuestionOption>();
}
// If it is null, means that the user have not answered the question yet
if (answerOption == null)
{
answerOption = insert(repository);
answerOption.Question = question;
savedAnswer.Answers.Add(answerOption);
}
else
{
update(repository, answerOption);
}
repository.SaveChanges();
}
public async Task <QuestionDefault> Save(Model model)
{
var user = await db.Users.FindAsync(model.UserId);
if (user == null)
{
throw new UnauthorizedException();
}
if (user != null && user.DeletedAt != null)
{
throw new NotFoundException();
}
user.Points += 10;
var question = new Domain.Question
{
Title = model.Title,
Content = model.Content,
UserId = model.UserId,
};
db.Questions.Add(question);
var questionTags = new List <Domain.QuestionTag>();
var Tags = new List <QuestionDefault.Tag>();
var tagsDisyinct = model.Tags
.Distinct();
if (tagsDisyinct.Count() > 10)
{
throw new HttpException(400, "Limite de tag ultrapassado");
}
foreach (var item in tagsDisyinct)
{
var tag = await db.Tags.FindAsync(item);
if (tag == null)
{
throw new Exception();
}
Tags.Add(new QuestionDefault.Tag {
Id = tag.Id, Name = tag.Name, Type = tag.TagType
});
questionTags.Add(new Domain.QuestionTag {
TagId = item, QuestionId = question.Id
});
}
db.QuestionTags.AddRange(questionTags);
await db.SaveChangesAsync();
return(new QuestionDefault
{
Id = question.Id,
Title = question.Title,
Content = question.Content,
CreatedAt = question.CreatedAt,
UpdatedAt = question.UpdatedAt,
UserId = question.UserId,
Tags = Tags
});
}
