eagle.ead.lmsestudio.com.br

UnknownSec Bypass 403

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

namespace EstudioLMS\Http\Controllers\Admin\Course;

use EstudioLMS\Base\ResponseBuilder;
use EstudioLMS\Helpers\Admin\CourseResources\DuplicateCourses;
use EstudioLMS\Helpers\Helpers;
use EstudioLMS\Http\Controllers\Controller;
use EstudioLMS\Http\Requests\Courses\CourseRequest;
use EstudioLMS\Repositories\Auth\UserRepository;
use EstudioLMS\Repositories\Config\GatewayRepository;
use EstudioLMS\Repositories\Courses\Course\CourseRepository;
use EstudioLMS\Repositories\Financial\PlanRepository;
use EstudioLMS\Services\Admin\CourseServices;
use EstudioLMS\Services\Environment\CourseService;
use EstudioLMS\System\HelperClass;
use Illuminate\Contracts\Auth\Guard;
use Illuminate\Http\Request;

/**
 * Class CourseController
 * @package EstudioLMS\Http\Controllers\Admin\Course
 */
class CourseController extends Controller
{

    /**
     * @var Guard
     */
    private $auth;
    /**
     * @var ResponseBuilder
     */
    private $responseBuilder;
    /**
     * @var UserRepository
     */
    private $userRepo;
    /**
     * @var CourseRepository
     */
    private $course;
    /**
     * @var PlanRepository
     */
    private $plan;
    /**
     * @var CourseServices
     */
    private $courseServices;
    /**
     * @var GatewayRepository
     */
    private $gatewayRepository;
    /**
     * @var CourseService
     */
    private $courseService;

    /**
     * @param ResponseBuilder $responseBuilder
     * @param Guard $auth
     * @param UserRepository $userRepo
     * @param CourseRepository $course
     * @param PlanRepository $plan
     * @param CourseServices $courseServices
     * @param GatewayRepository $gatewayRepository
     * @param CourseService $courseService
     */
    public function __construct(
        responseBuilder $responseBuilder,
        Guard $auth,
        UserRepository $userRepo,
        CourseRepository $course,
        PlanRepository $plan,
        CourseServices $courseServices,
        GatewayRepository $gatewayRepository,
        CourseService $courseService
    ) {
        $this->middleware('admin_teacher');
        $this->auth = $auth;
        $this->responseBuilder = $responseBuilder;
        $this->userRepo = $userRepo;
        $this->course = $course;
        $this->plan = $plan;
        $this->courseServices = $courseServices;
        $this->gatewayRepository = $gatewayRepository;
        $this->courseService = $courseService;
    }

    /**
     * @return mixed
     */
    public function index()
    {
        $title = trans('admin_course.title');
        return $this->responseBuilder->render(
            'admin.courses.course.list_courses',
            [],
            compact('title')
        );
    }

    /**
     * @return mixed
     */
    public function apiIndex()
    {
        if ($this->auth->user()['roles'][0]['name'] === 'teacher') {
            $userId = $this->auth->user()['id'];

            return $this->course->withTrashed()->with(
                ['user', 'category', 'category.language', 'countResources', 'countModules']
            )
                ->findByField('user_id', $userId);
        }

        return $this->course->withTrashed()->with(
            ['user', 'category', 'category.language', 'countResources', 'countModules']
        )->get(['id', 'name', 'course_category_id', 'user_id', 'published', 'deleted_at']);
    }

    /**
     * @return mixed
     */
    public function create()
    {
        $title = trans('admin_course.titleNew');

        return $this->responseBuilder->render(
            'admin.courses.course.create',
            [],
            compact('title', 'statuses')
        );
    }

    /**
     * @param CourseRequest $request
     * @return \Illuminate\Http\RedirectResponse
     * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
     */
    public function store(CourseRequest $request)
    {
        $this->courseServices->storeCourse($request);
        return redirect()->route('admin.courses.course.index');
    }

