eagle.ead.lmsestudio.com.br

UnknownSec Bypass 403

: /var/www/html/lms_9d655b94864d/app/Http/Controllers/Environment/Student/ [ drwxr-xr-x ]
name : StudentController.php
 <?php

namespace EstudioLMS\Http\Controllers\Environment\Student;

use Carbon\Carbon;
use EstudioLMS\Base\ResponseBuilder;
use EstudioLMS\Events\TaskAnswered;
use EstudioLMS\Events\UtfAnswered;
use EstudioLMS\Helpers\GetDataRecords;
use EstudioLMS\Helpers\Helpers;
use EstudioLMS\Helpers\VideoStream;
use EstudioLMS\Http\Controllers\Controller;
use EstudioLMS\Http\Requests\Courses\TaskRequest;
use EstudioLMS\Http\Requests\Courses\UtfCommentsRequest;
use EstudioLMS\Repositories\Courses\Course\CourseRepository;
use EstudioLMS\Repositories\Courses\CourseRatingInterface;
use EstudioLMS\Repositories\Courses\Resources\CommentInterface;
use EstudioLMS\Repositories\Courses\Resources\UtfCommentInterface;
use EstudioLMS\Repositories\Environment\HiredCourseRepository;
use EstudioLMS\Repositories\Environment\RecordRepository;
use EstudioLMS\Repositories\Environment\TaskSentInterface;
use EstudioLMS\Repositories\Financial\HireSubscriptionInterface;
use EstudioLMS\Repositories\Financial\HiringInterface;
use EstudioLMS\Repositories\Student\CourseHistoryInterface;
use EstudioLMS\Services\Environment\CourseResourceService;
use EstudioLMS\Services\Environment\CourseService;
use EstudioLMS\Services\Environment\StudentService;
use EstudioLMS\Services\Environment\SubscriptionService;
use File;
use Illuminate\Contracts\Auth\Guard;
use Illuminate\Http\Request;
use Illuminate\Support\Collection;
use mjanssen\BreadcrumbsBundle\Breadcrumbs;
use Response;
use Symfony\Component\HttpFoundation\Session\SessionInterface;
use Storage;

/**
 * Class StudentController
 * @package EstudioLMS\Http\Controllers\Environment\Student
 */
class StudentController extends Controller
{
    /**
     * @var Guard
     */
    private $auth;
    /**
     * @var HiredCourseRepository
     */
    private $hiredCourseRepository;
    /**
     * @var ResponseBuilder
     */
    private $responseBuilder;
    /**
     * @var CourseRepository
     */
    private $courseRepository;
    /**
     * @var Breadcrumbs
     */
    private $breadcrumbs;
    /**
     * @var RecordRepository
     */
    private $recordRepository;
    /**
     * @var CourseResourceService
     */
    private $courseResourceService;
    /**
     * @var CourseService
     */
    private $courseService;
    /**
     * @var SessionInterface
     */
    private $session;
    /**
     * @var HireSubscriptionInterface
     */
    private $hireSubscription;
    /**
     * @var StudentService
     */
    private $studentService;
    /**
     * @var SubscriptionService
     */
    private $subscriptionService;
    /**
     * @var CourseHistoryInterface
     */
    private $courseHistory;
    /**
     * @var HiringInterface
     */
    private $hiring;
    /**
     * @var CourseRatingInterface
     */
    private $courseRating;
    /**
     * @var CommentInterface
     */
    private $comment;
    /**
     * @var UtfCommentInterface
     */
    private $utfComment;
    /**
     * @var GetDataRecords
     */
    private $getDataRecords;
    /**
     * @var TaskSentInterface
     */
    private $taskSent;

