eagle.ead.lmsestudio.com.br

UnknownSec Bypass 403

: /var/www/html/lms_dc0466640eeb/app/Helpers/ [ drwxr-xr-x ]
name : GetDataRecords.php
 <?php namespace EstudioLMS\Helpers;

use EstudioLMS\Repositories\Auth\UserRepository;
use EstudioLMS\Repositories\Courses\Course\CourseRepository;
use EstudioLMS\Repositories\Courses\Course\CourseResourceRepository;
use EstudioLMS\Repositories\Courses\Course\ModuleRepository;
use EstudioLMS\Repositories\Courses\Resources\AttachmentLessonInterface;
use EstudioLMS\Repositories\Courses\Resources\CodeLessonInterface;
use EstudioLMS\Repositories\Courses\Resources\HotPotatoesLessonInterface;
use EstudioLMS\Repositories\Courses\Resources\LinkLessonInterface;
use EstudioLMS\Repositories\Courses\Resources\Questions\MultipleChoiceAnswerInterface;
use EstudioLMS\Repositories\Courses\Resources\Questions\MultipleChoiceInterface;
use EstudioLMS\Repositories\Courses\Resources\QuizInterface;
use EstudioLMS\Repositories\Courses\Resources\QuizQuestionInterface;
use EstudioLMS\Repositories\Courses\Resources\ResourceTypeInterface;
use EstudioLMS\Repositories\Courses\Resources\SlideShareLessonInterface;
use EstudioLMS\Repositories\Courses\Resources\TextLessonInterface;
use EstudioLMS\Repositories\Courses\Resources\VideoLessonInterface;
use EstudioLMS\Repositories\Courses\Resources\VimeoLiveLessonInterface;
use EstudioLMS\Repositories\Courses\Resources\YoutubeLiveLessonInterface;
use EstudioLMS\Repositories\Courses\Resources\VideoUploadLessonInterface;
use EstudioLMS\Repositories\Environment\RecordRepository;

class GetDataRecords
{
    /**
     * @var CourseRepository
     */
    private $courseRepository;
    /**
     * @var ModuleRepository
     */
    private $moduleRepository;
    /**
     * @var CourseResourceRepository
     */
    private $courseResourceRepository;
    /**
     * @var QuizInterface
     */
    private $quizRepository;
    /**
     * @var ResourceTypeInterface
     */
    private $resourceTypeRepository;
    /**
     * @var VideoLessonInterface
     */
    private $videoLessonRepository;
    /**
     * @var CodeLessonInterface
     */
    private $codeLessonRepository;
    /**
     * @var TextLessonInterface
     */
    private $textLessonRepository;
    /**
     * @var AttachmentLessonInterface
     */
    private $attachmentLessonRepository;
    /**
     * @var LinkLessonInterface
     */
    private $linkLessonRepository;
    /**
     * @var HotPotatoesLessonInterface
     */
    private $hotPotatoesLessonRepository;
    /**
     * @var SlideShareLessonInterface
     */
    private $slideShareLessonRepository;
    /**
     * @var RecordRepository
     */
    private $recordRepository;
    /**
     * @var QuizQuestionInterface
     */
    private $quizQuestionRepository;
    /**
     * @var MultipleChoiceInterface
     */
    private $multipleChoiceRepository;
    /**
     * @var MultipleChoiceAnswerInterface
     */
    private $multipleChoiceAnswerRepository;
    /**
     * @var UserRepository
     */
    private $userRepository;
    /**
     * @var YoutubeLiveLessonInterface
     */
    private $youtubeLiveLessonRepository;
    /**
     * @var VimeoLiveLessonInterface
     */
    private $vimeoLiveLessonRepository;
    /**
     * @var VideoUploadLessonInterface
     */
    private $videoUploadLessonRepository;

