eagle.ead.lmsestudio.com.br

UnknownSec Bypass 403

: /mnt/lmsestudio-instance-vol002/lms_0f60b15cfe7d/app/Services/Environment/ [ drwxr-xr-x ]
name : CourseService.php
 <?php namespace EstudioLMS\Services\Environment;

use EstudioLMS\Helpers\GetDataRecords;
use EstudioLMS\Repositories\Courses\Course\CourseResourceRepository;
use EstudioLMS\Repositories\Environment\HiredCourseRepository;
use EstudioLMS\Repositories\Environment\RecordRepository;

/**
 * Class CourseService
 * @package EstudioLMS\Services\Environment
 */
class CourseService
{
    /**
     * @var RecordRepository
     */
    private $recordRepository;
    /**
     * @var CourseResourceRepository
     */
    private $courseResourceRepository;
    /**
     * @var GetDataRecords
     */
    private $getDataRecords;
    /**
     * @var QuizService
     */
    private $quizService;

    /**
     * CourseService constructor.
     * @param RecordRepository $recordRepository
     * @param CourseResourceRepository $courseResourceRepository
     * @param GetDataRecords $getDataRecords
     * @param QuizService $quizService
     * @param HiredCourseRepository $hiredCourseRepository
     */
    public function __construct(
        RecordRepository $recordRepository,
        CourseResourceRepository $courseResourceRepository,
        GetDataRecords $getDataRecords,
        QuizService $quizService,
        HiredCourseRepository $hiredCourseRepository
    )
    {
        $this->recordRepository = $recordRepository;
        $this->courseResourceRepository = $courseResourceRepository;
        $this->getDataRecords = $getDataRecords;
        $this->quizService = $quizService;
        $this->hiredCourseRepository = $hiredCourseRepository;
    }

    /**
     * @param $userId
     * @return mixed
     */
    public function allCoursesByStudent($userId)
    {
        $hiredCourses = $this->hiredCourseRepository->with(['course'])
            ->findWhere([['user_id', '=', $userId]])
            ->all();

        return $hiredCourses;
    }

    /**
     * @param $userId
     * @param bool $lists
     * @return array|static[]
     */
    public function allCoursesByStudentWithAverageResources($userId, $lists = false)
    {
        $hiredCourses = \DB::table('hired_courses')
            ->join('courses', 'hired_courses.course_id', '=', 'courses.id')
            ->where('hired_courses.user_id', '=', $userId)
            ->where('courses.average', '>', 0);

        if ($lists) {
            return $hiredCourses->lists('courses.name', 'courses.id');
        }

        $hiredCourses = $hiredCourses->get();
        $hiredCourses = json_decode(json_encode($hiredCourses), true);

        return $hiredCourses;
    }

    /**
     * @param $courseId
     * @param bool $lists
     * @return $this|array|mixed
     */
    public function allQuizzesByCourse($courseId, $lists = false)
    {
        $quizzes = \DB::table('courses')
            ->join('course_resources', 'courses.id', '=', 'course_resources.course_id')
            ->join('quizzes', 'course_resources.resource_id', '=', 'quizzes.id')
            ->where('course_resources.resource_type_id', '=', 9)
            ->where('courses.id', '=', $courseId);

        if ($lists) {
            return $quizzes->lists('quizzes.title', 'quizzes.id');
        }

        return json_decode(json_encode($quizzes->get()), true);
    }

    /**
     * @param $courseId
     * @param bool $lists
     * @return $this|array|mixed
     */
    public function allQuizzesWithAverageByCourse($courseId, $lists = false)
    {
        $quizzes = \DB::table('courses')
            ->join('course_resources', 'courses.id', '=', 'course_resources.course_id')
            ->join('quizzes', 'course_resources.resource_id', '=', 'quizzes.id')
            ->where('course_resources.resource_type_id', '=', 9)
            ->where('quizzes.make_final_note', '=', 1)
            ->where('courses.id', '=', $courseId);

        if ($lists) {
            return $quizzes->lists('quizzes.title', 'quizzes.id');
        }

        return json_decode(json_encode($quizzes->get()), true);
    }

