eagle.ead.lmsestudio.com.br

UnknownSec Bypass 403

: /mnt/lmsestudio-instance-vol002/eagleead/app/Http/Controllers/Admin/ [ drwxr-xr-x ]
name : TaskLessonController.php
 <?php

namespace EstudioLMS\Http\Controllers\Admin;

use EstudioLMS\Events\TaskAnsweredByTeacher;
use EstudioLMS\Exceptions\Handler;
use EstudioLMS\Helpers\Helpers;
use EstudioLMS\Repositories\Environment\HiredCourseRepository;
use EstudioLMS\Repositories\Environment\TaskSentInterface;
use EstudioLMS\Services\Environment\QuizService;
use EstudioLMS\Services\Environment\StudentService;
use Illuminate\Http\Request;

use EstudioLMS\Http\Requests;
use EstudioLMS\Http\Controllers\Controller;
use EstudioLMS\Helpers\GetDataRecords;
use EstudioLMS\Repositories\Courses\Resources\TaskLessonInterface;
use mjanssen\BreadcrumbsBundle\Breadcrumbs;
use Illuminate\Auth\Guard;
use DB;
use Storage;
use File;

/**
 *
 */
class TaskLessonController extends Controller
{
    /**
     * @var Guard
     */
    private $auth;
    /**
     * @var GetDataRecords
     */
    private $getDataRecords;
    /**
     * @var Breadcrumbs
     */
    private $breadCrumb;
    /**
     * @var TaskSentInterface
     */
    private $taskSent;
    /**
     * @var HiredCourseRepository
     */
    private $hiredCourseRepository;

    /**
     * @param Guard $auth
     * @param GetDataRecords $getDataRecords
     * @param Breadcrumbs $breadCrumb
     * @param TaskSentInterface $taskSent
     * @param HiredCourseRepository $hiredCourseRepository
     */
    public function __construct(
        Guard                 $auth,
        GetDataRecords        $getDataRecords,
        Breadcrumbs           $breadCrumb,
        TaskSentInterface     $taskSent,
        HiredCourseRepository $hiredCourseRepository
    )
    {
        $this->middleware('admin_teacher');
        $this->auth = $auth;
        $this->getDataRecords = $getDataRecords;
        $this->breadCrumb = $breadCrumb;
        $this->taskSent = $taskSent;
        $this->hiredCourseRepository = $hiredCourseRepository;
    }

