eagle.ead.lmsestudio.com.br

UnknownSec Bypass 403

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

namespace EstudioLMS\Http\Controllers\Admin\Gamification;

use EstudioLMS\Base\ResponseBuilder;
use EstudioLMS\Http\Controllers\Controller;
use EstudioLMS\Http\Requests\Admin\Gamification\BadgeRuleRequest;
use EstudioLMS\Repositories\Courses\Course\CourseRepository;
use EstudioLMS\Repositories\Gamification\BadgeInterface;
use EstudioLMS\Repositories\Gamification\BadgeRuleInterface;
use EstudioLMS\Repositories\Gamification\RuleTypeInterface;
use EstudioLMS\Services\Admin\BadgeRuleService;
use Flash;
use Illuminate\Http\Request;
use mjanssen\BreadcrumbsBundle\Breadcrumbs;

/**
 * Class RuleController
 * @package EstudioLMS\Http\Controllers\Admin\Gamification
 */
class RuleController extends Controller
{
    /**
     * @var ResponseBuilder
     */
    private $responseBuilder;
    /**
     * @var Breadcrumbs
     */
    private $breadCrumbs;
    /**
     * @var RuleTypeInterface
     */
    private $ruleType;
    /**
     * @var BadgeRuleInterface
     */
    private $badgeRule;
    /**
     * @var BadgeInterface
     */
    private $badge;
    /**
     * @var CourseRepository
     */
    private $courseRepository;
    /**
     * @var BadgeRuleService
     */
    private $badgeRuleService;

    /**
     * RuleController constructor.
     * @param ResponseBuilder $responseBuilder
     * @param Breadcrumbs $breadCrumbs
     * @param RuleTypeInterface $ruleType
     * @param BadgeRuleInterface $badgeRule
     * @param BadgeInterface $badge
     * @param CourseRepository $courseRepository
     * @param BadgeRuleService $badgeRuleService
     */
    public function __construct(
        ResponseBuilder $responseBuilder,
        Breadcrumbs $breadCrumbs,
        RuleTypeInterface $ruleType,
        BadgeRuleInterface $badgeRule,
        BadgeInterface $badge,
        CourseRepository $courseRepository,
        BadgeRuleService $badgeRuleService
    )
    {
        $this->middleware('admins');
        $this->responseBuilder = $responseBuilder;
        $this->breadCrumbs = $breadCrumbs;
        $this->ruleType = $ruleType;
        $this->badgeRule = $badgeRule;
        $this->badge = $badge;
        $this->courseRepository = $courseRepository;
        $this->badgeRuleService = $badgeRuleService;
    }


    /**
     * Display a listing of the resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function index()
    {
        $title = trans('game_rule.createPageTitle');
        $env = 'coursemanager';

        $this->breadCrumbs->addBreadcrumb(trans('admin_master.breadDash'), route('admin.index'));
        $this->breadCrumbs->addBreadcrumb(trans('game_rule.ListPageTitle'), route('admin.rule.index'));
        $bread = $this->breadCrumbs->generate();

        return $this->responseBuilder
            ->render('admin.gamification.rules.list',
                [],
                compact('title', 'env', 'bread')
            );
    }

    /**
     * @return mixed
     */
    public function indexAPI()
    {
        $badges = $this->badgeRule->all();
        foreach ($badges as $key => $badge) {
            $badges[$key]['has_rule'] = 0;
            $ruleComp = $this->badgeRuleService->getRuleCompleteData($badge['rule_type_id'], $badge['id']);
            if ($ruleComp) {
                $badges[$key]['has_rule'] = 1;
            }
        }
        return $badges;
    }

