eagle.ead.lmsestudio.com.br

UnknownSec Bypass 403

: /var/www/html/lms_019b16b96b63/app/Http/Controllers/Admin/Report/ [ drwxr-xr-x ]
name : ReportController.php
 <?php namespace EstudioLMS\Http\Controllers\Admin\Report;


use Carbon\Carbon;
use EstudioLMS\Base\ResponseBuilder;
use EstudioLMS\Http\Controllers\Controller;
use EstudioLMS\Http\Requests\Admin\Reports\SalesRequest;
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\Environment\HiredCourseRepository;
use EstudioLMS\Repositories\Environment\RecordRepository;
use EstudioLMS\Repositories\Financial\HireDetailRepository;
use EstudioLMS\Repositories\Financial\HireHeaderRepository;
use EstudioLMS\Services\Environment\CourseService;
use Illuminate\Http\Request;
use Illuminate\Translation\Translator;
use mjanssen\BreadcrumbsBundle\Breadcrumbs;

/**
 * Class ReportController
 * @package EstudioLMS\Http\Controllers\Admin\Report
 */
class ReportController extends Controller
{
    /**
     * @var Translator
     */
    private $translator;
    /**
     * @var Breadcrumbs
     */
    private $breadCrumb;
    /**
     * @var ResponseBuilder
     */
    private $responseBuilder;
    /**
     * @var HireHeaderRepository
     */
    private $headerRepository;
    /**
     * @var HireDetailRepository
     */
    private $detailRepository;
    /**
     * @var UserRepository
     */
    private $userRepository;
    /**
     * @var CourseRepository
     */
    private $courseRepository;
    /**
     * @var RecordRepository
     */
    private $recordRepository;
    /**
     * @var CourseResourceRepository
     */
    private $courseResourceRepository;
    /**
     * @var CourseService
     */
    private $courseService;
    /**
     * @var HiredCourseRepository
     */
    private $hiredCourseRepository;

    /**
     * ReportController constructor.
     * @param ResponseBuilder $responseBuilder
     * @param Translator $translator
     * @param Breadcrumbs $breadCrumb
     * @param HireHeaderRepository $headerRepository
     * @param HireDetailRepository $detailRepository
     * @param UserRepository $userRepository
     * @param CourseRepository $courseRepository
     * @param RecordRepository $recordRepository
     * @param CourseResourceRepository $courseResourceRepository
     * @param CourseService $courseService
     * @param HiredCourseRepository $hiredCourseRepository
     */
    public function __construct(
        ResponseBuilder $responseBuilder,
        Translator $translator,
        Breadcrumbs $breadCrumb,
        HireHeaderRepository $headerRepository,
        HireDetailRepository $detailRepository,
        UserRepository $userRepository,
        CourseRepository $courseRepository,
        RecordRepository $recordRepository,
        CourseResourceRepository $courseResourceRepository,
        CourseService $courseService,
        HiredCourseRepository $hiredCourseRepository
    )
    {
        $this->middleware('admins');
        $this->responseBuilder = $responseBuilder;
        $this->translator = $translator;
        $this->breadCrumb = $breadCrumb;
        $this->headerRepository = $headerRepository;
        $this->detailRepository = $detailRepository;
        $this->userRepository = $userRepository;
        $this->courseRepository = $courseRepository;
        $this->recordRepository = $recordRepository;
        $this->courseResourceRepository = $courseResourceRepository;
        $this->courseService = $courseService;
        $this->hiredCourseRepository = $hiredCourseRepository;
    }

    /**
     * @param Request $request
     * @return mixed
     */
    public function sales(Request $request)
    {
        $env = 'reports';
        $title = 'Relatório de Vendas';
        $data = $request->all();

        $this->breadCrumb->addBreadcrumb('Home', route('index'));
        $this->breadCrumb->addBreadcrumb('Dashboard', route('admin.index'));
        $this->breadCrumb->addBreadcrumb('Relatório de Vendas', route('admin.reports.sale'));
        $bread = $this->breadCrumb->generate();

        $courses = ['' => 'Escolha o Curso'] + $this->courseRepository->all()->lists('name', 'id')->toArray();

        $teachers = ['' => 'Escolha o Professor'] +
            $this->userRepository->allInstructors()->lists('name', 'id')->toArray();

        /* When query fields are empty or null */
        if (empty($data['date_initial']) && empty($data['date_final'])) {
            $data['date_initial'] = new Carbon('first day of this month');
            $data['date_final'] = new Carbon('last day of this month');
        }
        $data['course_id'] = !isset($data['course_id']) ? 0 : $data['course_id'];
        $data['teacher_id'] = !isset($data['teacher_id']) ? 0 : $data['teacher_id'];

        /* Getting data */
        $salesData = $this->headerRepository->reportData(
            $data['course_id'],
            $data['teacher_id'],
            $data['date_initial'],
            $data['date_final']
        );

        /* Return date fields in the correct format to view */
        if (!empty($data['date_initial'])) {
            $data['date_initial'] = Carbon::createFromFormat('Y-m-d H:i:s', $data['date_initial'])
                ->format('d/m/Y');
        }

        if (!empty($data['date_final'])) {
            $data['date_final'] = Carbon::createFromFormat('Y-m-d H:i:s', $data['date_final'])
                ->format('d/m/Y');
        }

        return $this->responseBuilder->render(
            'admin.reports.sales',
            [],
            compact('title', 'env', 'bread', 'data', 'courses', 'teachers', 'salesData')
        );
    }

