eagle.ead.lmsestudio.com.br

UnknownSec Bypass 403

: /mnt/lmsestudio-instance-vol002/lms_6457fbc6908c/app/Services/Environment/ [ drwxr-xr-x ]
name : QuizService.php
 <?php

namespace EstudioLMS\Services\Environment;

use EstudioLMS\Exceptions\Handler;
use EstudioLMS\Helpers\GetDataRecords;
use EstudioLMS\Repositories\Courses\Course\CourseResourceRepository;
use EstudioLMS\Repositories\Courses\Resources\QuizInterface;
use EstudioLMS\Repositories\Courses\Resources\ResourceTypeInterface;
use EstudioLMS\Repositories\Environment\Gamification\AcquiredBadgeInterface;
use EstudioLMS\Repositories\Environment\Quiz\QuizAttemptInterface;
use EstudioLMS\Repositories\Environment\Quiz\QuizAttemptSummaryInterface;
use EstudioLMS\Repositories\Environment\RecordRepository;
use EstudioLMS\Repositories\Gamification\BadgeRuleInterface;
use EstudioLMS\Repositories\Gamification\RuleTypes\QuizWithAverageBetweenInterface;
use Symfony\Component\HttpFoundation\Session\Session;
use EstudioLMS\Repositories\Environment\Quiz\QuizAttemptDetailInterface;

/**
 * Class QuizService
 * @package EstudioLMS\Services\Environment
 */
class QuizService
{
    /**
     * @var GetDataRecords
     */
    private $getDataRecords;
    /**
     * @var QuizInterface
     */
    private $quizRepository;
    /**
     * @var CourseResourceRepository
     */
    private $courseResourceRepository;
    /**
     * @var RecordRepository
     */
    private $recordRepository;
    /**
     * @var QuizAttemptInterface
     */
    private $quizAttemptRepository;
    /**
     * @var ResourceTypeInterface
     */
    private $resourceTypeRepository;
    /**
     * @var Session
     */
    private $session;
    /**
     * @var BadgeRuleInterface
     */
    private $badgeRule;
    /**
     * @var QuizWithAverageBetweenInterface
     */
    private $quizWithAverageBetween;
    /**
     * @var AcquiredBadgeInterface
     */
    private $acquiredBadge;
    /**
     * @var QuizAttemptDetailInterface
     */
    private $quizAttemptDetailRepository;
    /**
     * @var QuizAttemptSummaryInterface
     */
    private $quizAttemptSummary;

    /**
     * QuizService constructor.
     * @param GetDataRecords $getDataRecords
     * @param QuizInterface $quizRepository
     * @param CourseResourceRepository $courseResourceRepository
     * @param RecordRepository $recordRepository
     * @param QuizAttemptInterface $quizAttemptRepository
     * @param ResourceTypeInterface $resourceTypeRepository
     * @param Session $session
     * @param BadgeRuleInterface $badgeRule
     * @param QuizWithAverageBetweenInterface $quizWithAverageBetween
     * @param AcquiredBadgeInterface $acquiredBadge
     * @param QuizAttemptDetailInterface $quizAttemptDetailRepository
     * @param QuizAttemptSummaryInterface $quizAttemptSummary
     */
    public function __construct(
        GetDataRecords                  $getDataRecords,
        QuizInterface                   $quizRepository,
        CourseResourceRepository        $courseResourceRepository,
        RecordRepository                $recordRepository,
        QuizAttemptInterface            $quizAttemptRepository,
        ResourceTypeInterface           $resourceTypeRepository,
        Session                         $session,
        BadgeRuleInterface              $badgeRule,
        QuizWithAverageBetweenInterface $quizWithAverageBetween,
        AcquiredBadgeInterface          $acquiredBadge,
        QuizAttemptDetailInterface      $quizAttemptDetailRepository,
        QuizAttemptSummaryInterface     $quizAttemptSummary
    )
    {
        $this->getDataRecords = $getDataRecords;
        $this->quizRepository = $quizRepository;
        $this->courseResourceRepository = $courseResourceRepository;
        $this->recordRepository = $recordRepository;
        $this->quizAttemptRepository = $quizAttemptRepository;
        $this->resourceTypeRepository = $resourceTypeRepository;
        $this->session = $session;
        $this->badgeRule = $badgeRule;
        $this->quizWithAverageBetween = $quizWithAverageBetween;
        $this->acquiredBadge = $acquiredBadge;
        $this->quizAttemptDetailRepository = $quizAttemptDetailRepository;
        $this->quizAttemptSummary = $quizAttemptSummary;
    }