    /**
     * @param Request $request
     * @return \Illuminate\Contracts\View\Factory|\Illuminate\Foundation\Application|\Illuminate\View\View
     */
    public function index(Request $request)
    {
        $data = $request->only(['course_id', 'resource_id', 'student_id']);
        $title = trans('admin_task.title');
        $env = 'coursemanager';

        $this->breadCrumb->addBreadcrumb(trans('admin_master.breadDash'), route('admin.index'));
        $this->breadCrumb->addBreadcrumb($title, route('admin.task.index'));
        $bread = $this->breadCrumb->generate();

        $cCourses = collect([]);
        $resources = collect([]);
        $students = collect([]);

        if ($this->auth->user()['roles'][0]['name'] === 'teacher') {
            $cCourses->push(['id' => 0, 'name' => trans('admin_task.filterCourse')]);
            $courses = DB::table('courses AS C')
                ->join('course_resources AS CR', 'CR.course_id', '=', 'C.id')
                ->where('CR.resource_type_id', '=', 15)
                ->where('C.user_id', '=', $this->auth->user()->id)
                ->groupBy('C.id')
                ->orderBy('C.id')
                ->get(['C.id', 'C.name']);
        } else {
            $cCourses->push(['id' => 0, 'name' => trans('admin_task.filterCourse')]);
            $courses = DB::table('courses AS C')
                ->join('course_resources AS CR', 'CR.course_id', '=', 'C.id')
                ->where('CR.resource_type_id', '=', 15)
                ->groupBy('C.id')
                ->orderBy('C.id')
                ->get(['C.id', 'C.name']);
        }

        foreach ($courses as $key => $course) {
            $cCourses->push(['id' => $course->id, 'name' => $course->name]);
        }
        $courses = $cCourses->pluck('name', 'id');

        if (isset($data['course_id']) && !empty($data['course_id'])) {
            $resources->push(['id' => 0, 'title' => trans('admin_task.filterLesson')]);
            $taskSents = DB::table('course_resources AS CR')
                ->join('task_sents AS TS', 'TS.task_lesson_id', '=', 'CR.resource_id')
                ->where('CR.course_id', $data['course_id'])
                ->where('CR.resource_type_id', 15)
                ->groupBy('TS.task_lesson_id')
                ->orderBy('TS.task_lesson_id')
                ->get(['TS.task_lesson_id']);
            foreach ($taskSents as $key => $taskSent) {
                $getResource = $this->getDataRecords
                    ->getResourceByResourceId(15, $taskSent->task_lesson_id, true);
                $resources->push(['id' => $getResource->id, 'title' => $getResource->title]);
            }
            $resources = $resources->pluck('title', 'id');
        }

        $sendedTasks = null;
        if (isset($data['resource_id']) && !empty($data['resource_id'])) {
            $students->push(['id' => 0, 'name' => trans('admin_task.filterStudent')]);
            $taskStudents = DB::table('task_sents AS TS')
                ->join('users AS U', 'U.id', '=', 'TS.user_id')
                ->where('TS.task_lesson_id', '=', $data['resource_id'])
                ->groupBy('TS.user_id')
                ->orderBy('TS.user_id')
                ->get(['U.id', 'U.name']);
            foreach ($taskStudents as $key => $taskStudent) {
                $students->push(['id' => $taskStudent->id, 'name' => $taskStudent->name]);
            }
            $students = $students->pluck('name', 'id');
            $sendedTasks = DB::table('task_sents AS TS')
                ->join('users AS U', 'U.id', '=', 'TS.user_id')
                ->join('task_lessons AS TL', 'TS.task_lesson_id', '=', 'TL.id')
                ->where('TS.task_lesson_id', $data['resource_id'])
                ->select(['U.name', 'U.email',
                    'TS.id', 'TS.task_upload', 'TS.course_id', 'TS.task_lesson_id', 'TS.user_id', 'TS.redaction', 'TS.status', 'TS.final_note', 'TS.teacher_comments', 'TS.sended_date',
                    'TL.start_date', 'TL.end_date', 'TL.max_note', 'TL.approval_minimum_note'])
                ->paginate(10);
        }

        if (isset($data['course_id']) && !empty($data['course_id']) &&
            isset($data['resource_id']) && !empty($data['resource_id']) &&
            isset($data['student_id']) && !empty($data['student_id'])) {
            $sendedTasks = DB::table('task_sents AS TS')
                ->join('users AS U', 'U.id', '=', 'TS.user_id')
                ->join('task_lessons AS TL', 'TS.task_lesson_id', '=', 'TL.id')
                ->where('TS.user_id', $data['student_id'])
                ->where('TS.task_lesson_id', $data['resource_id'])
                ->select(['U.name', 'U.email',
                    'TS.id', 'TS.task_upload', 'TS.course_id', 'TS.task_lesson_id', 'TS.user_id', 'TS.redaction', 'TS.status', 'TS.final_note', 'TS.teacher_comments', 'TS.sended_date',
                    'TL.start_date', 'TL.end_date', 'TL.max_note', 'TL.approval_minimum_note'])
                ->paginate(10);
        }

        return view('admin.tasks', compact('data', 'title', 'env', 'bread', 'courses', 'resources', 'students', 'sendedTasks'));
    }

    public function clearTask(Request $request)
    {
        $id = $request->get('id');
        $sendedTask = $this->taskSent->find($id);
        $userId = $sendedTask->user_id;
        $resourceId = $sendedTask->task_lesson_id;
        $courseId = $sendedTask->course_id;

        if (!empty($sendedTask->task_upload)) {
            $pathOld = 'task_sent/' . $sendedTask->course_id . '/' . $sendedTask->task_lesson_id . '/' . $sendedTask->user_id . '/' . $sendedTask->task_upload;
            $fullSourcePath = Storage::disk('lesson_file')->getDriver()->getAdapter()->applyPathPrefix($pathOld);
            if (File::exists($fullSourcePath)) {
                File::delete($fullSourcePath);
            }
            $sendedTask->task_upload = null;
        }
        $sendedTask->status = 2;
        $sendedTask->save();

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

        $mailData = [
            'to' => $course->to,
            'name' => $course->name,
            'course_name' => $course->course_name,
            'lesson_name' => $lesson->title,
            'student_name' => $student->name,
            'student_email' => $student->email,
            'subject' => trans('admin_task.msgSubjectTaskAnsweredByTeacher'),
            'type' => 1
        ];

        \Event::fire(new TaskAnsweredByTeacher($mailData));
    }