    /**
     * Show the form for creating a new resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function create()
    {
        $title = trans('game_rule.createPageTitle');
        $env = 'coursemanager';

        $badges = $this->badge->all();
        $courses = $this->courseRepository->all()->lists('name', 'id');
        $ruleTypes = $this->ruleType->all()->lists('title', 'id');

        $this->breadCrumbs->addBreadcrumb(trans('admin_master.breadDash'), route('admin.index'));
        $this->breadCrumbs->addBreadcrumb(trans('game_rule.ListPageTitle'), route('admin.rule.index'));
        $this->breadCrumbs->addBreadcrumb($title, route('admin.rule.create'));
        $bread = $this->breadCrumbs->generate();

        return $this->responseBuilder
            ->render('admin.gamification.rules.create',
                compact('badges', 'courses', 'ruleTypes'),
                compact('title', 'env', 'bread')
            );
    }

    /**
     * Store a newly created resource in storage.
     *
     * @param  BadgeRuleRequest $request
     * @return \Illuminate\Http\RedirectResponse
     */
    public function store(BadgeRuleRequest $request)
    {
        $data = $request->all();
        $return = $this->badgeRuleService->create($data);
        if ($return['success']) {
            Flash::success($return['message'] . '<br>' . trans('game_rule.dontForgetComplete'));
            return redirect()->route('admin.rule.edit', $return['id']);
        }
        Flash::error($return['message']);
        return redirect()->route('admin.rule.index');
    }

    /**
     * Show the form for editing the specified resource.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function edit($id)
    {
        $title = trans('game_rule.editPageTitle');
        $env = 'coursemanager';

        $data = $this->badgeRule->find($id);

        $badges = $this->badge->all();
        $courses = $this->courseRepository->all()->lists('name', 'id');
        $ruleTypes = $this->ruleType->all()->lists('title', 'id');

        $this->breadCrumbs->addBreadcrumb(trans('admin_master.breadDash'), route('admin.index'));
        $this->breadCrumbs->addBreadcrumb(trans('game_rule.ListPageTitle'), route('admin.rule.index'));
        $this->breadCrumbs->addBreadcrumb($title, route('admin.rule.edit', $id));
        $bread = $this->breadCrumbs->generate();

        $complete = $this->badgeRuleService->getRuleCompleteData($data['rule_type_id'], $data['id']);

        return $this->responseBuilder
            ->render('admin.gamification.rules.edit',
                compact('data', 'badges', 'courses', 'ruleTypes', 'complete'),
                compact('title', 'env', 'bread')
            );
    }

    /**
     * Update the specified resource in storage.
     *
     * @param  BadgeRuleRequest $request
     * @return \Illuminate\Http\RedirectResponse
     */
    public function update(BadgeRuleRequest $request)
    {
        $data = $request->all();
        $return = $this->badgeRuleService->update($data);
        if ($return['success']) {
            return redirect()->route('admin.rule.edit', $return['id']);
        }
        Flash::error($return['message']);
        return redirect()->route('admin.rule.index');
    }

    /**
     * @param $ruleId
     * @return mixed
     */
    public function complete($ruleId)
    {
        $data = $this->badgeRule->find($ruleId);
        switch ($data['rule_type_id']) {
            case 1:
                return $this->quizWithAverageBetween($data);
            case 2:
                return $this->watchLesson($data);
        }
    }

    /**
     * @param $data
     * @return mixed
     */
    private function quizWithAverageBetween($data)
    {
        $courseId = $data['course_id'];
        $quizList = $this->badgeRuleService->getAllQuizWithAverageByCourse($courseId);

        $complete = $this->badgeRuleService->getRuleCompleteData($data['rule_type_id'], $data['id']);

        return $this->responseBuilder
            ->render('admin.gamification.rules.complete',
                compact('complete', 'data'),
                compact('quizList')
            );
    }

    /**
     * @param $data
     * @return mixed
     */
    private function watchLesson($data)
    {
        $courseId = $data['course_id'];
        $quizList = $this->badgeRuleService->allResourceTypesThatCanBeViewedByCourse($courseId);

        $complete = $this->badgeRuleService->getRuleCompleteData($data['rule_type_id'], $data['id']);

        return $this->responseBuilder
            ->render('admin.gamification.rules.complete',
                compact('complete', 'data'),
                compact('quizList')
            );
    }

    /**
     * @param Request $request
     */
    public function completeStore(Request $request)
    {
        $data = $request->all();
        $return = $this->badgeRuleService->storeComplement($data);
        if ($return['success']) {
            Flash::success($return['message']);
        } else {
            Flash::error($return['message']);
        }
    }

    /**
     * @param Request $request
     */
    public function completeUpdate(Request $request)
    {
        $data = $request->all();
        $return = $this->badgeRuleService->updateComplement($data);
        if ($return['success']) {
            Flash::success($return['message']);
        } else {
            Flash::error($return['message']);
        }
    }
}