    /**
     * @param $userId
     * @param $resourceType
     * @param $courseSlug
     * @param $moduleSlug
     * @param $resourceSlug
     * @param array $attempt
     * @return mixed
     */
    public function startQuiz($userId, $resourceType, $courseSlug, $moduleSlug, $resourceSlug, $attempt = [])
    {
        $resourceType = $this->resourceTypeRepository->findByField('slug', $resourceType)->first();
        $course = $this->getDataRecords->getCourseBySlug($courseSlug);
        $module = $this->getDataRecords->getModuleBySlug($moduleSlug, $course['id']);

        $quiz = $this->quizRepository
            ->with(['questions' => function ($query) {
                $query->where('status_id', '=', 1);
            }, 'rule'])
            ->findByField('slug', $resourceSlug)
            ->first();

        $quiz['step'] = 1;
        $quiz['duration'] = 0;
        $quiz['type'] = $resourceType['slug'];

        $quiz['course_name'] = $course['name'];
        $quiz['course_id'] = $course['id'];
        $quiz['course_slug'] = $course['slug'];
        $quiz['module_id'] = $module['id'];
        $quiz['module_slug'] = $module['slug'];
        $quiz['ajax_watch_record'] = $resourceType['ajax_watch_record'];
        $quiz['timed_ajax_watch_record'] = $resourceType['timed_ajax_watch_record'];

        $totalQuestions = $this->getTotalQuizQuestions($courseSlug, $moduleSlug, $resourceSlug, $resourceType['id']);

        $quiz['totalQuestions'] = $totalQuestions;

        $quiz['previousResource'] = $this->getDataRecords->previousResource($course, $module, $quiz);
        $quiz['nextResource'] = $this->getDataRecords->nextResource($userId, $course, $module, $quiz);

        $quiz['canNewAttempt'] = true;

        /*
         * Quando não for possível pausar o questionário, e a tentativa anterior estiver em aberto,
         * esta tentativa deve ser concluída antes de se tentar iniciar uma nova tentativa
         */
        if (!$quiz['can_pause']) {
            if (empty($attempt)) {
                $attempt = null;
            } else {
                $attempt = [$attempt];
            }
            $unfinishedAttempt = $this->quizHasUnfinishedAttempt($userId, $courseSlug, $moduleSlug, $resourceSlug,
                $resourceType['id'], $attempt);
            if ($unfinishedAttempt) {
                $this->finishQuizAttempt($unfinishedAttempt['attempt'], $userId, $courseSlug, $moduleSlug,
                    $resourceSlug, $resourceType['slug']);
            }
        }

        /*
         * Verificar se o questionário tem as condições de Nova Tentativa e/ou Continuar Tentativa
         * quando puder pausar
         */
        if ($quiz['can_pause']) {
            //Verifica se existe alguma tentativa em aberto
            $unfinishedAttempt = $this->quizHasUnfinishedAttempt($userId, $courseSlug, $moduleSlug, $resourceSlug,
                $resourceType['id']);
            if ($unfinishedAttempt) {
                if ($unfinishedAttempt['attempt'] == $quiz['max_attempts']) {
                    $quiz['canNewAttempt'] = false;
                }
            }
        }

        return $quiz;
    }