    /**
     * @param $courseId
     * @param bool $lists
     * @return mixed
     */
    public function allResourceTypesByCourse($courseId, $lists = false)
    {
        $resources = $this->courseResourceRepository->allResourcesThatCanBeViewedByCourse($courseId);

        if ($lists) {
            return $resources->lists('resourceType.title', 'resource_type_id');
        }

        return $resources;
    }

    /**
     * @param $userId
     * @param bool $lists
     * @return $this|array|mixed
     *
     * Se não passar o parâmetro $userId, irá retornar todos os cursos de todos os professores
     */
    public function allCoursesByTeacher($userId, $lists = false)
    {
        $courses = \DB::table('courses')
            ->join('users', 'courses.user_id', '=', 'users.id')
            ->select(
                [
                    'courses.id', 'courses.name', 'courses.user_id'
                ]
            )->whereNull('courses.deleted_at');

        if (!empty($userId)) {
            $courses->where('courses.user_id', '=', $userId);
        }

        if ($lists) {
            return $courses->lists('courses.name', 'courses.id');
        }

        $courses = $courses->get();
        $courses = json_decode(json_encode($courses), true);

        return $courses;
    }

    /**
     * @param $userId
     * @param bool $lists
     * @return $this|array|mixed
     *
     * Se não passar o parâmetro $userId, irá retornar todos os cursos de todos os professores
     */
    public function allCoursesByTeacherWithAverageResources($userId, $lists = false)
    {
        $courses = \DB::table('courses')
            ->join('users', 'courses.user_id', '=', 'users.id')
            ->where('courses.average', '>', 0)
            ->select(
                [
                    'courses.id', 'courses.name', 'courses.user_id'
                ]
            );

        if (!empty($userId)) {
            $courses->where('courses.user_id', '=', $userId);
        }

        if ($lists) {
            return $courses->lists('courses.name', 'courses.id');
        }

        $courses = $courses->get();
        $courses = json_decode(json_encode($courses), true);

        return $courses;
    }

    /**
     * @param $userId
     * @param $courseId
     * @return int
     */
    public function totalWatchedLessons($userId, $courseId)
    {
        return count($this->recordRepository->getRecordsGrouped($userId, $courseId));
    }

    /**
     * @param $courseId
     * @return int
     */
    public function totalCourseLessons($courseId)
    {
        return $this->courseResourceRepository->countAllCourseLessons($courseId);
    }

    /**
     * @param $courseId
     * @param $userId
     * @return null
     */
    public function getAllAttemptsOfEvaluationsWithAverageByCourse($courseId, $userId)
    {
        $evaluations = $this->courseResourceRepository
            ->findWhere([
                ['course_id', '=', $courseId],
                /*['consists_average', '=', true]*/
                ['resource_type_id', '=', 9]
            ]);

        $count = 0;
        $result = null;
        foreach ($evaluations as $key => $evaluation) {
            $course = $this->getDataRecords->getCourseById($evaluation['course_id']);
            $module = $this->getDataRecords->getModuleById($evaluation['module_id']);
            $resource = $this->getDataRecords->getResourceByResourceId($evaluation['resource_type_id'], $evaluation['resource_id']);
            $attempts = $this->quizService->quizHasPreviousAttempts($userId, $course['slug'], $module['slug'], $resource['slug'], $evaluation['resource_type_id'], true);
            $resourceType = $this->getDataRecords->getResourceTypeById($evaluation['resource_type_id']);
            $student = $this->getDataRecords->getUserProfile($userId);

            foreach ($attempts as $id => $attempt) {
                $result[$count]['attempts'][] = [
                    'attempt' => $attempt['attempt'],
                    'completed' => $attempt['completed'],
                    'presented_questions' => $attempt['summary']['presented_questions'],
                    'answered_questions' => $attempt['summary']['answered_questions'],
                    'correct_questions' => $attempt['summary']['correct_questions'],
                    'incorrect_questions' => $attempt['summary']['incorrect_questions'],
                    'unanswered_questions' => $attempt['summary']['unanswered_questions'],
                    'final_note' => $attempt['summary']['final_note'],
                    'quiz_attempt_id' => $attempt['id']
                ];
            }
            $result[$count]['final_note'] = $this->quizService->getFinalNote(
                $resource['average_rule'],
                $userId, $course['slug'],
                $module['slug'],
                $resource['slug'],
                $resourceType['slug']
            );
            $result[$count]['course_id'] = $course['id'];
            $result[$count]['course_name'] = $course['name'];
            $result[$count]['module_name'] = $module['name'];
            $result[$count]['resource_title'] = $resource['title'];
            $result[$count]['resource_id'] = $resource['id'];
            $result[$count]['student_id'] = $student['id'];
            $result[$count]['student_name'] = $student['name'];
            $result[$count]['student_email'] = $student['email'];
            $result[$count]['resource_type_name'] = $resourceType['title'];
            $result[$count]['resource_type_id'] = $resourceType['id'];
            $result[$count]['minimum_note'] = $resource['approval_minimum_note'];
            $result[$count]['approved'] = $result[$count]['final_note']['final_note'] >= $result[$count]['minimum_note'] ? true : false;
            $count++;
        }
        return $result;
    }

