public void Create(CreateQuizDto dto)
{
var quiz = _mapper.Map <QuizDbEntity>(dto);
_DB.Quizzes.Add(quiz);
_DB.SaveChanges();
}
public IActionResult Create(CreateQuizDto dto)
{
if (ModelState.IsValid)
{
_service.Create(dto);
return RedirectToAction("Index");
}
return View(dto);
}
public CreatedQuizDto AddQuiz(CreateQuizDto createQuizDto)
{
var quiz = _repository.Add(new Quiz {
Date = createQuizDto.Date, QuizName = createQuizDto.Name, QuizOwnerId = createQuizDto.QuizOwnerId
}).First();
_repository.Save();
return(new CreatedQuizDto {
Id = quiz.Id, Name = quiz.QuizName, Date = quiz.Date
});
}
public IActionResult CreateQuizWithRound([FromBody] CreateQuizDto createQuizDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var createdQuizDto = _quizRoundService.CreateQuiz(createQuizDto, GetUserEmailFromToken());
if (createdQuizDto == null)
{
return(BadRequest("A quiz owner can't be a player"));
}
return(Ok(createQuizDto));
}
public Quiz CreateQuiz(CreateQuizDto createQuizDto, string currentUserId)
{
var owner = applicationUserService.GetUser(currentUserId);
if (owner != null)
{
var quiz = new Quiz()
{
Name = createQuizDto.Name,
Owner = owner
};
_context.Quizzes.Add(quiz);
_context.SaveChanges();
return(quiz);
}
return(null);
}
public CreatedQuizDto CreateQuiz(CreateQuizDto createQuizDto, string userEmail)
{
var user = GetUserFromEmail(userEmail);
createQuizDto.QuizOwnerId = user.Id;
var playerIds = createQuizDto.Players.Select(dto => dto.Id);
if (playerIds.Contains(createQuizDto.QuizOwnerId))
{
return(null);
}
var addedQuiz = _quizService.AddQuiz(createQuizDto);
addedQuiz.QuizRoundDto = createQuizDto.Round;
var addedRound = _roundService.AddRoundToQuiz(addedQuiz.QuizRoundDto, addedQuiz.Id);
_roundService.InsertUsersIntoTheRoundUserPoints(addedRound.Id, createQuizDto.Players);
return(new CreatedQuizDto {
Id = addedQuiz.Id, Name = addedQuiz.Name, Date = addedQuiz.Date, PlayerInQuizDtos = createQuizDto.Players
});
}
public ActionResult <Quiz> CreateQuiz(CreateQuizDto createQuizDto)
{
return(quizService.CreateQuiz(createQuizDto, HttpContext.User.GetUserId()));
}
public async Task <ResultDto <CreateQuizDto> > CreateQuiz(CreateQuizViewModel viewModel, int userId)
{
var result = new ResultDto <CreateQuizDto>();
var questions = _mapper.Map <List <QuestionViewModel>, List <Question> >(viewModel.Questions);
double effectiveness = CalculatePercentageRate(viewModel.NumberOfPositiveRates, viewModel.NumberOfNegativeRates);
var quiz = _mapper.Map <Quiz>(viewModel);
quiz.PointsForGame = CalculatePointsForEveryQuestion(questions, viewModel.QuizType);
quiz.SecondsSpendOnQuiz = Math.Round(viewModel.Questions.Sum(x => x.TimeForAnswerInSeconds), 2);
quiz.UserId = userId; quiz.RateInNumber = effectiveness;
var insertedQuiz = await _quizRepository.InsertAndReturnObject(quiz);
if (insertedQuiz == null)
{
result.Errors.Add("Wystapił błąd podczas dodawania wyniku do twojej historii. Ta gra nie zostanie uznana");
return(result);
}
foreach (var question in questions)
{
question.QuizId = insertedQuiz.Id;
}
int isQuestionsInserted = await _questionRepository.InsertList(questions);
if (isQuestionsInserted == 0)
{
result.Errors.Add("Wystapił błąd podczas dodawania wyniku do twojej historii. Ta gra nie zostanie uznana");
return(result);
}
var quizes = _quizRepository.GetAllBy(x => x.UserId == userId).ToList();
RateModel rateModel = CalculateCurrentRate(userId, quizes);
var rate = _rateRepository.GetBy(x => x.UserId == userId);
bool rateExist = true;
if (rate == null)
{
rate = new Rate();
rateExist = false;
}
rate.CurrentPercentageRate = rateModel.PercentageRate;
rate.NumberOfPlayedGames = rateModel.CountOfQuizes;
rate.PointsForAllGames = rateModel.PointsForAllGames;
rate.UserId = userId;
if (rateExist)
{
rate.CreationDate = rate.CreationDate;
int isRateUpdated = _rateRepository.Update(rate);
if (isRateUpdated == 0)
{
result.Errors.Add("Wystąpił błąd podczas dodawania nowych danych do twojego rankingu");
return(result);
}
}
else
{
int isRateInserted = await _rateRepository.Insert(rate);
if (isRateInserted == 0)
{
result.Errors.Add("Wystąpił błąd podczas dodawania oceny");
return(result);
}
}
var quizDto = new CreateQuizDto();
quizDto.ActualPoints = rate.PointsForAllGames;
quizDto.NumberOfPlayedGames = rate.NumberOfPlayedGames;
quizDto.Effectiveness = rate.CurrentPercentageRate;
quizDto.NumberOfAllPositiveAnswers = rateModel.NumberOfAllPositiveAnswers;
quizDto.NumberOfAllNegativeAnswers = rateModel.NumberOfAllNegativeAnswers;
quizDto.TimeAverage = Math.Round(quizes.Sum(x => x.SecondsSpendOnQuiz) / rateModel.CountOfQuizes, 2);
var rates = _rateRepository.GetAll(x => x.User.UserSetting).OrderByDescending(x => x.CurrentPercentageRate).ToList();
var SimilarUsers = new List <SimilarUserDto>();
var ratesWithoutRequestingUser = rates.Where(x => x.UserId != userId).Take(6).ToList();
quizDto.PlaceInRank = GetPlaceInRank(ratesWithoutRequestingUser, rates.Single(x => x.UserId == userId).CurrentPercentageRate);
if (ratesWithoutRequestingUser.Count() > 0)
{
foreach (var el in rates)
{
SimilarUsers.Add(new SimilarUserDto(el.User.Username, el.User.Sex, el.User.UserSetting != null ? el.User.UserSetting.PathToAvatar : "",
el.NumberOfPlayedGames, el.Id, el.PointsForAllGames));
}
quizDto.SimilarUsers = SimilarUsers;
}
result.SuccessResult = quizDto;
return(result);
}
public async Task CreateQuizAsync([FromBody] CreateQuizDto quiz)
{
}
public async Task <ActionResult <CreatedQuizDto> > CreateQuestion(CreateQuizDto createQuestionDto)
{
var result = await _mediator.Send(new CreateQuizCommand(createQuestionDto));
return(Ok(result));
}
public CreateQuizCommand(CreateQuizDto createQuizDto)
{
Dto = createQuizDto;
}
public IActionResult Create([FromBody] CreateQuizDto dto)
{
_service.Create(dto);
return(Ok(GetResponse()));
}
