eagle.ead.lmsestudio.com.br

UnknownSec Bypass 403

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

namespace EstudioLMS\Http\Controllers\Admin\Ticket;

use EstudioLMS\Base\ResponseBuilder;
use EstudioLMS\Events\TicketNotification;
use EstudioLMS\Http\Requests\Admin\Ticket\ReplyTicketRequest;
use EstudioLMS\Repositories\Auth\UserRepository;
use EstudioLMS\Repositories\Courses\Course\CourseRepository;
use EstudioLMS\Repositories\Environment\HiredCourseRepository;
use EstudioLMS\Repositories\Ticket\TicketMessageRepository;
use EstudioLMS\Repositories\Ticket\TicketRepository;
use File;
use Illuminate\Contracts\Auth\Guard;
use Illuminate\Http\Request;

use EstudioLMS\Http\Requests;
use EstudioLMS\Http\Controllers\Controller;
use Illuminate\Translation\Translator;
use mjanssen\BreadcrumbsBundle\Breadcrumbs;
use Storage;

/**
 * Class TicketController
 * @package EstudioLMS\Http\Controllers\Admin\Ticket
 */
class TicketController extends Controller
{
    /**
     * @var ResponseBuilder
     */
    private $responseBuilder;
    /**
     * @var Breadcrumbs
     */
    private $breadcrumbs;
    /**
     * @var Translator
     */
    private $translator;
    /**
     * @var TicketRepository
     */
    private $ticketRepository;
    /**
     * @var TicketMessageRepository
     */
    private $ticketMessageRepository;
    /**
     * @var HiredCourseRepository
     */
    private $hiredCourseRepository;
    /**
     * @var Guard
     */
    private $auth;
    /**
     * @var CourseRepository
     */
    private $courseRepository;
    /**
     * @var UserRepository
     */
    private $userRepository;

    /**
     * @param ResponseBuilder $responseBuilder
     * @param Breadcrumbs $breadcrumbs
     * @param Translator $translator
     * @param TicketRepository $ticketRepository
     * @param TicketMessageRepository $ticketMessageRepository
     * @param HiredCourseRepository $hiredCourseRepository
     * @param Guard $auth
     * @param CourseRepository $courseRepository
     * @param UserRepository $userRepository
     */
    public function __construct(
        ResponseBuilder $responseBuilder,
        Breadcrumbs $breadcrumbs,
        Translator $translator,
        TicketRepository $ticketRepository,
        TicketMessageRepository $ticketMessageRepository,
        HiredCourseRepository $hiredCourseRepository,
        Guard $auth,
        CourseRepository $courseRepository,
        UserRepository $userRepository
    )
    {
        $this->middleware('admins');
        $this->responseBuilder = $responseBuilder;
        $this->breadcrumbs = $breadcrumbs;
        $this->translator = $translator;
        $this->ticketRepository = $ticketRepository;
        $this->ticketMessageRepository = $ticketMessageRepository;
        $this->hiredCourseRepository = $hiredCourseRepository;
        $this->auth = $auth;
        $this->courseRepository = $courseRepository;
        $this->userRepository = $userRepository;
    }

