eagle.ead.lmsestudio.com.br

UnknownSec Bypass 403

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

namespace EstudioLMS\Services\Environment;

use EstudioLMS\Helpers\GetDataRecords;
use EstudioLMS\Helpers\Helpers;
use EstudioLMS\Repositories\Courses\Course\CourseResourceRepository;
use EstudioLMS\Repositories\Environment\HiredCourseRepository;
use EstudioLMS\Repositories\Environment\RecordRepository;
use EstudioLMS\Services\Admin\ConfigurationServices;
use Illuminate\Pagination\LengthAwarePaginator;
use Illuminate\Support\Facades\DB;

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

    /**
     * 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 $teacherId
     * @return array
     */
    public function listsAllCoursesByTeacherWithQuizz($teacherId)
    {
        return DB::table('course_resources AS cr')
            ->join('courses AS c', 'cr.course_id', '=', 'c.id')
            ->where('cr.resource_type_id', '9')
            ->where('c.user_id', $teacherId)
            ->groupBy('cr.course_id')
            ->lists('c.name', 'c.id');
    }

    /**
     * @return array
     */
    public function listsAllCoursesWithQuizz()
    {
        return DB::table('course_resources AS cr')
            ->join('courses AS c', 'cr.course_id', '=', 'c.id')
            ->where('cr.resource_type_id', '9')
            ->whereNull('cr.deleted_at')
            ->groupBy('cr.course_id')
            ->lists('c.name', 'c.id');
    }

    /**
     * @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
     * @param bool $onlyAvailable
     * @return int
     */
    public function totalCourseLessons($courseId, $onlyAvailable = true)
    {
        return $this->courseResourceRepository->countAllCourseLessons($courseId, $onlyAvailable);
    }

    /**
     * @param $courseId
     * @param null $userId
     * @param bool $withAverage
     */
    public function getAllAttemptsOfEvaluationsWithAverageByCourse($courseId, $userId = null, $withAverage = true)
    {
        $evaluations = DB::table('course_resources')
            ->where('course_id', $courseId)
            ->where('resource_type_id', 9)
            ->whereNull('deleted_at');

        if($withAverage) {
            $evaluations->where('consists_average', 1);
        }

        $evaluations = $evaluations->get();

        $courseSlug = $this->getDataRecords->getCourseById($courseId)->slug;

        $students = $this->courseStudents($courseId, $userId);
        $courseResult = $this->wasApprovedInTheCourse($userId, $courseId);
        $evaluationsResults = [];
        $attemptsResults = [];

        foreach ($evaluations as $evaluation) {
            $resource = $this->getDataRecords->getResourceByResourceId($evaluation->resource_type_id, $evaluation->resource_id);
            $moduleSlug = $this->getDataRecords->getModuleById($evaluation->module_id)->slug;
            $resourceType = $this->getDataRecords->getResourceTypeById($evaluation->resource_type_id);
            foreach ($students as $student) {
                if(!empty($resource->average_rule)) {
                    $finalNote = $this->quizService->getFinalNote($resource->average_rule, $student->id, $courseSlug, $moduleSlug, $resource->slug, $resourceType->slug)['final_note'];
                } else {
                    $finalNote = 'N/A';
                }
                $pupil = $this->getDataRecords->getUserProfile($student->id);
                $attempts = $this->quizService->getQuizzAttempts($student->id, $courseId, $evaluation->resource_id);

                if(count($attempts) > 0) {
                    if(!empty($resource->average_rule)) {
                        $approved = $finalNote >= $resource->approval_minimum_note ? 'Aprovado' : 'Reprovado';
                    } else {
                        $approved = null;
                    }
                } else {
                    $approved = 'Sem tentativas';
                }
                $attemptsResults[] = ['student_name' => $pupil->name, 'student_id' => $pupil->id, 'resource_id' => $evaluation->resource_id, 'attempts' => $attempts,
                    'average_rule' => $resource->average_rule, 'course_slug' => $courseSlug, 'module_slug' => $moduleSlug, 'resource_slug' => $resource->slug, 'resource_type_slug' => $resourceType->slug,
                    'final_note' => $finalNote, 'approved' => $approved];
            }
            $evaluationsResults[] = ['evaluation_name' => $resource->title, 'students' => $attemptsResults];
            $attemptsResults = [];
        }
        return $evaluationsResults;
    }

    /**
     * @param $courseId
     * @param $usersId
     * @param int $page
     * @return array
     */
    public function getAllAttemptsOfEvaluationsWithAverageByCourseAllStudents($courseId, $usersId, $page = 1)
    {
        $results = null;
        $count = 0;
        foreach ($usersId as $userId) {
            $temp = $this->getAllAttemptsOfEvaluationsWithAverageByCourse($courseId, $userId, false);
            if (!is_null($temp)) {
                $results[] = $temp;
                $count++;
            }
        }
        return $results;
    }

    /**
     * @param $userId
     * @param $courseId
     * @return bool
     */
    public function checkIfCourseHasCompleted($userId, $courseId)
    {
        $completedCourse = $this->hiredCourseRepository
            ->with(['course'])
            ->findWhere([
                ['user_id', '=', $userId],
                ['course_id', '=', $courseId]
            ])->first();

        if ($completedCourse->course->course_status_id == 2)
            return false;

        if (!is_null($completedCourse->completed_at))
            return true;

        return false;
    }

    /**
     * @param $userId
     * @param $courseId
     * @return bool
     */
    public function checkIfCourseHasCompletedByLessons($userId, $courseId)
    {
        $config = app(ConfigurationServices::class)->configuration();
        $onlyAvailable = $config->count_only_enabled_resources;

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

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

        return $completed;
    }

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

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

            $lessons = $this->courseResourceRepository->findWhere([
                ['course_id', '=', $courseId],
                ['consists_average', '=', 1]
            ]);

            $myAverages = [];

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

                if ($lesson['resource_type_id'] == 9) { // Questionários
                    $quizAverage = $this->quizService->getFinalNote(
                        $resource['average_rule'],
                        $userId,
                        $course['slug'],
                        $module['slug'],
                        $resource['slug'],
                        $resourceType['slug']
                    )['final_note'];

                    $myAverages[] = [
                        'user_id' => $userId,
                        'resource_type_id' => $lesson['resource_type_id'],
                        'resource_id' => $resource['id'],
                        'final_note' => $quizAverage
                    ];
                } elseif ($lesson['resource_type_id'] == 15) { // Lição tipo tarefa
                    $tasks = DB::table('task_sents')
                        ->where('course_id', $courseId)
                        ->where('task_lesson_id', $lesson['resource_id'])
                        ->where('user_id', $userId)
                        ->get();
                    foreach ($tasks as $key => $task) {
                        $myAverages[] = [
                            'user_id' => $userId,
                            'resource_type_id' => $lesson['resource_type_id'],
                            'resource_id' => $resource['id'],
                            'final_note' => $task->final_note
                        ];
                    }
                }
            }
            //dd($myAverages);
            $count = 0;
            $sumAverages = 0;

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

                if (($sumAverages / $count) < $average) {
                    return [
                        'approved' => 2,
                        'message' => trans('ambiente_my-courses.repproved'),
                        'average' => ($sumAverages / $count)
                    ];
                }
                return [
                    'approved' => 1,
                    'message' => trans('ambiente_my-courses.approved'),
                    'average' => ($sumAverages / $count)
                ];
            } else {
                return [
                    'approved' => 2,
                    'message' => 'ambiente_my-courses.studentWithoutAverage',
                    'average' => 0
                ];
            }
        }

        return [
            'approved' => 0,
            'message' => trans('ambiente_my-courses.courseWithoutAverage'),
            'average' => '100% de aulas ralizadas.'
        ];
    }

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

    /**
     * @return \Illuminate\Support\Collection
     */
    public function courseStudents($courseId, $studentId = null)
    {
        // Buscar alunos matriculados (hired_courses) com status ativo
        $hiredStudents = DB::table('hired_courses AS hc')
            ->join('courses AS c', 'hc.course_id', '=', 'c.id')
            ->join('users AS u', 'hc.user_id', '=', 'u.id')
            ->where('hc.course_id', $courseId)
            ->whereIn('hc.status', [3, 4]) // Status ativo
            ->whereNull('u.deleted_at');

        if (!empty($studentId)) {
            $hiredStudents = $hiredStudents->where('hc.user_id', $studentId);
        }

        $results = $hiredStudents->select('u.id AS id', 'u.name AS name', 'u.email AS email')
            ->distinct()
            ->get();

        $students = collect();

        foreach ($results as $result) {
            $students->push($result);
        }

        return $students;
    }

    /**
     * @param $studentId
     * @param $lists
     * @return array|mixed
     */
    public function getAllCoursesByStudentWithAverage($studentId, $lists = false)
    {
        $hiredCourses = DB::table('course_histories AS CH')
            ->join('courses AS C', 'CH.course_id', '=', 'C.id')
            ->where('CH.user_id', '=', $studentId)
            ->where('C.average', '>', 0)
            ->groupBy('CH.course_id');

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

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

        return $hiredCourses;
    }
}