    /**
     * @param $id
     * @return mixed
     */
    public function edit($id)
    {
        $course = $this->course->with(['plans', 'material'])->find($id);
        $plans = $this->plan->with('duration')->all();
        $gateways = $this->gatewayRepository->all();

        $title = trans('admin_course.titleEdit');

        foreach ($plans as $key => $plan) {
            $value = $course->plans->where('id', $plan->id)->first();

            if (count($value) > 0) {
                $plans[$key]['value'] = $value->pivot->price;
                $plans[$key]['checked'] = true;
                $plans[$key]['default'] = $value->pivot->default;
                $plans[$key]['registration'] = $value->pivot->registration;
            }
        }

        foreach ($gateways as $key => $gateway) {
            $value = $course->gateways->find($gateway->id);
            if (count($value) > 0) {
                $gateways[$key]['installments'] = $value->pivot->installments;
                $gateways[$key]['checked'] = true;
            }
        }

        return $this->responseBuilder->render(
            'admin.courses.course.edit',
            compact('course'),
            compact('plans', 'title', 'gateways')
        );
    }

    /**
     * @param CourseRequest $request
     * @return \Illuminate\Http\RedirectResponse
     * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
     */
    public function update(CourseRequest $request)
    {
        $this->courseServices->updateCourse($request);
        return redirect()->route('admin.courses.course.index');
    }

    /**
     * @param Request $request
     * @return array
     */
    public function updateStatus(Request $request)
    {
        $data = $request->all();
        $published = $data['published'] == 0 ? 1 : 0;
        $course = $this->course->find($data['id']);
        $course['published'] = $published;
        $course->save();
        $success = trans('admin_master.success');
        $message = trans('admin_master.msgSuccess');
        $ret = ['success' => $success, 'message' => $message, 'published' => $published];
        return $ret;
    }


    /**
     * Remove the specified resource from storage.
     *
     * @param Request $request
     * @return array
     */
    public function destroy(Request $request)
    {
        $data = $request->all();
        $this->course->find($data['id']);
        $this->course->delete($data['id']);
        $ret = ['success' => trans('admin_master.delete'), 'message' => trans('admin_master.msgDelete')];
        return $ret;
    }

    /**
     * @param Request $request
     * @return string[]
     */
    public function restoreCategory(Request $request)
    {
        $data = $request->all();
        $course = $this->course->restore($data['id']);
        $success = trans('admin_master.success');
        $message = trans('admin_master.restoreSuccess');;
        $ret = ['success' => $success, 'message' => $message];
        return $ret;
    }

    /**
     * @return \Illuminate\Contracts\View\Factory|\Illuminate\Foundation\Application|\Illuminate\View\View
     */
    public function duplicate($courseId)
    {
        $course = $this->course->find($courseId);
        $storageNeeded = app(DuplicateCourses::class)->necessaryStorage($courseId);
        $attachments = Helpers::convertBytesToSpecified($storageNeeded['attachments'],'M');
        $videos = Helpers::convertBytesToSpecified($storageNeeded['videos'], 'M');
        $hotPot = Helpers::convertBytesToSpecified($storageNeeded['hot_pot'], 'M');
        $total = $attachments + $videos + $hotPot;

        $planStorageSize = \Session::get('planLimite.plan_storage') * 1048576;
        $usedStorageSize = app(HelperClass::class)->storageSize() * 1048576;

        $planStorageSize = Helpers::convertBytesToSpecified($planStorageSize, 'M');
        $usedStorageSize = Helpers::convertBytesToSpecified($usedStorageSize, 'M');
        $disponible = $planStorageSize - $usedStorageSize;
        $final = $disponible - $total;

        return view('admin.courses.course.duplicate',
            compact('course', 'attachments', 'videos', 'hotPot', 'total', 'disponible', 'final'));
    }

    /**
     * @param Request $request
     * @return string
     * @throws \Exception
     */
    public function doDuplicate(Request $request)
    {
        $data = $request->all();
        $data['types'] = $data['types'] ?? [];
        $result = app(DuplicateCourses::class)
            ->duplicateCourse($data['course_id'], $data['types']);
        return $result;
    }
}