    /**
     * @return mixed
     */
    public function index()
    {
        $env = 'coursemanager';
        $title = trans('admin_ticket.title');

        $this->breadcrumbs->addBreadcrumb(trans('admin_master.breadDash'), route('environment.index'));
        $this->breadcrumbs->addBreadcrumb(trans('admin_ticket.title'), route('admin.ticket.index'));
        $bread = $this->breadcrumbs->generate();

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

    /**
     * @return mixed
     */
    public function apiIndex()
    {
        $tickets = $this->ticketRepository->with(['type', 'course', 'status', 'messages'])->all();
        foreach ($tickets as $key => $ticket) {
            $tickets[$key]['course_name'] = $ticket['course']['name'];
            $tickets[$key]['status_name'] = $ticket['status']['name'];
        }
        return $tickets;
    }

    /**
     * @param $guid
     * @return mixed
     */
    public function show($guid)
    {
        $env = 'coursemanager';
        $title = trans('admin_ticket.titleShow');

        $this->breadcrumbs->addBreadcrumb(trans('admin_master.breadDash'), route('environment.index'));
        $this->breadcrumbs->addBreadcrumb(trans('admin_ticket.title'), route('admin.ticket.index'));
        $this->breadcrumbs->addBreadcrumb(trans('admin_ticket.breadTicketShow'), route('admin.ticket.show'));
        $bread = $this->breadcrumbs->generate();

        $ticket = $this->ticketRepository
            ->with(['type', 'course', 'status', 'messages', 'messages.from', 'messages.to'])
            ->findByField('GUID', $guid)
            ->first();

        return $this->responseBuilder->render(
            'admin.ticket.show',
            compact('ticket'),
            compact('env', 'bread', 'title')
        );
    }

    /**
     * @param ReplyTicketRequest $request
     * @return \Illuminate\Http\RedirectResponse
     * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
     */
    public function reply(ReplyTicketRequest $request)
    {
        $data = $request->all();

        $ticket = $this->ticketRepository
            ->with('messages')
            ->findByField('GUID', $data['guid'])
            ->first();

        $this->ticketRepository->update(['ticket_status_id' => 2], $ticket['id']);

        if ($request->hasFile('attachment')) {
            if ($request->file('attachment')->isValid()) {
                $data['attachment'] = $request->file('attachment')->getClientOriginalName();
                Storage::disk('ticket')->put($data['guid'] . '/' . $data['attachment'],
                    File::get($request->file('attachment')));
            }
        } else {
            $data['attachment'] = null;
        }

        $data['to_id'] = $ticket['messages'][0]['from_id'];

        $this->ticketRepository->update(['ticket_status_id' => 2], $ticket['id']);

        $newMessage = [
            'ticket_id' => $ticket['id'],
            'from_id' => $this->auth->user()['id'],
            'to_id' => $data['to_id'],
            'message' => $data['message'],
            'attachment' => $data['attachment']
        ];
        $message = $this->ticketMessageRepository->create($newMessage);

        $notify = [
            'link' => route('student.ticket.show', $ticket['GUID']),
            'course_id' => $ticket['course_id'],
            'from_id' => $message['from_id'],
            'to_id' => $message['to_id'],
            'message' => $message['message'],
            'attachment' => !empty($message['attachment']),
            'url' => route('index')
        ];
        \Event::fire(new TicketNotification($notify, $ticket['ticket_type_id'], 'R', 'A'));

        return redirect()->route('admin.ticket.index');
    }

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

        $ticket = $this->ticketRepository->with(['messages'])->find($data['id']);
        $ticket['ticket_status_id'] = 3;
        $ticket->save();

        $message = $ticket['messages']['0'];

        $to = $this->userRepository->find($message['from_id']);

        if ($to->roles[0]->name == 'student') {
            $showRoute = 'student.ticket.show';
        } else {
            $showRoute = 'teacher.ticket.show';
        }

        $notify = [
            'link' => route($showRoute, $ticket['GUID']),
            'course_id' => $ticket['course_id'],
            'from_id' => $this->auth->user()['id'],
            'to_id' => $message['from_id'],
            'message' => '',
            'attachment' => !empty($message['attachment'])
        ];

        \Event::fire(new TicketNotification($notify, $ticket['ticket_type_id'], 'C', 'A'));

        if ($ticket['ticket_type_id'] == 1) {
            $showRoute = 'teacher.ticket.show';
            $notify = [
                'link' => route($showRoute, $ticket['GUID']),
                'course_id' => $ticket['course_id'],
                'from_id' => $this->auth->user()['id'],
                'to_id' => $message['to_id'],
                'message' => '',
                'attachment' => !empty($message['attachment']),
                'url' => route('index')
            ];

            \Event::fire(new TicketNotification($notify, $ticket['ticket_type_id'], 'C', 'A'));
        }

        return $ticket;
    }

    /**
     * @param $guid
     * @param $attach
     * @return \Symfony\Component\HttpFoundation\BinaryFileResponse
     */
    public function download($guid, $attach)
    {
        return response()->download('storage/tickets/attachments/' . $guid . '/' . $attach);
    }
}