    /**
     * GetDataRecords constructor.
     * @param CourseRepository $courseRepository
     * @param ModuleRepository $moduleRepository
     * @param CourseResourceRepository $courseResourceRepository
     * @param QuizInterface $quizRepository
     * @param ResourceTypeInterface $resourceTypeRepository
     * @param VideoLessonInterface $videoLessonRepository
     * @param CodeLessonInterface $codeLessonRepository
     * @param TextLessonInterface $textLessonRepository
     * @param AttachmentLessonInterface $attachmentLessonRepository
     * @param LinkLessonInterface $linkLessonRepository
     * @param HotPotatoesLessonInterface $hotPotatoesLessonRepository
     * @param SlideShareLessonInterface $slideShareLessonRepository
     * @param RecordRepository $recordRepository
     * @param QuizQuestionInterface $quizQuestionRepository
     * @param MultipleChoiceInterface $multipleChoiceRepository
     * @param MultipleChoiceAnswerInterface $multipleChoiceAnswerRepository
     * @param UserRepository $userRepository
     * @param YoutubeLiveLessonInterface $youtubeLiveLessonRepository
     * @param VimeoLiveLessonInterface $vimeoLiveLessonRepository
     * @param VideoUploadLessonInterface $videoUploadLessonRepository
     */
    public function __construct(
        CourseRepository $courseRepository,
        ModuleRepository $moduleRepository,
        CourseResourceRepository $courseResourceRepository,
        QuizInterface $quizRepository,
        ResourceTypeInterface $resourceTypeRepository,
        VideoLessonInterface $videoLessonRepository,
        CodeLessonInterface $codeLessonRepository,
        TextLessonInterface $textLessonRepository,
        AttachmentLessonInterface $attachmentLessonRepository,
        LinkLessonInterface $linkLessonRepository,
        HotPotatoesLessonInterface $hotPotatoesLessonRepository,
        SlideShareLessonInterface $slideShareLessonRepository,
        RecordRepository $recordRepository,
        QuizQuestionInterface $quizQuestionRepository,
        MultipleChoiceInterface $multipleChoiceRepository,
        MultipleChoiceAnswerInterface $multipleChoiceAnswerRepository,
        UserRepository $userRepository,
        YoutubeLiveLessonInterface $youtubeLiveLessonRepository,
        VimeoLiveLessonInterface $vimeoLiveLessonRepository,
        VideoUploadLessonInterface $videoUploadLessonRepository
    )
    {
        $this->courseRepository = $courseRepository;
        $this->moduleRepository = $moduleRepository;
        $this->courseResourceRepository = $courseResourceRepository;
        $this->quizRepository = $quizRepository;
        $this->resourceTypeRepository = $resourceTypeRepository;
        $this->videoLessonRepository = $videoLessonRepository;
        $this->codeLessonRepository = $codeLessonRepository;
        $this->textLessonRepository = $textLessonRepository;
        $this->attachmentLessonRepository = $attachmentLessonRepository;
        $this->linkLessonRepository = $linkLessonRepository;
        $this->hotPotatoesLessonRepository = $hotPotatoesLessonRepository;
        $this->slideShareLessonRepository = $slideShareLessonRepository;
        $this->recordRepository = $recordRepository;
        $this->quizQuestionRepository = $quizQuestionRepository;
        $this->multipleChoiceRepository = $multipleChoiceRepository;
        $this->multipleChoiceAnswerRepository = $multipleChoiceAnswerRepository;
        $this->userRepository = $userRepository;
        $this->youtubeLiveLessonRepository = $youtubeLiveLessonRepository;
        $this->vimeoLiveLessonRepository = $vimeoLiveLessonRepository;
        $this->videoUploadLessonRepository = $videoUploadLessonRepository;
    }