    /**
     * @param $attempt
     * @param $userId
     * @param $courseSlug
     * @param $moduleSlug
     * @param $resourceSlug
     * @param $questionHash
     * @param $resourceTypeSlug
     * @return mixed
     */
    public function newQuizzAttempt(
        $attempt,
        $userId,
        $courseSlug,
        $moduleSlug,
        $resourceSlug,
        $questionHash,
        $resourceTypeSlug
    )
    {
        $course = $this->getDataRecords->getCourseBySlug($courseSlug);

        $module = $this->getDataRecords->getModuleBySlug($moduleSlug, $course['id']);
        $resourceType = $this->getDataRecords->getResourceTypeBySlug($resourceTypeSlug);
        $resource = $this->getDataRecords->getResourceByResourceSlug($resourceType['id'], $resourceSlug);

        $unfinishedAttempt = $this->quizHasUnfinishedAttempt($userId, $courseSlug, $moduleSlug, $resourceSlug,
            $resourceType['id']);
        if ($unfinishedAttempt) {
            $this->finishQuizAttempt($unfinishedAttempt['attempt'], $userId, $courseSlug, $moduleSlug, $resourceSlug,
                $resourceType['slug']);
            $attempt = $attempt + 1;
        }

        $totalQuestions = $this->getTotalQuizQuestions($courseSlug, $moduleSlug, $resourceSlug, $resourceType['id']);

        $this->newAttempt($userId, $course['id'], $module['id'], $resource['id'], $resource['resource_type_id'],
            $attempt, $totalQuestions);

        $quizQuestions = $this->getDataRecords->getQuizAllAvailableQuestions(
            $course['id'],
            $module['id'],
            $resource['id']
        );

        $quizQuestion = $quizQuestions->where('hash', $questionHash)->first();
        $currentKey = $quizQuestions->where('hash', $questionHash)->keys()->first();
        $question = $this->getQuestionWithAnswers($quizQuestion);
        $question['value'] = $quizQuestion['value'];
        $question['has_answer'] = 0;

        $question['previousQuestion'] = $this->getQuizPreviousQuestion($quizQuestions, $currentKey);
        $question['nextQuestion'] = $this->getQuizNextQuestion($quizQuestions, $currentKey);
        $question['currentQuestion'] = $currentKey + 1;
        return $question;
    }

    /**
     * @param $attempt
     * @param $userId
     * @param $courseSlug
     * @param $moduleSlug
     * @param $resourceSlug
     * @param $questionHash
     * @param $resourceTypeSlug
     * @return mixed
     */
    public function continueQuizzAttempt(
        $attempt,
        $userId,
        $courseSlug,
        $moduleSlug,
        $resourceSlug,
        $questionHash,
        $resourceTypeSlug
    )
    {
        $course = $this->getDataRecords->getCourseBySlug($courseSlug);
        $module = $this->getDataRecords->getModuleBySlug($moduleSlug, $course['id']);
        $resourceType = $this->getDataRecords->getResourceTypeBySlug($resourceTypeSlug);
        $resource = $this->getDataRecords->getResourceByResourceSlug($resourceType['id'], $resourceSlug);

        $quizQuestions = $this->getDataRecords->getQuizAllAvailableQuestions(
            $course['id'],
            $module['id'],
            $resource['id']
        );
        $quizQuestion = $quizQuestions->where('hash', $questionHash)->first();
        $currentKey = $quizQuestions->where('hash', $questionHash)->keys()->first();

        $question = $this->getQuestionWithAnswers($quizQuestion);
        $question['value'] = $quizQuestion['value'];
        $question['has_answer'] = 0;

        $hasAttempt = $this->quizHasUnfinishedAttempt($userId, $courseSlug, $moduleSlug, $resource['slug'],
            $resourceType['id']);

        if ($hasAttempt['details']) {
            $answer = $hasAttempt['details']->where('question_id', $question['id'])->first();
            $question['has_answer'] = $answer['answer_id'];
        }

        $question['previousQuestion'] = $this->getQuizPreviousQuestion($quizQuestions, $currentKey);
        $question['nextQuestion'] = $this->getQuizNextQuestion($quizQuestions, $currentKey);
        $question['currentQuestion'] = $currentKey + 1;
        $question['attempt'] = $hasAttempt['attempt'];
        return $question;
    }

