403WebShell

403Webshell
Server IP : 45.32.152.128 / Your IP : 216.73.216.91
Web Server : nginx/1.24.0
System : Linux stage-vultr 5.4.0-216-generic #236-Ubuntu SMP Fri Apr 11 19:53:21 UTC 2025 x86_64
User : forge ( 1000)
PHP Version : 8.2.14
Disable Function : NONE
MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : ON | Sudo : ON | Pkexec : ON
Directory : /home/forge/lms.pdgm.dev/app/Http/Controllers/
Upload File :
[ Back ]
Current File : /home/forge/lms.pdgm.dev/app/Http/Controllers/EventController.php
<?php

namespace App\Http\Controllers;

use App\Http\Resources\_Answer;
use App\Http\Resources\_Event;
use App\Http\Resources\_EventTemplate;
use App\Http\Resources\_Test;
use App\Http\Resources\_TestRating;
use App\Http\Resources\_User;
use App\Models\Answer;
use App\Models\Event;
use App\Models\EventConflict;
use App\Models\EventParticipation;
use App\Models\EventTemplate;
use App\Models\EventUser;
use App\Models\StartedTask;
use App\Models\Task;
use App\Models\Test;
use App\Models\TestRating;
use App\Models\User;
use App\Notifications\TaskEvaluated;
use App\Rules\HasRoles;
use App\Traits\hasHelpers;
use Carbon\Carbon;
use Illuminate\Auth\Access\AuthorizationException;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Hash;
use Illuminate\Validation\ValidationException;
use Inertia\Inertia;

class EventController extends Controller
{
    use hasHelpers;
    /**
     * Display a listing of the resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function index()
    {

        $events = _Event::collection(
            Event::with([
                'aircraft',
                'airports',
                'eventUsers',
                'rooms',
                'tasks',
                'courses'
            ])
                ->where('ends_at', '>', now())
                ->orderBy('starts_at', 'ASC')
                ->get()
        );

        return Inertia::render('admin/events', compact('events'));
    }

    /**
     * Show the form for creating a new resource.
     * 
     * @return \Illuminate\Http\Response
     */
    public function create()
    {
        //
    }

    /**
     * Store a newly created resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Http\Response
     */
    public function store(Request $request)
    {
        if ($this->_timestamp($request->starts_at)->lt(now()->subHour()))
            return throw ValidationException::withMessages(['event' => __('validation.after', ['attribute' => 'starts_at', 'date' => now()->subHour()->format('d. m. Y H:i:s')])]);

        $task = Task::find($request->task_id ?? NULL);

        // if ($task?->type == 'THEORY' && !$task?->test?->locked && !$request->test_starts_at)
        //     return throw ValidationException::withMessages(['test_starts_at' => __('validation.required')]);

        // $request->validate($validations[$task->type ?? 'BASIC']);

        // dd($request->starts_at, $this->_timestamp($request->starts_at)->utc() );

        $random = fn () => rand(0, 9) . rand(0, 9) . rand(0, 9) . rand(0, 9) . rand(0, 9) . rand(0, 9);

        $event = Event::create([
            'name' => $request->name ?? $task->name ?? '_EMPTY_',
            'type' => $task ? 'TASK' : 'BASIC',
            'starts_at' => $this->_timestamp($request->starts_at),
            'ends_at' => $this->_timestamp($request->ends_at),
            'locked' => $task?->test?->locked ?? false,
            'test_starts_at' => $task?->test?->locked ? NULL : ($request->test_starts_at ? $this->_timestamp($request->test_starts_at) : $this->_timestamp($request->starts_at)),
            'participation_code' => $task?->confirm_participation ? $this->participationCode()  : NULL
        ]);

        $event->trainingGroups()->syncWithoutDetaching($request->training_groups ?? []);
        $event->tasks()->syncWithoutDetaching($task ? [$task->id] : []);
        $event->users()->syncWithoutDetaching(array_merge($request->users ?? [], $request->students ?? [], $request->instructors ?? [], $request->approvers ?? []));
        $event->rooms()->syncWithoutDetaching($request->rooms ?? []);
        $event->equipment()->syncWithoutDetaching($request->equipment ?? []);
        $event->aircraft()->syncWithoutDetaching($request->aircraft ?? []);
        $event->airports()->syncWithoutDetaching($request->airports ?? []);

        $this->checkConflicts($event);

        return back()->with(['flash' => ['event' => _Event::init($event)]]);
    }