    /**
     * StudentController constructor.
     * @param Guard $auth
     * @param ResponseBuilder $responseBuilder
     * @param HiredCourseRepository $hiredCourseRepository
     * @param CourseRepository $courseRepository
     * @param Breadcrumbs $breadcrumbs
     * @param RecordRepository $recordRepository
     * @param CourseResourceService $courseResourceService
     * @param CourseService $courseService
     * @param SessionInterface $session
     * @param HireSubscriptionInterface $hireSubscription
     * @param StudentService $studentService
     * @param SubscriptionService $subscriptionService
     * @param CourseHistoryInterface $courseHistory
     * @param HiringInterface $hiring
     * @param CourseRatingInterface $courseRating
     * @param CommentInterface $comment
     * @param UtfCommentInterface $utfComment
     * @param GetDataRecords $getDataRecords
     * @param TaskSentInterface $taskSent
     */
    public function __construct(
        Guard $auth,
        ResponseBuilder $responseBuilder,
        HiredCourseRepository $hiredCourseRepository,
        CourseRepository $courseRepository,
        Breadcrumbs $breadcrumbs,
        RecordRepository $recordRepository,
        CourseResourceService $courseResourceService,
        CourseService $courseService,
        SessionInterface $session,
        HireSubscriptionInterface $hireSubscription,
        StudentService $studentService,
        SubscriptionService $subscriptionService,
        CourseHistoryInterface $courseHistory,
        HiringInterface $hiring,
        CourseRatingInterface $courseRating,
        CommentInterface $comment,
        UtfCommentInterface $utfComment,
        GetDataRecords $getDataRecords,
        TaskSentInterface $taskSent
    )
    {
        $this->middleware('student', ['except' => ['showUrl']]);
        $this->auth = $auth;
        $this->responseBuilder = $responseBuilder;
        $this->hiredCourseRepository = $hiredCourseRepository;
        $this->courseRepository = $courseRepository;
        $this->breadcrumbs = $breadcrumbs;
        $this->recordRepository = $recordRepository;
        $this->courseResourceService = $courseResourceService;
        $this->courseService = $courseService;
        $this->session = $session;
        $this->hireSubscription = $hireSubscription;
        $this->studentService = $studentService;
        $this->subscriptionService = $subscriptionService;
        $this->courseHistory = $courseHistory;
        $this->hiring = $hiring;
        $this->courseRating = $courseRating;
        $this->comment = $comment;
        $this->utfComment = $utfComment;
        $this->getDataRecords = $getDataRecords;
        $this->taskSent = $taskSent;
    }

    /**
     * @return \Illuminate\Contracts\View\Factory|\Illuminate\View\View
     */
    public function myCourses()
    {
        $env = 'mycourses';
        $title = 'Meus Cursos';
        $userId = $this->auth->user()['id'];

        $showCourses = $this->showCourses();

        $coursesCompleted = [];
        $coursesInProgress = [];

        foreach ($showCourses as $course) {
            if ($this->courseService->checkIfCourseHasCompletedByLessons($userId, $course['course_id'])) {
                $coursesCompleted[] = $course;
            } else {
                $coursesInProgress[] = $course;
            }
        }

        if ($coursesCompleted) {
            foreach ($coursesCompleted as $key => $courseCompleted) {
                $coursesCompleted[$key]['approval'] = $this->courseService->wasApprovedInTheCourse($userId,
                    $courseCompleted['course_id']);
            }
        }

        $this->breadcrumbs->addBreadcrumb(
            'Dashboard',
            route('environment.index')
        );
        $this->breadcrumbs->addBreadcrumb(trans('messages.lblAmbienteMyCourses'), route('student.course.list'));
        $bread = $this->breadcrumbs->generate();

        $naoPago = [1, 2];
        $pago = [3, 4];
        $bloqueado = [5, 6, 7];

        return $this->responseBuilder->render(
            'ambiente.student.mycourses',
            compact('coursesInProgress', 'coursesCompleted'),
            compact('env', 'bread', 'title', 'naoPago', 'pago', 'bloqueado', 'showCourses')
        );
    }