    /**
     * @param Request $request
     * @return \Illuminate\Foundation\Application|string
     */
    public function evaluateTask(Request $request)
    {
        try {
            $data = $request->only(['id', 'final_note', 'teacher_comments']);
            $sendedTask = $this->taskSent->find($data['id']);

            $userId = $sendedTask->user_id;
            $resourceId = $sendedTask->task_lesson_id;
            $courseId = $sendedTask->course_id;

            $sendedTask->final_note = $data['final_note'];
            $sendedTask->teacher_comments = $data['teacher_comments'];
            $sendedTask->status = 3;
            $sendedTask->save();


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

            $mailData = [
                'to' => $course->to,
                'name' => $course->name,
                'course_name' => $course->course_name,
                'lesson_name' => $lesson->title,
                'student_name' => $student->name,
                'student_email' => $student->email,
                'subject' => trans('admin_task.msgSubjectTaskAvailable'),
                'type' => 2
            ];

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

            return trans('admin_task.alertSave');
        } catch (\Exception $e) {
            app(Handler::class)->report($e);
            return trans('admin_task.alertError');
        }
    }

    public function deleteFileOnly(Request $request)
    {
        $id = $request->get('id');
        $sendedTask = $this->taskSent->find($id);
        if (!empty($sendedTask->task_upload)) {
            $pathOld = 'task_sent/' . $sendedTask->course_id . '/' . $sendedTask->resource_id . '/' . $sendedTask->user_id . '/' . $sendedTask->task_upload;
            $fullSourcePath = Storage::disk('lesson_file')->getDriver()->getAdapter()->applyPathPrefix($pathOld);
            if (File::exists($fullSourcePath)) {
                File::delete($fullSourcePath);
            }
            $sendedTask->task_upload = null;
        }
        $sendedTask->save();
    }

    /**
     * @param Request $request
     * @return \Illuminate\Contracts\View\Factory|\Illuminate\Foundation\Application|\Illuminate\View\View
     */
    public function reportGradesWithFinalAverages(Request $request)
    {
        $env = 'reports';
        $title = 'Relatório de Notas e Médias';

        $this->breadCrumb->addBreadcrumb('Dashboard', route('admin.index'));
        $this->breadCrumb->addBreadcrumb($title, route('admin.reports.grades-with-final-average'));
        $bread = $this->breadCrumb->generate();

        $selectCourses = \DB::table('courses AS C')
            ->join('course_resources AS CR', 'C.id', '=', 'CR.course_id')
            ->where('CR.consists_average', '=', 1)
            ->groupBy('CR.course_id')
            ->select('C.id', 'C.name');

        if($this->auth->user()['roles'][0]['name'] === 'teacher') {
            $selectCourses->where('C.user_id', $this->auth->user()['id']);
        }
        $selectCourses = $selectCourses->get();

        $courses = ['' => 'Selecione o Curso'] + array_pluck($selectCourses, 'name', 'id');
        $selectedCourse = null;
        $students = ['' => 'Sem alunos'];
        $selectedStudent = null;
        $data = $request->all();

        $reportData = null;
        $headers = null;

        if (!empty($data['course_id'])) {
            $headers = $this->headers($data['course_id']);
            $selectedCourse = $data['course_id'];
            //$students = $this->hiredCourseRepository->getHiredCoursesWithStudentData($data['course_id'])->get();
            $students = $this->getStudentsWithCourse($data['course_id']);
            $students = ['' => 'Selecione o aluno'] + $students->pluck('name', 'id')->toArray();
            if (empty($data['student_id'])) {
                $reportData = $this->dataGradesWithFinalAverages($data['course_id']);
            } else {
                $reportData = $this->dataGradesWithFinalAverages($data['course_id'], $data['student_id']);
                $selectedStudent = $data['student_id'];
            }
            $reportData = Helpers::paginate($reportData, 10, \request('page'));
        }

        return view('admin.reports.report-grades-with-final-average',
            compact('env', 'title', 'bread', 'courses', 'selectedCourse', 'students', 'selectedStudent', 'reportData', 'headers', 'students'));
    }