    /**
     * @param $attempt
     * @param $userId
     * @param $courseSlug
     * @param $moduleSlug
     * @param $resourceSlug
     * @param $resourceTypeSlug
     */
    public function finishQuizAttempt($attempt, $userId, $courseSlug, $moduleSlug, $resourceSlug, $resourceTypeSlug)
    {
        $resourceType = $this->getDataRecords->getResourceTypeBySlug($resourceTypeSlug);

        if (!empty($attempt)) {
            $attempt = $this->getQuizAttempt($attempt, $userId, $courseSlug, $moduleSlug, $resourceSlug,
                $resourceTypeSlug);
        } else {
            $find = $this->quizHasUnfinishedAttempt($userId, $courseSlug, $moduleSlug, $resourceSlug,
                $resourceType['id']);
            $attempt = $this->getQuizAttempt($find['attempt'], $userId, $courseSlug, $moduleSlug, $resourceSlug,
                $resourceTypeSlug);
        }

        if (!$attempt) {
            $find = $this->quizHasUnfinishedAttempt($userId, $courseSlug, $moduleSlug, $resourceSlug,
                $resourceType['id']);
            $attempt = $this->getQuizAttempt($find['attempt'], $userId, $courseSlug, $moduleSlug, $resourceSlug,
                $resourceTypeSlug);
        }

        if ($attempt) {
            $course = $this->getDataRecords->getCourseBySlug($courseSlug);
            $module = $this->getDataRecords->getModuleBySlug($moduleSlug, $course['id']);
            $resource = $this->getDataRecords->getResourceByResourceSlug($resourceType['id'], $resourceSlug);

            $totalQuestions = $this->getTotalQuizQuestions($courseSlug, $moduleSlug, $resourceSlug,
                $resourceType['id']);
            $finalNote = 0.0;
            $answered = 0;
            $correct = 0;
            $incorrect = 0;
            if ($attempt['details']) {
                foreach ($attempt['details'] as $detail) {
                    $answered++;
                    if ($detail['correct']) {
                        $correct++;
                        $finalNote += $detail['value'];
                    } else {
                        $incorrect++;
                    }
                }
            }
            $unanswered = $totalQuestions - $answered;

            $summary = [
                'presented_questions' => $totalQuestions,
                'answered_questions' => $answered,
                'correct_questions' => $correct,
                'incorrect_questions' => $incorrect,
                'unanswered_questions' => $unanswered,
                'final_note' => $finalNote
            ];
            $attempt->summary()->update($summary);

            $this->recordRepository->create([
                'user_id' => $userId,
                'course_id' => $course['id'],
                'module_id' => $module['id'],
                'resource_id' => $resource['id'],
                'resource_type_id' => $resourceType['id'],
                'watched_at' => date('Y-m-d H:i:s'),
                'status' => 1
            ]);

            $attempt['completed'] = true;
            $attempt->save();
        }
    }

    /**
     * @param $attempt
     * @param $userId
     * @param $courseSlug
     * @param $moduleSlug
     * @param $resourceSlug
     * @param $resourceTypeId
     * @return mixed
     */
    public function isUnfinishedAttempt($attempt, $userId, $courseSlug, $moduleSlug, $resourceSlug, $resourceTypeId)
    {
        $attempt = (int)$attempt;
        $course = $this->getDataRecords->getCourseBySlug($courseSlug);
        $module = $this->getDataRecords->getModuleBySlug($moduleSlug, $course['id']);
        $resource = $this->getDataRecords->getResourceByResourceSlug($resourceTypeId, $resourceSlug);

        return $this->quizAttemptRepository->with(['details', 'summary'])
            ->findWhere([
                ['user_id', '=', $userId],
                ['course_id', '=', $course['id']],
                ['module_id', '=', $module['id']],
                ['resource_id', '=', $resource['id']],
                ['attempt', '=', $attempt],
                ['completed', '=', false]
            ])
            ->first();
    }