    /**
     * Display the specified resource.
     *
     * @param  \App\Models\Event  $event
     * @return \Illuminate\Http\Response
     */
    public function show(Request $request, Event $event)
    {
        $roleName = (Auth::user()->roles)->first()->name;

        $request->merge([
            'with_test' => true
        ]);

        $event = _Event::init(
            $event
                ->load(
                    [
                        'task' /* => fn ($q) => $q->with(['test']) */,
                        'users'
                    ]
                )
        );



        if ($roleName == "Super Admin" || $roleName == "Instructor" || $roleName == "Admin") {
            $event->load(["users", "eventParticipations"]);
            $participations = EventParticipation::where("event_id", $event->id)->with("user")->get();

            return Inertia::render('admin/events/show', compact('event', "participations"));
        } else {
            if ($event?->task?->type == "LECTURE") {
                return Inertia::render('events/lecture', compact('event'));
            } else {
                return Inertia::render('events/show', compact('event'));
            }
        }
    }

    public function confirm(Event $event)
    {
        $event = _Event::init($event);
        return Inertia::render('events/confirm', compact('event'));
    }

    public function reject(Event $event)
    {
        $event = _Event::init($event);
        return Inertia::render('events/reject', compact('event'));
    }

    public function data(Event $event)
    {
        $event = _Event::init($event->load(
            [
                'task' => fn ($q) => $q->with(['test']),
                'aircraft',
                'airports',
                'users',
                'rooms',
                'equipment',
                'eventConflicts',
                'trainingGroups' => fn ($q) => $q->with(['users']),
                'airspaceZones'
            ]
        ));

        return response()->json(['event' => $event]);
    }

    public function test(Event $event)
    {
        $event = _Event::init($event->load(
            [
                'task' => fn ($q) => $q->with(['test'])
            ]
        ));

        return Inertia::render('events/test', compact('event'));
    }

    /**
     * Show the form for editing the specified resource.
     *
     * @param  \App\Models\Event  $event
     * @return \Illuminate\Http\Response
     */
    public function edit(Event $event)
    {
        //
    }

    public function resolve(Request $request, Event $event)
    {
        $resolve_type = $request->resolve_type;
        $user_id = $request->user_id;
        $event = _Event::init($event->load('task'));


        // if ($resolve_type == 'App\\Models\\Answer') {

        $answers = Answer::where('event_id', $event->id)->where('user_id', $user_id)->get();
        $answers = _Answer::collection($answers->load(['question' => fn ($p) => $p->with('questionOptions'), 'questionOptions']));

        $test = _Test::init($event->task?->test);

        $testRating = null;

        if ($test) {
            $testRating = TestRating::where(['test_id' => $test->id, 'user_id' => $user_id])->first();
            $testRating = _TestRating::init($testRating);
        }

        $asigned_user = _User::init(User::find($user_id));
        // dd($answers);
        // $answers = _Answer::collection($answers);
        return Inertia::render("admin/events/test_resolve", compact('event', 'resolve_type', 'answers', 'testRating', 'asigned_user'));
        // } else {
        //     $asigned_user = User::find($user_id);
        //     $asigned_user = _User::init($asigned_user);
        //     $event_participation = EventParticipation::where(['user_id' => $user_id, 'event_id' => $event->id])->first();
        //     return Inertia::render("admin/events/participation", compact('event', 'resolve_type', 'asigned_user', 'event_participation'));
        // }
    }

    public function resolve_task(Request $request)
    {

        $request->validate([
            // 'comment' => 'required',
            'final_evaluation' => 'required'
        ]);

        $startedTask = StartedTask::where(['user_id' => $request->user_id, 'event_id' => $request->event_id])->first();

        $startedTask->update([
            'final_evaluation' => $request->final_evaluation,
            'finished' => true,
            'comment' => $request->comment ?? NULL,
            'completed_repetitions' => $request->completed_repetitions ?? 1
        ]);

        $startedTask->user->notify(new TaskEvaluated($startedTask->fresh()));

        return redirect(route("admin.users.edit", ["user" => $request->user_id]));
    }

    public function manual_resolve_task(Request $request)
    {
        if (!Hash::check($request->code, Auth::user()->pin_code))
            return throw ValidationException::withMessages(['code' => __('auth.failed')]);

        $request->validate([
            // 'comment' => 'required',
            // 'final_evaluation' => 'required'
        ]);

        $task = Task::find($request->task_id);

        if ($startedTask = StartedTask::where(['task_id' => $request->task_id, 'user_id' => $request->user_id, 'event_id' => NULL])->whereNotNull('final_evaluation')->first()) {
            $startedTask->delete();
            return back();
        }

        $startedTask = StartedTask::updateOrCreate([
            'task_id' => $request->task_id,
            'user_id' => $request->user_id,
            'event_id' => NULL,
        ], [
            'final_evaluation' => ($request->completed_repetitions ?? 1) == $task->repetitions ?  $request->final_evaluation : NULL,
            'finished' => ($request->completed_repetitions ?? 1) == $task->repetitions,
            'comment' => $request->comment ?? NULL,
            'completed_repetitions' => $request->completed_repetitions ?? 1
        ]);

        $startedTask->user->notify(new TaskEvaluated($startedTask->fresh()));

        return back(); // redirect(route("admin.tasks.manualEdit", ["startedTask" => $startedTask->id]));
    }