    /**
     * @param SalesRequest $request
     * @return \Illuminate\Http\RedirectResponse|\Illuminate\Routing\Redirector
     */
    public function salesFilter(SalesRequest $request)
    {
        $data = $request->all();
        if (!empty($data['date_initial']))
            $data['date_initial'] = Carbon::createFromFormat('d/m/Y', $data['date_initial'])->format('Y-m-d 00:00:00');

        if (!empty($data['date_final']))
            $data['date_final'] = Carbon::createFromFormat('d/m/Y', $data['date_final'])->format('Y-m-d 23:59:59');

        $route = route('admin.reports.sale', $data);
        return redirect($route);
    }

    public function lessonsCompletedFilter()
    {
        $env = 'reports';
        $title = 'Relatório de Lições Completas por Curso';

        $this->breadCrumb->addBreadcrumb('Home', route('index'));
        $this->breadCrumb->addBreadcrumb('Dashboard', route('admin.index'));
        $this->breadCrumb->addBreadcrumb('Relatório de Lições Completas por Curso', route('admin.reports.lessons-completed'));
        $bread = $this->breadCrumb->generate();

        $courses = $this->courseRepository->withTrashed()->all()->lists('name', 'id');

        return $this->responseBuilder->render(
            'admin.reports.students-lessons-completed',
            compact('courses'),
            compact('title', 'env', 'bread')
        );
    }

    public function lessonsControllerAPI()
    {
        //$headers = $this->headerRepository->with(['user', 'details'])->all();

        $headers = \DB::table('hire_headers')
            ->join('hire_details', 'hire_headers.id', '=', 'hire_details.hire_headers_id')
            ->join('users', 'hire_headers.user_id', '=', 'users.id')
            ->groupBy('hire_details.course_id')
            ->groupBy('users.id')
            ->select(['users.id', 'users.name', 'users.email', 'hire_details.course_id'])
            ->get();

        $headers = json_decode(json_encode($headers), true);

        foreach ($headers as $header) {
            $students[] = [
                'checked' => 0,
                'course_id' => $header['course_id'],
                'user_id' => $header['id'],
                'name' => $header['name'],
                'email' => $header['email'],
                'completed' => '0%',
                'incompleted' => '0%'
            ];
        }
        return $students;
    }

    /**
     * @param Request $request
     * @return string
     */
    public function lessonsCompletedFiltering(Request $request)
    {
        $data = $request->all();

        $results = $this->recordRepository->getRecordsGrouped($data['studentId'], $data['course_id']);
        $courseLesson = $this->courseResourceRepository->findWhere(
            [
                ['course_id', '=', $data['course_id']],
                ['resource_type_id', '<>', 1]
            ]
        );

        $totalWatched = count($results);
        $totalLessons = count($courseLesson);

        $percentWatched = (($totalWatched * 100) / $totalLessons);
        $percentNotWatched = 100 - $percentWatched;

        $report[] = [
            'completed' => number_format($percentWatched, 2) . '%',
            'incompleted' => number_format($percentNotWatched, 2) . '%',
        ];
        return json_encode($report);
    }

    public function averagesReport()
    {
        $env = 'reports';
        $title = 'Relatório de Avaliações por Aluno';

        $this->breadCrumb->addBreadcrumb('Home', route('index'));
        $this->breadCrumb->addBreadcrumb('Dashboard', route('admin.index'));
        $this->breadCrumb->addBreadcrumb('Médias dos Alunos', route('admin.reports.average'));
        $bread = $this->breadCrumb->generate();

        return $this->responseBuilder->render(
            'admin.reports.averages.report',
            [],
            compact('env', 'bread', 'title')
        );
    }

    public function listTeachersAPI()
    {
        return $this->userRepository->allInstructors();
    }

    public function listCoursesAPI($userId = 0)
    {
        //return $this->courseRepository->showCourseList(false)->get();
        return $this->courseService->allCoursesByTeacher($userId);
    }

    public function listStudentsAPI($courseId)
    {
        return $this->hiredCourseRepository->getHiredCoursesWithStudentData($courseId)->get();
    }

    public function averageAPI($courseId, $userId)
    {
        return $this->courseService->getAllAttemptsOfEvaluationsWithAverageByCourse($courseId, $userId);

    }
}