    /**
     * @param $userId
     * @param $courseSlug
     * @param $moduleSlug
     * @param $resourceSlug
     * @param $resourceTypeId
     * @param array $notInAttempt
     * @return mixed
     */
    public function quizHasUnfinishedAttempt(
        $userId,
        $courseSlug,
        $moduleSlug,
        $resourceSlug,
        $resourceTypeId,
        $notInAttempt = []
    )
    {
        $course = $this->getDataRecords->getCourseBySlug($courseSlug);
        $module = $this->getDataRecords->getModuleBySlug($moduleSlug, $course['id']);
        $resource = $this->getDataRecords->getResourceByResourceSlug($resourceTypeId, $resourceSlug);

        return $this->quizAttemptRepository->hasUnfinishedAttempt($userId, $course['id'], $module['id'],
            $resource['id'], $resourceTypeId, $notInAttempt);
    }

    /**
     * @param $courseSlug
     * @param $moduleSlug
     * @param $resourceSlug
     * @param $resourceTypeId
     * @return int
     */
    public function getTotalQuizQuestions($courseSlug, $moduleSlug, $resourceSlug, $resourceTypeId)
    {
        $course = $this->getDataRecords->getCourseBySlug($courseSlug);
        $module = $this->getDataRecords->getModuleBySlug($moduleSlug, $course['id']);
        $resource = $this->getDataRecords->getResourceByResourceSlug($resourceTypeId, $resourceSlug);

        return count($this->getDataRecords->getQuizAllAvailableQuestions(
            $course['id'],
            $module['id'],
            $resource['id']
        ));
    }

    /**
     * @param $userId
     * @param $courseSlug
     * @param $moduleSlug
     * @param $resourceSlug
     * @param $resourceTypeId
     * @param bool $onlyCompleted
     * @return mixed
     */
    public function quizHasPreviousAttempts($userId, $courseSlug, $moduleSlug, $resourceSlug, $resourceTypeId, $onlyCompleted = false)
    {
        $course = $this->getDataRecords->getCourseBySlug($courseSlug);
        $module = $this->getDataRecords->getModuleBySlug($moduleSlug, $course['id']);
        $resource = $this->getDataRecords->getResourceByResourceSlug($resourceTypeId, $resourceSlug);

        if ($onlyCompleted) {
            return $this->quizAttemptRepository->with(['details', 'summary'])
                ->orderBy('attempt')
                ->findWhere([
                    ['user_id', '=', $userId],
                    ['course_id', '=', $course['id']],
                    ['module_id', '=', $module['id']],
                    ['resource_id', '=', $resource['id']],
                    ['completed', '=', 1]
                ]);
        }
        return $this->quizAttemptRepository->with(['details', 'summary'])
            ->orderBy('attempt')
            ->findWhere([
                ['user_id', '=', $userId],
                ['course_id', '=', $course['id']],
                ['module_id', '=', $module['id']],
                ['resource_id', '=', $resource['id']],
            ]);
    }

    /**
     * @param $userId
     * @param $courseId
     * @param $resourceId
     * @return mixed
     */
    public function getQuizzAttempts($userId, $courseId, $resourceId)
    {
        return $this->quizAttemptRepository->with(['details', 'summary'])
            ->orderBy('attempt')
            ->findWhere([
                ['user_id', '=', $userId],
                ['course_id', '=', $courseId],
                ['resource_id', '=', $resourceId],
                ['completed', '=', 1]
            ]);
    }