    public function participated(Request $request, EventParticipation $event_participation)
    {

        $request->validate([
            'evaluation' => 'required',
            'comment' => 'required'
        ]);


        return redirect(route('admin.index'));
    }

    function participationCode()
    {
        return rand(0, 9) . rand(0, 9) . rand(0, 9) . rand(0, 9) . rand(0, 9) . rand(0, 9);
    }

    /**
     * Update the specified resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \App\Models\Event  $event
     * @return \Illuminate\Http\Response
     */
    public function update(Request $request, Event $event)
    {
        $request->validate([
            'starts_at' => 'required',
            'ends_at' => 'required',
            'type' => 'required',
            'name' => 'required'
        ]);

        $task = Task::find($request->task_id ?? NULL);

        if ($event->startedTasks()->count() > 0) {
            return throw ValidationException::withMessages(['event' => __('validation.custom.started')]);
        }

        if ($task?->type == 'THEORY' && !$task?->test?->locked && !$request->test_starts_at)
            return throw ValidationException::withMessages(['test_starts_at' => __('validation.required')]);

        $event->update([
            'starts_at' => $this->_timestamp($request->starts_at),
            'ends_at' => $this->_timestamp($request->ends_at),
            'locked' => $task?->test?->locked ?? false,
            'test_starts_at' => $task?->test?->locked
                ? NULL
                : (
                    $request->test_starts_at
                    ? $this->_timestamp($request->test_starts_at)
                    : (
                        !$this->_timestamp($request->starts_at)->isSameMinute($event->starts_at)
                        ? $this->_timestamp($request->starts_at)
                        : NULL
                    )
                ),
            'type' => $request->type,
            'name' => $request->name,
            'note' => $request->note,
            'participation_code' => ($task?->id != $event->task_id) ? ($task?->confirm_participation ? $this->participationCode() : NULL) : $event->participation_code

            // 'assessor_id' => $request->assessor_id ?? NULL,
            // 'approver_id' => $request->approver_id ?? NULL
        ]);




        $event->trainingGroups()->sync($request->training_groups ?? []);
        $event->tasks()->sync($task ? [$task->id] : []);
        $event->users()->sync(array_merge($request->students ?? [], $request->instructors ?? [], $request->approvers ?? []));
        $event->rooms()->sync($request->rooms ?? []);
        $event->aircraft()->sync($request->aircraft ?? []);
        $event->airports()->sync($request->airports ?? []);

        $this->checkConflicts($event);
        $event->approval?->delete();

        return back()->with(['flash' => ['updated' => $event->id]]);
    }

    public function checkConflicts(Event $event)
    {
        $event->eventConflicts()->delete();
        $event->conflictingWith()->delete();

        $to_check = ($event->users ?? collect())
            ->merge($event->rooms)
            ->merge($event->aircraft);

        foreach ($to_check as $key => $item) {
            $conflicting = $item->events()
                ->join(
                    'events as e2',
                    fn ($join) =>
                    $join->on('events.id', '<', 'e2.id')
                        ->where('events.starts_at', '<', DB::raw('e2.ends_at'))
                        ->where('e2.starts_at', '<', DB::raw('events.ends_at'))
                        ->join(
                            "{$item->events()->getTable()} as eu",
                            fn ($q) =>
                            $q->on('e2.id', '=', 'eu.event_id')
                                ->where("eu.{$item->events()->getForeignPivotKeyName()}", '=', $item->id)
                        )
                )->select(['events.id as event_id', 'e2.id as conflicting_id'])
                ->get(['event_id', 'conflicting_id']);

            foreach ($conflicting as $key => $conflict) {
                EventConflict::updateOrCreate([
                    'event_id' => $conflict->event_id,
                    'conflicting_id' => $conflict->conflicting_id,
                    'source_type' => $item::class,
                    'source_id' => $item->id
                ]);
            }
        }
    }