    /**
     * @param $resourceTypeId
     * @param $resourceId
     * @return mixed
     */
    public function getResourceByResourceId($resourceTypeId, $resourceId = 0)
    {
        switch ($resourceTypeId) {
            case 2 :
                if ($resourceId == 0) {
                    return $this->videoLessonRepository->all();
                }
                return $this->videoLessonRepository->find($resourceId);
            case 3 :
                if ($resourceId == 0) {
                    return $this->codeLessonRepository->all();
                }
                return $this->codeLessonRepository->find($resourceId);
            case 4 :
                if ($resourceId == 0) {
                    return $this->textLessonRepository->all();
                }
                return $this->textLessonRepository->find($resourceId);
            case 5 :
                if ($resourceId == 0) {
                    return $this->attachmentLessonRepository->all();
                }
                return $this->attachmentLessonRepository->find($resourceId);
            case 6 :
                if ($resourceId == 0) {
                    return $this->linkLessonRepository->all();
                }
                return $this->linkLessonRepository->find($resourceId);
            case 7 :
                if ($resourceId == 0) {
                    return $this->hotPotatoesLessonRepository->all();
                }
                return $this->hotPotatoesLessonRepository->find($resourceId);
            case 8 :
                if ($resourceId == 0) {
                    return $this->slideShareLessonRepository->all();
                }
                return $this->slideShareLessonRepository->find($resourceId);
            case 9 :
                if ($resourceId == 0) {
                    return $this->quizRepository->all();
                }
                return $this->quizRepository->find($resourceId);
            case 10 :
                if ($resourceId == 0) {
                    return $this->youtubeLiveLessonRepository->all();
                }
                return $this->youtubeLiveLessonRepository->find($resourceId);
            case 11 :
                if ($resourceId == 0) {
                    return $this->vimeoLiveLessonRepository->all();
                }
                return $this->vimeoLiveLessonRepository->find($resourceId);
            case 12 :
                if ($resourceId == 0) {
                    return $this->videoUploadLessonRepository->all();
                }
                return $this->videoUploadLessonRepository->find($resourceId);
            default:
                return false;
        }
    }

    public function getResourceByResourceSlug($resourceTypeId, $resourceSlug)
    {
        $resource = null;
        switch ($resourceTypeId) {
            case 2 :
                $resource = $this->videoLessonRepository->findByField('slug', $resourceSlug)->first();
                break;
            case 3 :
                $resource = $this->codeLessonRepository->findByField('slug', $resourceSlug)->first();
                break;
            case 4 :
                $resource = $this->textLessonRepository->findByField('slug', $resourceSlug)->first();
                break;
            case 5 :
                $resource = $this->attachmentLessonRepository->findByField('slug', $resourceSlug)->first();
                break;
            case 6 :
                $resource = $this->linkLessonRepository->findByField('slug', $resourceSlug)->first();
                break;
            case 7 :
                $resource = $this->hotPotatoesLessonRepository->findByField('slug', $resourceSlug)->first();
                break;
            case 8 :
                $resource = $this->slideShareLessonRepository->findByField('slug', $resourceSlug)->first();
                break;
            case 9 :
                $resource = $this->quizRepository->findByField('slug', $resourceSlug)->first();
                break;
            case 10 :
                $resource = $this->youtubeLiveLessonRepository->findByField('slug', $resourceSlug)->first();
                break;
            case 11 :
                $resource = $this->vimeoLiveLessonRepository->findByField('slug', $resourceSlug)->first();
                break;
            case 12 :
                $resource = $this->videoUploadLessonRepository->findByField('slug', $resourceSlug)->first();
                break;
        }
        return $resource;
    }

    public function getQuestionWithAnswersById($questionId)
    {
        return $this->multipleChoiceRepository->with(['tags', 'answers'])->find($questionId);
    }

    public function getResourceTypeById($resourceTypeId)
    {
        return $this->resourceTypeRepository->find($resourceTypeId);
    }

    public function getResourceTypeBySlug($resourceTypeSlug)
    {
        return $this->resourceTypeRepository->findByField('slug', $resourceTypeSlug)->first();
    }

    public function getCourseById($courseId)
    {
        return $this->courseRepository->withTrashed()->find($courseId);
    }

    public function getModuleById($moduleId)
    {
        return $this->moduleRepository->find($moduleId);
    }

    public function getCourseBySlug($courseSlug, $first = true)
    {
        return $this->courseRepository->getCourseBySlug($courseSlug, $first);
    }

    public function getModuleBySlug($moduleSlug, $courseId, $first = true)
    {
        if ($first) {
            return $this->moduleRepository->findWhere([
                ['slug', '=', $moduleSlug],
                ['course_id', '=', $courseId]
            ])->first();
        }

        return $this->moduleRepository->findWhere([
            ['slug', '=', $moduleSlug],
            ['course_id', '=', $courseId]
        ]);
    }