    /**
     * @param $userId
     * @param $courseId
     * @param $resourceId
     * @return mixed
     */
    public function getQuizzAttemptSummaries($userId, $courseId, $resourceId)
    {
        return $this->quizAttemptRepository->with(['summary'])
            ->orderBy('attempt')
            ->findWhere([
                ['user_id', '=', $userId],
                ['course_id', '=', $courseId],
                ['resource_id', '=', $resourceId],
                ['completed', '=', 1]
            ]);
    }

    /**
     * @param $attempt
     * @param $userId
     * @param $courseSlug
     * @param $moduleSlug
     * @param $resourceSlug
     * @param $resourceTypeSlug
     * @return mixed
     */
    public function getQuizAttempt($attempt, $userId, $courseSlug, $moduleSlug, $resourceSlug, $resourceTypeSlug)
    {
        $course = $this->getDataRecords->getCourseBySlug($courseSlug);
        $module = $this->getDataRecords->getModuleBySlug($moduleSlug, $course['id']);
        $resourceType = $this->getDataRecords->getResourceTypeBySlug($resourceTypeSlug);
        $resource = $this->getDataRecords->getResourceByResourceSlug($resourceType['id'], $resourceSlug);

        return $this->quizAttemptRepository
            ->findWhere([
                ['user_id', '=', $userId],
                ['course_id', '=', $course['id']],
                ['module_id', '=', $module['id']],
                ['resource_id', '=', $resource['id']],
                ['attempt', '=', $attempt]
            ])->first();
    }

    /**
     * @param $quizQuestion
     * @return mixed
     */
    public function getQuestionWithAnswers($quizQuestion)
    {
        return $this->getDataRecords->getQuestionWithAnswersById($quizQuestion['question_id']);
    }

    /**
     * @param $questions
     * @param $current
     * @return array
     */
    private function getQuizPreviousQuestion($questions, $current)
    {
        if ($current == 0) {
            return ['hash' => null];
        }
        return ['hash' => $questions[$current - 1]['hash']];
    }

    /**
     * @param $questions
     * @param $current
     * @return array
     */
    private function getQuizNextQuestion($questions, $current)
    {
        $last = count($questions) - 1;
        if ($current == $last) {
            return ['hash' => null];
        }
        return ['hash' => $questions[$current + 1]['hash']];
    }

    /**
     * @param $userId
     * @param $courseId
     * @param $moduleId
     * @param $resourceId
     * @param $resourceTypeId
     * @param $attempt
     * @param $totalQuestions
     */
    private function newAttempt($userId, $courseId, $moduleId, $resourceId, $resourceTypeId, $attempt, $totalQuestions)
    {
        $attempt = $this->quizAttemptRepository->create([
            'user_id' => $userId,
            'course_id' => $courseId,
            'module_id' => $moduleId,
            'resource_id' => $resourceId,
            'resource_type_id' => $resourceTypeId,
            'attempt' => $attempt,
            'completed' => false
        ]);

        $attempt->summary()->create([
            'presented_questions' => $totalQuestions,
            'answered_questions' => 0,
            'correct_questions' => 0,
            'incorrect_questions' => 0,
            'unanswered_questions' => $totalQuestions,
            'final_note' => 0
        ]);
    }

    /**
     * @param $userId
     * @param $choice
     */
    public function confirmChoice($userId, $choice)
    {
        $attempt = $this->quizAttemptRepository
            ->findWhere(
                [
                    ['user_id', '=', $userId],
                    ['course_id', '=', $choice['course_id']],
                    ['module_id', '=', $choice['module_id']],
                    ['resource_id', '=', $choice['resource_id']],
                    ['resource_type_id', '=', $choice['resource_type_id']],
                    ['attempt', '=', $choice['attempt']],
                ]
            )->first();

        $check = $this->quizAttemptDetailRepository
            ->findWhere([
                ['quiz_attempt_id', '=', $attempt['id']],
                ['question_id', '=', $choice['question_id']]
            ])->first();

        if (count($check) == 0) {
            $this->quizAttemptDetailRepository->create(
                [
                    'quiz_attempt_id' => $attempt['id'],
                    'question_id' => $choice['question_id'],
                    'answer_id' => $choice['answer_id'],
                    'correct' => $choice['correct'],
                    'value' => $choice['value'],
                    'answer_attempts' => 1
                ]
            );
        }
    }