    /**
     * @param $slugCourse
     * @param null $subscriptionId
     * @return mixed
     */
    public function showCourse($slugCourse, $subscriptionId = null)
    {
        $env = 'mycourses';
        $userId = $this->auth->user()['id'];
        if (is_null($subscriptionId)) {
            $course = $this->hiredCourseRepository->getCourseDetails($userId, $slugCourse);
        } else {
            $course = $this->subscriptionService->getCourseDetails($userId, $subscriptionId, $slugCourse);
        }
        #dd($course);
        if (!$course) {
            flash()->error('Você não tem acesso a este curso');
            return redirect()->route('student.course.list');
        }

        $title = $course['course']['name'];
        $this->breadcrumbs->addBreadcrumb(
            'Dashboard',
            route('environment.index')
        );
        $this->breadcrumbs->addBreadcrumb(trans('messages.lblAmbienteMyCourses'), route('student.course.list'));
        $this->breadcrumbs->addBreadcrumb(
            $course['course']['name'],
            route('student.course.detail', $course['course']['slug'])
        );
        $bread = $this->breadcrumbs->generate();

        $studentCount = \DB::table('hired_courses')
            ->selectRaw('COUNT(*) AS countStudent')
            ->where('course_id', '=', $course['course']['id'])
            ->where('completed', '=', false)
            ->first();

        if (!is_null($course['course_id'])) {
            $course['approval'] = $this->courseService->wasApprovedInTheCourse($userId, $course['course_id']);
        } else {
            $course['approval'] = $this->courseService->wasApprovedInTheCourse($userId, $course['course']['id']);
        }

        $rating = $this->courseRating->findWhere([
            ['course_id', '=', $course['course_id']],
            ['user_id', '=', $userId]
        ])->first();

        if (!$rating) {
            $rating = collect(
                [
                    'user_id' => $userId,
                    'course_id' => $course['course_id'],
                    'rating' => 0,
                    'comments' => null
                ]
            )->first();
        }
        return $this->responseBuilder
            ->render(
                'ambiente.student.course_details',
                compact('course', 'studentCount', 'subscriptionId', 'rating'),
                compact('env', 'bread', 'title')
            );
    }

    /**
     * @param $resourceType
     * @param $courseSlug
     * @param $moduleSlug
     * @param $resourceSlug
     * @param null $subscriptionId
     * @return mixed
     */
    public function watchLesson($resourceType, $courseSlug, $moduleSlug, $resourceSlug, $subscriptionId = null)
    {
        $env = 'mycourses';
        $userId = $this->auth->user()['id'];

        $resource = $this->courseResourceService->renderLesson($userId, $resourceType, $courseSlug, $moduleSlug,
            $resourceSlug);

        $comments = $this->comment->getComments($resource['course_id'], $resource['resource_type_id'], $resource['id']);

        //Home
        /*$this->breadcrumbs->addBreadcrumb('Home', route('index'));*/
        // Dashboard
        $this->breadcrumbs->addBreadcrumb('Dashboard', route('environment.index'));
        // Meus Cursos
        $this->breadcrumbs->addBreadcrumb(trans('messages.lblAmbienteMyCourses'), route('student.course.list'));
        // Curso em andamento
        $this->breadcrumbs->addBreadcrumb($resource['course_name'], route('student.course.detail', $courseSlug));
        // Lição corrente

        $route = 'environment.resource.render.lesson';
        if ($resourceType == 'quiz') {
            $route = 'environment.resource.render.quiz';
        }

        $this->breadcrumbs->addBreadcrumb(
            $resource['title'],
            route($route, [$resourceType, $courseSlug, $moduleSlug, $resourceSlug])
        );

        $taskData = null;
        if ($resourceType == 'task') {
            $taskData = $this->taskSent->with(['taskLesson'])->findWhere([
                ['task_lesson_id', '=', $resource['id']],
                ['user_id', '=', $userId],
            ])->first();
        }

        $bread = $this->breadcrumbs->generate();
        $title = $resource['course_name'];
        return $this->responseBuilder->render(
            'ambiente.student.watch_lesson',
            compact('resource', 'subscriptionId', 'comments', 'taskData'),
            compact('env', 'bread', 'title')
        );
    }

    /**
     * @param Request $request
     */
    public function recordWatchedLesson(Request $request)
    {
        $data = $request->all();
        $userId = $this->auth->user()['id'];

        $data['user_id'] = $userId;
        $data['watched_at'] = date('Y-m-d H:i:s');
        $record = $this->recordRepository->create($data);
        $courseId = $record['course_id'];
        $completed = $this->courseService->checkIfCourseHasCompletedByLessons($userId, $courseId);

        if ($completed) {
            $this->hiredCourseRepository->setCompleted($userId, $courseId);
            $this->studentService->setCompleted($userId, $courseId);
        }
    }

