public void AddQuestion()
{
var addEntityCommand = new Mock <IAddEntityCommand>();
var getEntityByIdQueryMock = new Mock <IGetEntityByIdQuery>();
var questionnaire = new Questionnaire {
Id = QuestionnaireId
};
getEntityByIdQueryMock.Setup(x => x.Execute <Questionnaire>(QuestionnaireId)).Returns(questionnaire);
var section = new Section {
Id = SectionId
};
getEntityByIdQueryMock.Setup(x => x.Execute <Section>(SectionId)).Returns(section);
var request = new AddQuestionRequest();
request.Model = new AddQuestionModel()
{
Text = Text, Ordinal = Ordinal, SectionId = SectionId, QuestionnaireId = QuestionnaireId
};
var handler = new AddQuestionRequestHandler(addEntityCommand.Object, getEntityByIdQueryMock.Object);
CancellationTokenSource cts = new CancellationTokenSource();
handler.Handle(request, cts.Token);
getEntityByIdQueryMock.Verify(x => x.Execute <Questionnaire>(QuestionnaireId), Times.Once);
addEntityCommand.Verify(x => x.Execute(It.Is <Question>(q => q.Text == Text && q.Ordinal == Ordinal && q.Section == section && q.Questionnaire == questionnaire)), Times.Once);
}
public async Task <ApiResponse> AddQuestionAsync(AddQuestionRequest request)
{
return(await GetResponseAsync(async() =>
{
var response = new ApiResponse();
using (var db = new EFDbContext())
{
// TODO: Valodation as login
var questionEntity = new Question
{
Name = request.Name,
Type = request.Type,
Level = request.Level,
TestAnswer1 = request.TestAnswer1,
TestAnswer2 = request.TestAnswer2,
TestAnswer3 = request.TestAnswer3,
TestAnswer4 = request.TestAnswer4,
RightTestAnswer = request.RightTestAnswer,
RightWordAnswer = request.RightWordAnswer,
UserId = request.UserId,
LastActionDate = DateTime.UtcNow
};
db.Questions.Add(questionEntity);
await db.SaveChangesAsync();
}
return response;
}));
}
public int AddQuestion(AddQuestionRequest model)
{
var paramForQuestion = new DynamicParameters();
paramForQuestion.Add("@QuestionTitle", model.QuestionTitle);
paramForQuestion.Add("@QuestionContent", model.QuestionContent);
paramForQuestion.Add("@CreatedDate", model.CreatedDate);
paramForQuestion.Add("@UserId", model.UserId);
var questionId = _dbConnection.Query <int>(@"insert into Question(QuestionTitle, QuestionContent, CreatedDate, UserId)
values(@QuestionTitle,@QuestionContent,@CreatedDate,@UserId);
SELECT CAST(SCOPE_IDENTITY() as int)", paramForQuestion).Single();
foreach (var categoryId in model.CategoriesId)
{
var paramForQuestionCategory = new DynamicParameters();
paramForQuestionCategory.Add("@QuestionId", questionId);
paramForQuestionCategory.Add("@CategoryId", categoryId);
_dbConnection.Execute(@"insert into QuestionCategory(QuestionId,CategoryId)
values(@QuestionId,@CategoryId)", paramForQuestionCategory);
}
return(questionId);
}
public async Task <IActionResult> AddQuestion([FromBody] AddQuestionRequest request, string QuizId)
{
if (!ModelState.IsValid)
{
return(new BadRequestResult());
}
var userId = HttpContext.GetUserIdFromJwt();
try
{
var quizId = new ObjectId(QuizId);
var quiz = await _quizService.GetQuiz(quizId);
if (quiz == null)
{
return(StatusCode(StatusCodes.Status410Gone, new { message = "Error: quiz does not exist" }));
}
if (quiz.OwnerId == userId)
{
var result = await _quizService.AddQuestion(quizId, request.Question, request.Answer);
return(Ok(new { quiz = result }));
}
else
{
return(Unauthorized());
}
}
catch
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public void AddQuestion(AddQuestionRequest request)
{
GeneralHelpers.ThrowIfNull(request.Question);
var initialAnswerDescriptions = new List <string>
{
request.InitialAnswerOne,
request.InitialAnswerTwo,
request.InitialAnswerThree
};
GeneralHelpers.ThrowIfAnyAreNull(initialAnswerDescriptions);
var initialAnswers = initialAnswerDescriptions
.Select(ad => new Answer
{
Description = ad
}).ToList();
if (request.OrderPosition == -1) // question is last
{
AddQuestionToLastPositionOfQuiz(request.Question, initialAnswers, request.QuizId);
}
else
{
AddQuestionToSpecificPositionOfQuiz(request.Question, initialAnswers, request.QuizId,
request.OrderPosition);
}
}
public Task AddAsync(AddQuestionRequest request)
{
return(transactionService.CommitAsync(new[] { TransactionContextScope.Main }, async() =>
{
var question = mapper.Map <Question>(request);
await AddAsync(question, request.Answers);
await examinationsService.UpdateModificationTimeAsync(question.ExaminationId);
}));
}
public IActionResult AddQuestion(AddQuestionRequest model)
{
string tokenString = Request.Headers["Authorization"];
int currentUserId = JwtAthentication.GetCurrentUserId(tokenString);
model.UserId = currentUserId;
var questionId = _questionService.AddQuestion(model);
return(Ok(new { questionId = questionId }));
}
public Survey PostQuestion(int id, [FromBody] AddQuestionRequest question)
{
var existingQuestion = _questionsRepository.Get(question.QuestionId);
var existingSurvey = _surveysRepository.Get(id);
existingSurvey.AddQuestion(existingQuestion);
_surveysRepository.Update(existingSurvey);
return(existingSurvey);
}
public QuestionResponse AddQuestion([FromBody] AddQuestionRequest request)
{
var userId = User.Claims
.Where <Claim>(c => c.Type == ClaimTypes.NameIdentifier)
.Select(s => s.Value).First();
if (userId == null)
{
return(new QuestionResponse {
Data = null, Message = "اطلاعات کاربری یافت نشد"
});
}
var question = new Question
{
Title = request.Title,
Description = request.Description,
UserId = userId,
CreateTime = DateTime.Now,
};
try
{
context.Questions.Add(question);
context.SaveChanges();
}
catch (Exception e)
{
return(new QuestionResponse {
Data = null, Message = "خطایی در ثبت سوال بوجد امد"
});
}
return(new QuestionResponse {
Data = null, Message = "سوال با موفقیت ثبت شد"
});
}
public ActionResult AddQuestion([FromForm] AddQuestionRequest request)
{
questionService.AddQuestion(request);
return(Ok());
}
public int AddQuestion(AddQuestionRequest model)
{
return(_questionRepository.AddQuestion(model));
}
public async Task <ApiResponse> AddQuestionAsync([FromBody] AddQuestionRequest request) => await _questionsService.AddQuestionAsync(request);
public Question Map(AddQuestionRequest request)
{
throw new System.NotImplementedException();
}
public async Task AddQuestion([FromBody] AddQuestionRequest question) => await questionsService.AddAsync(question);
public BaseResult AddQuestion(AddQuestionRequest request)
{
return(_retroLogic.AddQuestion(request.Question, request.Order));
}