    /**
     * @param $userId
     * @param $courseSlug
     * @param $moduleSlug
     * @param $resourceSlug
     * @param $resourceTypeSlug
     * @return array
     */
    public function calculateFinalNoteByHighNote($userId, $courseSlug, $moduleSlug, $resourceSlug, $resourceTypeSlug)
    {
        $resourceType = $this->getDataRecords->getResourceTypeBySlug($resourceTypeSlug);
        $attempts = $this->quizHasPreviousAttempts($userId, $courseSlug, $moduleSlug, $resourceSlug,
            $resourceType['id']);

        $higherNote = 0.0;
        $attempKey = 0;
        foreach ($attempts as $key => $attempt) {
            if ($attempt['summary']['final_note'] > $higherNote) {
                $higherNote = $attempt['summary']['final_note'];
                $attempKey = $key;
            }
        }

        if (count($attempts) > 0) {
            $high = $attempts[$attempKey];
            $result = ['final_note' => $high['summary']['final_note']];
        } else {
            $result = ['final_note' => 0];
        }
        return $result;
    }

    /**
     * @param $userId
     * @param $courseSlug
     * @param $moduleSlug
     * @param $resourceSlug
     * @param $resourceTypeSlug
     * @return array
     */
    public function calculateFinalNoteByLastNote($userId, $courseSlug, $moduleSlug, $resourceSlug, $resourceTypeSlug)
    {
        $resourceType = $this->getDataRecords->getResourceTypeBySlug($resourceTypeSlug);

        $attempts = $this->quizHasPreviousAttempts($userId, $courseSlug, $moduleSlug, $resourceSlug,
            $resourceType['id']);

        $last = $attempts->last();
        $result = ['final_note' => $last['summary']['final_note']];
        return $result;
    }

    /**
     * @param $userId
     * @param $courseSlug
     * @param $moduleSlug
     * @param $resourceSlug
     * @param $resourceTypeSlug
     * @return array
     */
    public function calculateFinalNoteByAverageNote($userId, $courseSlug, $moduleSlug, $resourceSlug, $resourceTypeSlug)
    {
        $resourceType = $this->getDataRecords->getResourceTypeBySlug($resourceTypeSlug);
        $attempts = $this->quizHasPreviousAttempts($userId, $courseSlug, $moduleSlug, $resourceSlug,
            $resourceType['id']);

        $finishedAttempts = 0;
        $sumNotes = 0.0;
        foreach ($attempts as $key => $attempt) {
            if ($attempt['completed']) {
                $finishedAttempts++;
                $sumNotes += $attempt['summary']['final_note'];
            }
        }

        $average = null;
        if (!empty($finishedAttempts)) {
            $average = round(($sumNotes / $finishedAttempts), 2);
        }
        $result = ['final_note' => $average];
        return $result;
    }

    /**
     * @param $averageType
     * @param $userId
     * @param $courseSlug
     * @param $moduleSlug
     * @param $resourceSlug
     * @param $resourceTypeSlug
     * @return array
     */
    public function getFinalNote($averageType, $userId, $courseSlug, $moduleSlug, $resourceSlug, $resourceTypeSlug)
    {
        switch ($averageType) {
            case 1 :
                return $this->calculateFinalNoteByLastNote($userId, $courseSlug, $moduleSlug, $resourceSlug,
                    $resourceTypeSlug);
            case 2 :
                return $this->calculateFinalNoteByAverageNote($userId, $courseSlug, $moduleSlug, $resourceSlug,
                    $resourceTypeSlug);
            case 3 :
                return $this->calculateFinalNoteByHighNote($userId, $courseSlug, $moduleSlug, $resourceSlug,
                    $resourceTypeSlug);
            default :
                return ['final_note' => trans('messages.avaliationWhitoutAverage')];
        }

    }