    /**
     * @return mixed
     */
    public function showCertificates()
    {
        $userId = $this->auth->user()['id'];

        $env = 'mycourses';
        $title = 'Meus Certificados';

        //Home
        //$this->breadcrumbs->addBreadcrumb('Home', route('index'));
        // Dashboard
        $this->breadcrumbs->addBreadcrumb('Dashboard', route('environment.index'));
        // Meus Certificados
        $this->breadcrumbs->addBreadcrumb('Meus Certificados', route('available.certificates'));

        $bread = $this->breadcrumbs->generate();

        $availableCertificates = $this->courseHistory->availableCertificates($userId);

        $certificates = new Collection();
        foreach ($availableCertificates as $key => $availableCertificate) {
            $wasApproved = $this->studentService->wasApprovedInTheCourse($userId, $availableCertificate->course->id);
            if ($wasApproved['approved'] == 1 || $wasApproved['approved'] == 0) {
                $certificates->push([
                    'course_name' => $availableCertificate->course->name,
                    'link' => route('issue.certificate', [$userId, $availableCertificate->course->id]),
                    'main_image' => $availableCertificate->course->main_image
                ]);
            }
        }

        return $this->responseBuilder
            ->render(
                'ambiente.student.available_certificates',
                compact('certificates'),
                compact('env', 'bread', 'title')
            );
    }

    /**
     * @param $salt
     * @param $resourceTypeId
     * @param $resourceId
     */
    public function showUrl($salt, $resourceTypeId, $resourceId)
    {
        $invalidateUrl = [];
        $url = \URL::current();
        if ($this->session->has('invalidate-url')) {
            $invalidateUrl[] = $this->session->get('invalidate-url');
        }

        if (in_array($url, $invalidateUrl)) {
            return abort(404);
        }

        $previousUrl = \URL::previous();
        if (strpos($previousUrl, '/my-courses/video-upload/') || strpos($previousUrl, '/site/curso/')) {
            $resource = $this->courseResourceService->localVideoURL($resourceTypeId, $resourceId);
            $name = $resource->uploaded_video;
            $base = public_path() . '/storage/resources/' . $resource->resource_type_id . '/' . $resource->id . '/' . $name;

            $filePath = $base;
            $stream = new VideoStream($filePath, $this->session);
            $stream->start(\URL::current());

            #$invalidateUrl[] = \URL::current();

            $this->session->set('invalidate-url', \URL::current());
            $this->session->save();
        }
        return abort(404);
    }

    /**
     * @param Request $request
     * @return \Illuminate\Http\RedirectResponse
     */
    public function rating(Request $request)
    {
        $this->validate($request,
            [
                'rating' => 'required',
                'comments' => 'required|min:20',
            ],
            [],
            [
                'rating' => 'Avaliação',
                'comments' => 'Comentário'
            ]
        );
        $data = $request->all();
        $rating = $this->courseRating
            ->findWhere([
                ['course_id', '=', $data['course_id']],
                ['user_id', '=', $data['user_id']]
            ])->first();
        if ($rating) {
            $rating->fill($data);
            $rating->save();
        } else {
            $this->courseRating->create($data);
        }
        if (!empty($data['subscription_id'])) {
            return redirect()->route('student.course.detail', [$data['course_slug'], $data['subscription_id']]);
        } else {
            return redirect()->route('student.course.detail', [$data['course_slug']]);
        }
    }

    /**
     * @param UtfCommentsRequest $request
     * @return \Illuminate\Http\RedirectResponse
     */
    public function storeUftComments(UtfCommentsRequest $request)
    {
        $data = $request->all();
        $utfCommentId = $data['reply_id'] ?? $data['rejoinder_id'];

        $this->utfComment->create([
            'utf_lesson_id' => null,
            'utf_comment_id' => $utfCommentId,
            'user_id' => $this->auth->user()['id'],
            'comments' => $data['comments'.$utfCommentId]
        ]);
        return back();
    }

