public void UpdateQuiz(int id, QuizDto quizDto)
{
if (!ModelState.IsValid)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
var quizInDatabase = _context
.Quizzes
.Include(q => q.Choices)
.ToList()
.SingleOrDefault(c => c.Id == id);
if (quizInDatabase == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
_context.Entry(quizInDatabase).CurrentValues.SetValues(quizDto);
foreach (var choice in quizDto.Choices)
{
var choiceItem = quizInDatabase.Choices
.SingleOrDefault(q => q.Id == choice.Id && q.Id != 0);
_context.Entry(choiceItem).CurrentValues.SetValues(choice);
}
// Mapper.Map(quizInDatabase, quizDto);
_context.SaveChanges();
}
public async Task GetUserQuizWithId_JustCalled_ReturnQuizIdAndQuizDto()
{
// Arrange
var quizDto = new QuizDto();
_mapperMock
.Setup(m => m.Map <QuizDto>(It.IsAny <Quiz>()))
.Returns(quizDto);
_quizDaoMock
.Setup(m => m.GetUserQuiz(Username))
.ReturnsAsync(new Quiz {
Id = QuizId
});
// Act
var(actualQuizId, actualQuizDto) = await _service.GetUserQuizWithId(Username);
// Assert
Assert.Equal(QuizId, actualQuizId);
Assert.Same(quizDto, actualQuizDto);
_quizDaoMock.Verify(x => x.GetUserQuiz(Username), Times.Once);
_quizDaoMock.VerifyNoOtherCalls();
_mapperMock.Verify(m => m.Map <QuizDto>(It.IsAny <Quiz>()), Times.Once);
_mapperMock.VerifyNoOtherCalls();
}
public async Task <IActionResult> AddQuiz(QuizDto quiz)
{
var questionToAdd = new QuizQuestion();
questionToAdd.Question = quiz.Question;
_repo.Add(questionToAdd);
if (await _repo.SaveAll())
{
foreach (var option in quiz.Options)
{
var optionToAdd = new Option();
optionToAdd.Answer = option.Answer;
optionToAdd.IsCorrect = option.isCorrect;
optionToAdd.Question = await _repo.GetQuizQuestionAsync(questionToAdd.Id);
_repo.Add(optionToAdd);
await _repo.SaveAll();
}
return(Ok(quiz));
}
throw new Exception("Question failed to add");
}
public async Task <IDataResult <QuizDto> > DeleteAsync(QuizDto entity)
{
var response = new DataResult <QuizDto>();
try
{
var result = await _quizDal.DeleteAsync(_mapper.Map <Quizs>(entity));
await _unitOfWork.CompletedAsync();
if (result.Successeded && result.Data != null)
{
response.Message = "Quiz Silme İşlemi Başarılı";
response.Data = _mapper.Map <QuizDto>(result.Data);
response.Successeded = result.Successeded;
}
else
{
response.Message = "İşlem Sırasında Hata Oluştu";
response.Successeded = false;
response.Data = null;
}
}
catch (Exception exception)
{
response.Message = exception.Message;
response.Successeded = false;
response.Data = null;
}
return(response);
}
public QuizDto GetQuiz(int quizId = 0)
{
if (quizId == 0)
{
return new QuizDto()
{
Questions = new ObservableCollection <QuestionDto>()
}
}
;
QuizDto quizDto = new QuizDto();
quizDto.Questions = new ObservableCollection <QuestionDto>();
QuizModel quizModel = quizRepository.Get(quizId);
quizDto.QuizId = quizModel.QuizId;
quizDto.Name = quizModel.QuizName;
List <QuestionModel> questionList = questionRepository.GetByQuizId(quizId).ToList();
foreach (QuestionModel questionModel in questionList)
{
quizDto.Questions.Add(new QuestionDto()
{
QuestionId = questionModel.QuestionId,
Question = questionModel.Question
});
}
return(quizDto);
}
public bool CreateQuiz(QuizDto quizDto)
{
using var dbContext = _dbContextFactory.GetDbContext();
try
{
dbContext.Quizes.Add(new Quiz
{
Question = quizDto.Question,
PointsPerCorrectAnswer = quizDto.PointsPerCorrectAnswer,
Complexity = quizDto.Complexity,
Options = quizDto.Options.Select(
quizOptionDto => new QuizOption {
Text = quizOptionDto.Text
}
).ToList(),
CorrectAnswers = quizDto.CorrectAnswers.Select(
quizOptionDto => new QuizOption {
Text = quizOptionDto.Text
}
).ToList()
});
dbContext.SaveChanges();
return(true);
}
catch
{
return(false);
}
}
public async Task <ActionResult> DeleteAsync(QuizDto quizDto)
{
var result = await _quizService.DeleteAsync(quizDto);
if (!result.Successeded && result.Data == null)
{
return(BadRequest(result));
}
return(Ok(result));
}
/// <summary>
/// Выполняет преобразование <see cref="QuizDto"/> в <see cref="SimpleQuizModel"/>.
/// </summary>
/// <param name="dto">Исходный объект.</param>
/// <returns>Преобразованный объект.</returns>
public static SimpleQuizModel SimpleTranslate(QuizDto dto)
{
var model = new SimpleQuizModel
{
Id = dto.Id,
Title = dto.Title,
TotalTimeSecs = dto.TotalTimeSecs,
};
return(model);
}
public async Task <QuizDto> CreateQuiz(QuizDto quizDto)
{
var quiz = _mapper.Map <Quiz>(quizDto);
var quizzes = await _dbContext.Quizzes.AddAsync(quiz);
_dbContext.SaveChanges();
//quizzes.MapTo<AgentUserModel>()
var quizResult = _mapper.Map <QuizDto>(quiz);
return(quizResult);
}
public async Task <QuizDto> Update(QuizDto quizDto)
{
Validation(quizDto);
var entity = _mapper.Map(quizDto, new Quiz());
entity.QuizUrl = GenerateUrl(quizDto.Id);
_quizRepository.Update(entity);
await _quizRepository.SaveAsync().ConfigureAwait(false);
return(_mapper.Map <Quiz, QuizDto>(entity));
}
public async Task <Quiz> Create(QuizDto quizDto)
{
var quiz = _autoMapper.Map <QuizDto, Quiz>(quizDto);
await _db.Quizzes.AddAsync(quiz);
await _db.QuizItems.AddRangeAsync(quiz.Items);
await _db.SaveChangesAsync(CancellationToken.None);
return(quiz);
}
public async Task <ActionResult <QuizDto> > PostQuiz(QuizDto quiz)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
quiz.UserId = User.FindFirstValue(ClaimTypes.NameIdentifier);
await _quizService.Insert(quiz).ConfigureAwait(false);
return(Ok(quiz));
}
public async Task <ApiResponse> Update(QuizDto quizDto)
{
try
{
return(new ApiResponse(Status200OK, "Updated Quiz", await _quizStore.Update(quizDto)));
}
catch (InvalidDataException dataException)
{
return(new ApiResponse(Status400BadRequest, "Failed to update Quiz"));
}
}
/// <summary>
/// Выполняет трансляцию DTO в модель редактирования теста.
/// </summary>
/// <param name="dto">DTO-объект теста.</param>
/// <returns>Модель с описанием теста.</returns>
private EditQuizViewModel TranslateEditQuizModel(QuizDto dto)
{
var model = new EditQuizViewModel
{
QuizId = dto.Id,
Title = dto.Title,
TotalTimeSecs = dto.TotalTimeSecs,
QuizBlocks = dto.QuizBlocks.Select(TranslateQuizBlockModel).ToList()
};
return(model);
}
/// <summary>
/// Выполняет трансляцию DTO в модель создания теста.
/// </summary>
/// <param name="dto">DTO-объект теста.</param>
/// <returns>Модель с описанием теста.</returns>
private CreateQuizViewModel TranslateCreateQuizModel(QuizDto dto)
{
var model = new CreateQuizViewModel
{
Title = dto.Title,
TotalTimeSecs = dto.TotalTimeSecs,
MaxQuizBlocksCount = dto.MaxQuizBlocksCount,
QuizBlocks = dto.QuizBlocks.Select(TranslateQuizBlockModel).ToList()
};
return(model);
}
/// <summary>
/// Выполняет трансляцию модели создания теста в DTO.
/// </summary>
/// <param name="model">Модель с описанием теста.</param>
/// <returns>DTO-объект теста.</returns>
private QuizDto TranslateCreateQuizModel(CreateQuizViewModel model)
{
var dto = new QuizDto
{
Title = model.Title,
TotalTimeSecs = model.TotalTimeSecs,
MaxQuizBlocksCount = model.MaxQuizBlocksCount,
QuizBlocks = model.QuizBlocks.Select(TranslateQuizBlockModel).ToList()
};
return(dto);
}
void ValidateQuiz(QuizDto quiz)
{
if (quiz.Name == "")
{
throw new ArgumentException("La encuesta debe tener un nombre");
}
if (quiz.Questions.Count() == 0)
{
throw new ArgumentException("Al menos debe existir una pregunta");
}
}
/// <summary>
/// Выполняет преобразование <see cref="QuizDto"/> в <see cref="QuizModel"/>.
/// </summary>
/// <param name="dto">Исходный объект.</param>
/// <returns>Преобразованный объект.</returns>
public static QuizModel Translate(QuizDto dto)
{
var model = new QuizModel
{
Id = dto.Id,
Title = dto.Title,
TotalTimeSecs = dto.TotalTimeSecs,
MaxQuizBlocks = dto.MaxQuizBlocksCount,
QuizBlocks = dto.QuizBlocks.Select(Translate).ToList(),
};
return(model);
}
public void AddQuestionToQuiz(QuizDto quiz, QuestionDto question)
{
if (quiz.Questions.Count < 5)
{
quiz.Questions.Add(new QuestionDto()
{
Question = question.Question
});
}
else
{
throw new Exception("Solo se permiten 5 preguntas por encuesta");
}
}
public async Task <QuizDto> CreateQuiz(QuizDto dto)
{
try
{
HttpResponseMessage response;
response = await _client.PostAsJsonAsync("quiz", dto).ContinueWith((postTask) => postTask.Result.EnsureSuccessStatusCode());
var retVal = response.Content.ReadAsAsync <QuizDto>().Result;
return(retVal);
}
catch (Exception ex)
{
return(null);
}
}
public async Task <Quiz> Update(QuizDto quizDto)
{
var quiz = await _db.Quizzes.SingleOrDefaultAsync(t => t.Id == quizDto.Id);
if (quiz == null)
{
throw new InvalidDataException($"Unable to find Quiz with ID: {quizDto.Id}");
}
quiz = _autoMapper.Map(quizDto, quiz);
_db.Quizzes.Update(quiz);
//_db.QuizItems.UpdateRange(quiz.Items);
await _db.SaveChangesAsync(CancellationToken.None);
return(quiz);
}
public async Task <ActionResult <Quiz> > PostQuiz(QuizDto quizDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var quiz = _mapper.Map <Quiz>(quizDto);
quiz.OwnerId = HttpContext.User.Claims.First().Value;
await _context.Quizzes.AddAsync(quiz);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetQuiz", new { id = quiz.Id }, _mapper.Map <QuizDto>(quiz)));
}
public async Task <IActionResult> PostQuiz([FromBody] QuizDto quizDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userId = GetCurrentUserId();
var quiz = new Quiz
{
Questions = quizDto.Questions,
Title = quizDto.Title,
OwnerId = userId
};
_context.Quizzes.Add(quiz);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetQuiz", new { id = quiz.Id }, quiz));
}
public IHttpActionResult CreateQuiz(QuizDto quizDto)
{
if (!ModelState.IsValid)
{
var errors = ModelState.Select(m => m.Value.Errors)
.Where(e => e.Count > 0)
.ToList();
return(BadRequest());
}
//quizDto.LanguageId = quizDto.Language.Id;
//quizDto.LevelId = quizDto.Level.Id;
//quizDto.CategoryId = quizDto.Category.Id;
var quiz = Mapper.Map <QuizDto, Quiz>(quizDto);
_context.Quizzes.Add(quiz);
_context.SaveChanges();
quizDto.Id = quiz.Id;
return(Created(new Uri(Request.RequestUri + "/" + quiz.Id), quizDto));
}
public ActionResult AddNewQuiz(QuizDto quizDto)
{
if (!ModelState.IsValid)
{
return(View(quizDto));
}
else
{
var requestPath = "quiz/add-quiz";
var content = QuizClientOptions.StringContent(quizDto);
var request = _httpClient.PostAsync(requestPath, content);
var response = request.Result.Content.ReadAsStringAsync();
var entity = JsonConvert.DeserializeObject <DataResult <QuizDto> >(response.Result);
if (entity.Data != null && entity.Successeded)
{
return(RedirectToAction("AddNewQuiz", "Quiz"));
}
else
{
return(View(quizDto));
}
}
}
public async Task <IActionResult> PutQuiz(int id, QuizDto quizDto)
{
if (id != quizDto.Id)
{
return(BadRequest());
}
var quiz = await _context.Quizzes.SingleOrDefaultAsync(x => x.Id == id);
if (quiz.OwnerId != HttpContext.User.Claims.First().Value)
{
return(BadRequest());
}
_mapper.Map(quizDto, quiz);
_context.Entry(quiz).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!QuizExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task StartQuiz_JustCalled_ReturnDtoFromMapper()
{
// Arrange
var quiz = new Quiz {
Id = QuizId, Challenge = null
};
var quizDto = new QuizDto();
_mapperMock
.Setup(m => m.Map <QuizDto>(It.IsAny <Quiz>()))
.Returns(quizDto);
_quizDaoMock
.Setup(m => m.AddUserToQuizOrCreateNew(Username))
.ReturnsAsync(quiz);
// Act
var actualQuizDto = await _service.StartQuiz(Username);
// Assert
Assert.Same(quizDto, actualQuizDto);
_mapperMock.Verify(x => x.Map <QuizDto>(quiz), Times.Once);
_mapperMock.VerifyNoOtherCalls();
}
private void Validation(QuizDto dto)
{
var validator = new QuizValidator();
validator.ValidateAndThrow(dto);
}
public async Task <ApiResponse> Create(QuizDto quizDto)
{
var quiz = await _quizStore.Create(quizDto);
return(new ApiResponse(Status200OK, "Created Quiz", quiz));
}
public async Task <ApiResponse> Put([FromBody] QuizDto quiz) => ModelState.IsValid ? await _quizManager.Update(quiz) : new ApiResponse(Status400BadRequest, "Quiz Model is Invalid");
