Esempio n. 1
0
        public async Task <AnswerUpdateModel> Update(string id, AnswerUpdateModel p)
        {
            var answer = await GetById(id);

            _mapper.Map(p, answer);
            await _answers.ReplaceOneAsync(p => p.Id == id, answer);

            return(p);
        }
Esempio n. 2
0
        public IActionResult PutAnswer(int id, int qid, int aid, [FromBody] AnswerUpdateModel value)
        {
            const string sql         = "UPDATE Answer SET Text = @Text WHERE Id = @AnswerId";
            int          rowsUpdated = _connection.Execute(sql, new { AnswerId = qid, Text = value.Text });

            if (rowsUpdated == 0)
            {
                return(NotFound());
            }
            return(NoContent());
        }
        public async Task <AnswerModelBase> Update(AnswerUpdateModel model)
        {
            var entity = _mapper.Map <Answers>(model);

            _context.Answers.Attach(entity);
            _context.Entry(entity).State = EntityState.Modified;

            await SaveAsync();

            return(_mapper.Map <AnswerModelBase>(entity));
        }
Esempio n. 4
0
        public async Task <IActionResult> Put(int id, [FromBody] AnswerUpdateModel model)
        {
            if (ModelState.IsValid)
            {
                model.Id = id;
                var result = await _service.Update(model);

                return(result != null
                    ? (IActionResult)Ok(result)
                    : NoContent());
            }
            return(BadRequest());
        }
Esempio n. 5
0
        public async Task <Answer> UpdateAnswer(int questionId, int answerId, AnswerUpdateModel request, string username, string role)
        {
            var answer = await answerRepo.FindById(answerId);

            if (answer == null)
            {
                throw new NotFoundException();
            }
            if (answer.Author != username)
            {
                throw new ConflictedDataException();
            }
            answer.Content = request.Content;
            var ret = await answerRepo.Update(answer);

            await questionHub.OnAnswerEdited(answer.QuestionId, answer);

            if (answer.Moderator != null)
            {
                await notificationService.CreateHiddenAnswerEditedNotification(answer.QuestionId, answer);
            }
            return(ret);
        }
Esempio n. 6
0
        public async Task <AnswerUpdateModel> Update(string id, AnswerUpdateModel answerUpdate)
        {
            var answer = await _answerService.Update(id, answerUpdate);

            return(answer);
        }
Esempio n. 7
0
 public async Task <IActionResult> UpdateAnswer([FromRoute] int qId, [FromRoute] int id, [FromBody] AnswerUpdateModel request)
 {
     return(await HandleExceptionsWithOk(
                async() => await questionService.UpdateAnswer(qId, id, request, UserName, Role)
                ));
 }