    /**
     * @param UtfCommentsRequest $request
     * @return \Illuminate\Http\RedirectResponse
     */
    public function storeUftAnswer(UtfCommentsRequest $request)
    {
        $data = $request->all();
        $utfCommentId = $data['answer_id'];
        $this->utfComment->create([
            'utf_lesson_id' => $utfCommentId,
            'utf_comment_id' => null,
            'user_id' => $this->auth->user()['id'],
            'comments' => $data['comments0']
        ]);

        /* Marcando o fórum como assistido */
        $userId = $this->auth->user()['id'];
        $data['user_id'] = $userId;
        $data['watched_at'] = date('Y-m-d H:i:s');
        $record = $this->recordRepository->create($data);
        $courseId = $record['course_id'];
        $completed = $this->courseService->checkIfCourseHasCompletedByLessons($userId, $courseId);

        if ($completed) {
            $this->hiredCourseRepository->setCompleted($userId, $courseId);
            $this->studentService->setCompleted($userId, $courseId);
        }

        $mailData = $this->courseRepository->with(['user'])->find($courseId);
        \Event::fire(new UtfAnswered($mailData));

        return back();
    }

    /**
     * @return Collection
     */
    private function showCourses()
    {
        $userId = $this->auth->user()['id'];
        $selectCourses = new Collection();
        $mySubscriptions = $this->hireSubscription->hiredSubscriptions($userId, [1]);
        $subscriptionId = null;
        foreach ($mySubscriptions as $subscription) {
            if ($subscription->subscription->full_content) {
                $selectCourses = null;
                $selectCourses = $this->courseRepository->showCourseList();
                $subscriptionId = $subscription->subscription_id;
                break;
            } else {
                $temp = $subscription->subscription->courses;
                $temp->subscription_id = $subscription->subscription_id;
                $selectCourses = $selectCourses->merge($temp);
            }
        }
        $showCourses = new Collection();
        foreach ($selectCourses as $course) {
            $showCourses->push(
                [
                    'course_id' => $course->id,
                    'name' => $course->name,
                    'main_image' => $course->main_image,
                    'slug' => $course->slug,
                    'completed' => $this->studentService->hasCompletedCourse($userId, $course->id),
                    'approval' => $this->studentService->wasApprovedInTheCourse($userId, $course->id),
                    'subscription' => true,
                    'subscription_id' => !is_null($subscriptionId) ? $subscriptionId : $course->pivot->subscription_id,
                    'status' => 3,
                    'end' => null
                ]
            );
        }
        $myCourses = $this->hiredCourseRepository->hiredCourses($userId);
        foreach ($myCourses as $myCourse) {
            $completed = $this->studentService->hasCompletedCourse($userId, $myCourse->course->id);
            if ($myCourse->status == 3 || $myCourse->status == 4 || $myCourse->status == 10) {
                if (count($showCourses->where('course_id', $myCourse->course->id)) <= 0) {
                    $showCourses->push(
                        [
                            'course_id' => $myCourse->course->id,
                            'name' => $myCourse->course->name,
                            'main_image' => $myCourse->course->main_image,
                            'slug' => $myCourse->course->slug,
                            'completed' => $completed,
                            'approval' => $this->studentService->wasApprovedInTheCourse($userId, $myCourse->course->id),
                            'subscription' => false,
                            'subscription_id' => null,
                            'status' => $myCourse->status,
                            'end' => $myCourse->end
                        ]
                    );
                }
            }
        }
        return $showCourses;
    }