    /**
     * @param $userId
     * @param $courseSlug
     * @param $moduleSlug
     * @param $resourceTypeSlug
     * @param $resourceSlug
     */
    public function setBadge($userId, $courseSlug, $moduleSlug, $resourceTypeSlug, $resourceSlug)
    {
        $course = $this->getDataRecords->getCourseBySlug($courseSlug);
        $resourceType = $this->getDataRecords->getResourceTypeBySlug($resourceTypeSlug);
        $resource = $this->getDataRecords->getResourceByResourceSlug($resourceType['id'], $resourceSlug);

        $rules = $this->badgeRule->with(['badge', 'ruleType'])
            ->findWhere(
                [
                    ['course_id', '=', $course['id']]
                ]
            )
            ->all();

        $appliedBadge = null;
        foreach ($rules as $key => $rule) {
            $finalNote = $this->getFinalNote(
                $resource['average_rule'],
                $userId,
                $courseSlug,
                $moduleSlug,
                $resourceSlug,
                $resourceTypeSlug
            )['final_note'];

            $badgeRule = $this->quizWithAverageBetween
                ->with(['resource'])
                ->findWhere([
                    ['badge_rule_id', '=', $rule['id']],
                    ['resource_type_id', '=', $resourceType['id']],
                    ['resource_id', '=', $resource['id']]
                ])
                ->first();

            if ($badgeRule && ($finalNote >= $badgeRule['average_min'] && $finalNote <= $badgeRule['average_max'])) {
                $appliedBadge = [
                    'user_id' => $userId,
                    'course_id' => $rule['course_id'],
                    'resource_type_id' => $resourceType['id'],
                    'resource_id' => $resource['id'],
                    'badge_rule_id' => $rule['id'],
                    'badge_id' => $rule['badge_id'],
                    'value' => $rule['value']
                ];
            }
        }

        if ($appliedBadge) {
            $hasBadge = $this->acquiredBadge->findWhere([
                ['user_id', '=', $userId],
                ['course_id', '=', $appliedBadge['course_id']],
                ['resource_type_id', '=', $appliedBadge['resource_type_id']],
                ['resource_id', '=', $appliedBadge['resource_id']]
            ])->first();

            if ($hasBadge) {
                $this->acquiredBadge->update($appliedBadge, $hasBadge['id']);
            } else {
                $this->acquiredBadge->create($appliedBadge);
            }
        }
    }

    /**
     * @param $attempId
     * @return array
     */
    public function resetLastAttemp($attempId)
    {
        try {
            $summary = $this->quizAttemptSummary->findWhere(
                [
                    ['quiz_attempt_id', '=', $attempId]
                ]
            )->first();
            $this->quizAttemptSummary->delete($summary->id);

            /*$this->quizAttemptSummary->update([
                'presented_question' => 0,
                'answered_questions' => 0,
                'correct_questions' => 0,
                'incorrect_questions' => 0,
                'unanswered_questions' => 0,
                'final_note' => 0
            ],
                $summary->id
            );*/

            $this->quizAttemptDetailRepository->deleteByField('quiz_attempt_id', '=', $attempId);
            $this->quizAttemptRepository->delete($attempId);

            /*$this->quizAttemptRepository->update([
                'completed' => 0
            ],
                $attempId
            );*/

            return [
                'success' => true,
                'message' => 'Última tentativa resetada.'
            ];
        } catch (\Exception $e) {
            app(Handler::class)->report($e);
            return [
                'success' => false,
                'message' => $e->getMessage()
            ];
        }
    }
}