    /**
     * Update the specified resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \App\Models\Event  $event
     * @return \Illuminate\Http\Response
     */
    public function updatePartial(Request $request, Event $event)
    {

        if ($event->startedTasks()->count() > 0) {
            return throw ValidationException::withMessages(['event' => __('validation.custom.started')]);
        }

        $task = Task::find($request->tasks[0] ?? NULL);

        $to_update = array_merge(
            $request->starts_at ? ['starts_at' => $this->_timestamp($request->starts_at)] : [],
            $request->ends_at ? ['ends_at' => $this->_timestamp($request->ends_at)] : [],
            ($request->starts_at || $request->test_starts_at) ? [
                'test_starts_at' => $task?->test?->locked
                    ? NULL
                    : (
                        $request->test_starts_at
                        ? $this->_timestamp($request->test_starts_at)
                        : (
                            !$this->_timestamp($request->starts_at)->isSameMinute($event->starts_at)
                            ? $this->_timestamp($request->starts_at)
                            : NULL
                        )
                    ),
            ] : [],
            $request->name ? ['name' => $request->name] : [],
            $request->note ? ['note' => $request->note] : [],
            $request->assessor_id ? ['assessor_id' => $request->assessor_id] : [],
            $request->approver_id ? ['approver_id' => $request->approver_id] : [],
            $task ? [
                'type' => 'TASK',
                'participation_code' => ($task?->confirm_participation ? $this->participationCode() : NULL),
                'locked' => $task?->test?->locked ?? false,
            ] : [],
        );

        $event->update($to_update);

        if ($task) {
            $event->tasks()->sync([$task->id]);
        }

        if ($request->has('training_groups'))
            $event->trainingGroups()->sync($request->training_groups ?? []);
        if ($request->has('users') || $request->has('students') || $request->has('instructors') /* || $request->has('approvers') */)
            $event->users()->sync(array_merge($request->users ?? [], $request->students ?? [], $request->instructors ?? [], $request->approvers ?? []));
        if ($request->has('rooms'))
            $event->rooms()->sync($request->rooms ?? []);
        if ($request->has('equipment'))
            $event->equipment()->sync($request->equipment ?? []);
        if ($request->has('aircraft'))
            $event->aircraft()->sync($request->aircraft ?? []);
        if ($request->has('airports'))
            $event->airports()->sync($request->airports ?? []);
        if ($request->has('airspaceZones'))
            $event->airspaceZones()->sync($request->airspaceZones ?? []);
        if ($request->has('courses'))
            $event->courses()->sync($request->courses ?? []);

        $this->checkConflicts($event);
        $event->approval?->delete();

        return back()->with(['flash' => ['event' => _Event::init(
            $event->load(
                [
                    'task' => fn ($q) => $q->with(['test']),
                    'aircraft',
                    'airports',
                    'users',
                    'rooms',
                    'equipment',
                    'trainingGroups' => fn ($q) => $q->with(['users']),
                    'airspaceZones'
                ]
            )
        )]]);
    }

    public function unlock(Request $request, Event $event)
    {
        // Odemkne event, pokud se jedná o test, nastaví se čas začátku testu, aby žák mohl test spustit.
        if (!is_null($event?->task?->test?->instructor_id) && $event?->task?->test?->instructor_id != Auth::user()?->id)
            return throw ValidationException::withMessages(['task' => __('validation.not_assigned')]);

        $event->update([
            'locked' => 0,
            'test_starts_at' => ($event->task->type == "THEORY") ? Carbon::now() : null
        ]);

        return back();
    }

    public function confirm_code(Request $request, Event $event)
    {
        // Checkuje kód pro potvrzení účasti
        $request->validate([
            'code' => 'required|size:6',
        ]);

        if ($request->code === $event->participation_code) {
            EventParticipation::updateOrCreate(
                [
                    'event_id' => $event->id,
                    'user_id' => Auth::user()->id
                ],
                [
                    'required' => true,
                    'participated' => true
                ]

            );

            return redirect(route("events.show", ["event" => $event->id]));
        } else {
            return back()->withErrors(["code" => "Code is not valid. Use one-time participation code provided by the instructor, not your personal PIN."]);
        }
    }

    public function reject_code(Request $request, Event $event)
    {
        // Checkuje kód pro potvrzení účasti
        $request->validate([
            'code' => 'required|size:6',
        ]);

        if (Hash::check($request->code, Auth::user()->pin_code)) {
            EventParticipation::updateOrCreate(
                [
                    'event_id' => $event->id,
                    'user_id' => Auth::user()->id
                ],
                [
                    'required' => true,
                    'participated' => 0
                ]

            );

            return redirect(route("events.show", ["event" => $event->id]));
        } else {
            return back()->withErrors(["code" => "Code is not valid. Use your personal PIN to reject this event."]);
        }
    }

    /**
     * Remove the specified resource from storage.
     *
     * @param  \App\Models\Event  $event
     * @return \Illuminate\Http\Response
     */
    public function destroy(Event $event)
    {
        $event->eventConflicts()->delete();
        $event->conflictingWith()->delete();
        $event->delete();
        return back();
    }
}
Youez - 2016 - github.com/yon3zu
LinuXploit