    /**
     * @param TaskRequest $request
     * @return \Illuminate\Http\RedirectResponse
     * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
     */
    public function storeTaskLesson(TaskRequest $request)
    {
        $userId = $this->auth->user()['id'];
        $data = $request->all();
        $file = null;
        $data['task_upload'] = null;
        if ($request->hasFile('task_upload')) {
            $file = $request->file('task_upload')->getClientOriginalName();
            $path = 'task_sent/' . $data['course_id'] . '/' . $data['resource_id'] . '/' . $userId . '/' . $file;
            Storage::disk('lesson_file')
                ->put(
                    $path,
                    File::get($request->file('task_upload'))
                );
            $data['task_upload'] = $file;
        }
        $this->taskSent->create([
            'course_id' => $data['course_id'],
            'task_lesson_id' => $data['resource_id'],
            'user_id' => $userId,
            'redaction' => $data['redaction'] ?? null,
            'task_upload' => $data['task_upload'],
            'sended_date' => Carbon::now(),
            'final_note' => null,
            'status' => 1
        ]);

        /* Marcando a lição de tarefa como assistida */
        $data['user_id'] = $userId;
        $data['watched_at'] = date('Y-m-d H:i:s');
        $record = $this->recordRepository->create($data);
        $courseId = $record['course_id'];
        $completed = $this->courseService->checkIfCourseHasCompletedByLessons($userId, $courseId);

        if ($completed) {
            $this->hiredCourseRepository->setCompleted($userId, $courseId);
            $this->studentService->setCompleted($userId, $courseId);
        }

        $lesson = \DB::table('task_lessons')->find($data['resource_id']);

        $course = \DB::table('courses')
            ->join('users', 'courses.user_id', '=', 'users.id')
            ->where('courses.id', $data['course_id'])
            ->select(['users.email AS to', 'users.name AS name', 'courses.name AS course_name'])
            ->first();

        $mailData = [
            'to' => $course->to,
            'name' => $course->name,
            'course_name' => $course->course_name,
            'lesson_name' => $lesson->title,
            'student_name' => $this->auth->user()['name'],
            'student_email' => $this->auth->user()['mail'],
            'subject' => 'Lição Tarefa Respondida!',
            'type' => 1
        ];

        \Event::fire(new TaskAnswered($mailData));

        return back();
    }

    /**
     * @param TaskRequest $request
     * @return \Illuminate\Http\RedirectResponse
     * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
     */
    public function updateTaskLesson(TaskRequest $request)
    {
        $userId = $this->auth->user()['id'];
        $data = $request->all();
        $file = null;
        $data['task_upload'] = null;
        $data['status'] = 1;
        $taskData = $this->taskSent->find($data['task_id']);
        if ($request->hasFile('task_upload')) {
            $pathOld = 'task_sent/' . $data['course_id'] . '/' . $data['resource_id'] . '/' . $userId . '/' . $taskData['task_upload'];
            $fullSourcePath = Storage::disk('lesson_file')->getDriver()->getAdapter()->applyPathPrefix($pathOld);
            if(File::exists($fullSourcePath)) {
                File::delete($fullSourcePath);
            }

            $file = $request->file('task_upload')->getClientOriginalName();
            $path = 'task_sent/' . $data['course_id'] . '/' . $data['resource_id'] . '/' . $userId . '/' . $file;
            Storage::disk('lesson_file')
                ->put(
                    $path,
                    File::get($request->file('task_upload'))
                );
            $data['task_upload'] = $file;
        }
        $data['sended_date'] = Carbon::now();
        $this->taskSent->update($data, $data['task_id']);

        /* Marcando a lição de tarefa como assistida */
        $data['user_id'] = $userId;
        $data['watched_at'] = date('Y-m-d H:i:s');
        $record = $this->recordRepository->create($data);
        $courseId = $record['course_id'];
        $completed = $this->courseService->checkIfCourseHasCompletedByLessons($userId, $courseId);

        if ($completed) {
            $this->hiredCourseRepository->setCompleted($userId, $courseId);
            $this->studentService->setCompleted($userId, $courseId);
        }

        $lesson = \DB::table('task_lessons')->find($data['resource_id']);
        $course = \DB::table('courses')
            ->join('users', 'courses.user_id', '=', 'users.id')
            ->where('courses.id', $data['course_id'])
            ->select(['users.email AS to', 'users.name AS name', 'courses.name AS course_name'])
            ->first();

        $mailData = [
            'to' => $course->to,
            'name' => $course->name,
            'course_name' => $course->course_name,
            'lesson_name' => $lesson->title,
            'student_name' => $this->auth->user()['name'],
            'student_email' => $this->auth->user()['mail'],
            'subject' => 'Lição Tarefa Respondida!',
            'type' => 1
        ];

        \Event::fire(new TaskAnswered($mailData));

        return back();
    }
}