    /**
     * @param $userId
     * @param $courseId
     * @return bool
     */
    public function checkIfCourseHasCompleted($userId, $courseId)
    {
        $course = $this->getDataRecords->getCourseById($courseId);
        if ($course->course_status_id == 2) {
            return false;
        }

        $watched = $this->recordRepository->getRecordsGrouped($userId, $courseId);
        $totalLesson = $this->courseResourceRepository->countAllCourseLessons($courseId);

        $completed = false;

        if (count($watched) >= $totalLesson) {
            $completed = true;
        }

        return $completed;
    }

    /**
     * @param $userId
     * @param $courseId
     * @return array
     */
    public function hasStudentPassedInCourse($userId, $courseId)
    {
        $course = $this->getDataRecords->getCourseById($courseId);

        if ($course->requirement_certificate_id == 2) {
            if (!$this->checkIfCourseHasCompleted($userId, $courseId)) {
                return [
                    'approved' => false,
                    'message' => trans('ambiente_my-courses.notCompleted'),
                    'average' => 0
                ];
            }
        }

        $average = $course->average;

        if ($average > 0) {
            $quizzes = $this->courseResourceRepository->findWhere([
                ['course_id', '=', $courseId],
                ['consists_average', '=', 1]
            ]);

            $myAverages = [];

            foreach ($quizzes as $quiz) {
                $module = $this->getDataRecords->getModuleById($quiz['module_id']);
                $resource = $this->getDataRecords->getResourceByResourceId($quiz['resource_type_id'], $quiz['resource_id']);
                $resourceType = $this->getDataRecords->getResourceTypeById($quiz['resource_type_id']);

                $quizAverage = $this->quizService->getFinalNote(
                    $resource['average_rule'],
                    $userId,
                    $course['slug'],
                    $module['slug'],
                    $resource['slug'],
                    $resourceType['slug']
                )['final_note'];

                $myAverages[] = [
                    'user_id' => $userId,
                    'resource_id' => $resource['id'],
                    'final_note' => $quizAverage
                ];
            }

            $count = 0;
            $sumAverages = 0;

            if ($myAverages) {
                foreach ($myAverages as $myAverage) {
                    $sumAverages += $myAverage['final_note'];
                    $count++;
                }

                if (($sumAverages / $count) < $average) {
                    return [
                        'approved' => false,
                        'message' => trans('ambiente_my-courses.repproved'),
                        'average' => ($sumAverages / $count)
                    ];
                }
                return [
                    'approved' => true,
                    'message' => trans('ambiente_my-courses.approved'),
                    'average' => ($sumAverages / $count)
                ];
            } else {
                return [
                    'approved' => false,
                    'message' => '',
                    'average' => 0
                ];
            }
        }
        return [
            'approved' => true,
            'message' => trans('ambiente_my-courses.courseWithoutAverage'),
            'average' => '100% de aulas ralizadas.'
        ];
    }

    /**
     * @param $attemptId
     * @return array
     */
    public function resetLastAttempt($attemptId)
    {
        return $this->quizService->resetLastAttemp($attemptId);
    }
}