    /**
     * @param $courseId
     * @param $studentId
     * @return \Illuminate\Support\Collection
     */
    public function getStudentsWithCourse($courseId, $studentId = null)
    {
        $return = collect();
        $students = $this->hiredCourseRepository->getHiredCoursesWithStudentData($courseId, $studentId)->get();

        foreach ($students as $student) {
            $return->push(['id' => $student->id, 'name' => $student->name]);
        }

        $subscriptions = DB::table('hire_subscriptions AS HS')
            ->join('subscriptions AS S', 'HS.subscription_id', '=', 'S.id')
            ->join('users as U', 'HS.user_id', '=', 'U.id')
            ->select('U.id', 'U.name', 'S.full_content', 'S.id AS subs_id')
            ->groupBy('HS.user_id');

        if($studentId) {
            $subscriptions->where('HS.user_id', $studentId);
        }
        $subscriptions = $subscriptions->get();

        foreach ($subscriptions as $subscription) {
            if($subscription->full_content) {
                if (!$return->where('id', $subscription->id)->first()) {
                    $return->push(['id' => $subscription->id, 'name' => $subscription->name]);
                }
            } else {
                $hasCourse = \DB::table('course_subscription')
                    ->where('course_id', $courseId)
                    ->where('subscription_id', $subscription->subs_id)
                    ->first();
                if($hasCourse) {
                    if (!$return->where('id', $subscription->id)->first()) {
                        $return->push(['id' => $subscription->id, 'name' => $subscription->name]);
                    }
                }
            }
        }
        return $return;
    }

    /**
     * @return \Illuminate\Support\Collection
     */
    public function dataGradesWithFinalAverages($courseId, $studentId = null)
    {
        $reportData = collect([]);
        $students = $this->getStudentsWithCourse($courseId, $studentId);

        foreach ($students as $student) {
            $reportData->push($this->getGradles($courseId, $student['id']));
        }

        return $reportData;
    }

    /**
     * @param $courseId
     * @param $studentId
     * @return string[]
     */
    public function getGradles($courseId, $studentId)
    {
        $student = \DB::table('users')->find($studentId);
        $evaluations = \DB::table('course_resources')
            ->where('course_id', $courseId)
            ->where('consists_average', 1)
            ->whereNull('deleted_at')
            ->get();

        $getDataRecord = app(GetDataRecords::class);
        $quizService = app(QuizService::class);
        $studentService = app(StudentService::class);
        $count = 1;
        $collect = [
            'name' => $student->name,
            'email' => $student->email,
        ];
        $sumGrades = 0;

        foreach ($evaluations as $key => $evaluation) {
            switch ($evaluation->resource_type_id) {
                case 9:
                    $course = $getDataRecord->getCourseById($evaluation->course_id);
                    $module = $getDataRecord->getModuleById($evaluation->module_id);
                    $resource = $getDataRecord->getResourceByResourceId(9, $evaluation->resource_id);
                    $resourceType = $getDataRecord->getResourceTypeById($evaluation->resource_type_id);
                    $grade = $quizService->getFinalNote(
                            $resource->average_rule,
                            $studentId,
                            $course->slug,
                            $module->slug,
                            $resource->slug,
                            $resourceType->slug
                        )['final_note'] ?? 0;

                    $sumGrades += $grade;

                    $collect['N_' . $count] = $grade;
                    $collect['evaluation_name_' . $count] = $resource->title;
                    break;
                case 15:
                    $resource = $getDataRecord->getResourceByResourceId(15, $evaluation->resource_id);
                    $grade = \DB::table('task_sents')
                            ->where('course_id', '=', $courseId)
                            ->where('task_lesson_id', '=', $resource->id)
                            ->where('user_id', '=', $studentId)
                            ->first()->final_note ?? 0;

                    $sumGrades += $grade;

                    $collect['N_' . $count] = $grade;
                    $collect['evaluation_name_' . $count] = $resource->title;
                    break;
            }
            $collect['approved'] = $studentService->wasApprovedInTheCourse($studentId, $courseId)['approved'];
            $count++;
        }
        $average = round($sumGrades / --$count, 2);
        $collect['average'] = $average;
        $course = $getDataRecord->getCourseById($courseId);
        $collect['needed_average'] = $course->average;
        return $collect;
    }

    /**
     * @param $courseId
     * @return \Illuminate\Support\Collection
     */
    public function headers($courseId)
    {
        $getDataRecord = app(GetDataRecords::class);
        $evaluations = \DB::table('course_resources')
            ->where('course_id', $courseId)
            ->where('consists_average', 1)
            ->whereNull('deleted_at')
            ->get();
        $collect = null;
        $count = 1;
        foreach ($evaluations as $key => $evaluation) {
            $resource = $getDataRecord->getResourceByResourceId($evaluation->resource_type_id, $evaluation->resource_id);
            $collect[$count] = $resource->title;
            $count++;
        }
        return $headers = collect($collect);
    }
}