    public function previousResource($course, $module, $resource)
    {
        $allResources = $this->courseResourceRepository->allLessonsThatCanBeRenderedByCourse($course['id']);

        $currentResource = $allResources->where('module_id', $module['id'])
            ->where('resource_id', $resource['id'])
            ->where('resource_type_id', $resource['resource_type_id'])
            ->keys()->first();

        if ($currentResource == 0) {
            return '';
        }
        $previous = $allResources[$currentResource - 1];

        $resource = $this->getResourceByResourceId($previous['resource_type_id'], $previous['resource_id']);
        $prevModule = $this->getModuleById($previous['module_id']);

        $resourceType = $this->getResourceTypeById($previous['resource_type_id']);

        $previousResource = [
            'course_slug' => $course['slug'],
            'module_slug' => $prevModule['slug'],
            'resource_slug' => $resource['slug'],
            'resource_type_slug' => $resourceType['slug'],
            'enabled' => true,
            'route' => $resourceType['route']
        ];
        return $previousResource;
    }

    public function nextResource($userId, $course, $module, $resource)
    {
        $allResources = $this->courseResourceRepository->allLessonsThatCanBeRenderedByCourse($course['id']);

        $lastResource = count($allResources) - 1;
        $currentResource = $allResources->where('module_id', $module['id'])
            ->where('resource_id', $resource['id'])
            ->where('resource_type_id', $resource['resource_type_id'])
            ->keys()->first();

        if ($currentResource == $lastResource) {
            return '';
        }
        $current = $allResources[$currentResource];

        //Define se o próximo recurso está liberado para acesso ou não
        $can = $this->canAccessNextResource($current, $userId);

        $next = $allResources[$currentResource + 1];

        $resource = $this->getResourceByResourceId($next['resource_type_id'], $next['resource_id']);
        $nextModule = $this->getModuleById($next['module_id']);

        $resourceType = $this->getResourceTypeById($next['resource_type_id']);

        $nextResource = [
            'course_slug' => $course['slug'],
            'module_slug' => $nextModule['slug'],
            'resource_slug' => $resource['slug'],
            'resource_type_slug' => $resourceType['slug'],
            'enabled' => $can,
            'route' => $resourceType['route']
        ];
        return $nextResource;
    }

    public function getQuizAllQuestions($courseId, $moduleId, $quizId)
    {
        return $this->quizQuestionRepository->orderBy('position')
            ->findWhere(
                [
                    ['course_id', '=', $courseId],
                    ['module_id', '=', $moduleId],
                    ['quiz_id', '=', $quizId],
                    ['status_id', '=', 1]
                ]
            );
    }

    public function getQuizAllAvailableQuestions($courseId, $moduleId, $quizId)
    {
        return $this->quizQuestionRepository->orderBy('position')
            ->findWhere(
                [
                    ['course_id', '=', $courseId],
                    ['module_id', '=', $moduleId],
                    ['quiz_id', '=', $quizId],
                    ['status_id', '=', 1]
                ]
            );
    }

    public function getQuestionByHash($courseId, $moduleId, $quizId, $hash)
    {
        return $this->quizQuestionRepository->orderBy('position')
            ->findWhere(
                [
                    ['course_id', '=', $courseId],
                    ['module_id', '=', $moduleId],
                    ['quiz_id', '=', $quizId],
                    ['hash', '=', $hash]
                ]
            )->first();
    }

    private function canAccessNextResource($resource, $userId)
    {
        $check = $this->recordRepository
            ->findWhere([
                ['user_id', '=', $userId],
                ['course_id', '=', $resource['course_id']],
                ['module_id', '=', $resource['module_id']],
                ['resource_id', '=', $resource['resource_id']],
                ['resource_type_id', '=', $resource['resource_type_id']]
            ])->all();
        if ($check) {
            return true;
        }
        return false;
    }

    public function getUserProfile($userId)
    {
        return $this->userRepository->find($userId);
    }
}