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/beta.lms.pdgm.dev/database/seeders/
Upload File :
[ Back ]
Current File : /home/forge/beta.lms.pdgm.dev/database/seeders/EventsSeeder.php
<?php

namespace Database\Seeders;

use App\Models\Aircraft;
use App\Models\Airport;
use App\Models\Answer;
use App\Models\Course;
use App\Models\Event;
use App\Models\EventParticipation;
use App\Models\EventRole;
use App\Models\EventTemplate;
use App\Models\EventUser;
use App\Models\Room;
use App\Models\StartedTask;
use App\Models\Task;
use App\Models\TemplateItem;
use App\Models\TestRating;
use App\Models\User;
use Database\Factories\CourseFactory;
use Illuminate\Database\Console\Seeds\WithoutModelEvents;
use Illuminate\Database\Seeder;
use Spatie\Permission\Models\Role;

class EventsSeeder extends Seeder
{
    /**
     * Run the database seeds.
     *
     * @return void
     */
    public function run()
    {

        $courses = Course::all();

        $instructor = Role::firstOrCreate([
            'name' => 'Instructor',
            'guard_name' => '*'
        ]);

        $student = Role::firstOrCreate([
            'name' => 'Student',
            'guard_name' => '*'
        ]);

        $users = User::all();

        $instructors = $users->filter(fn ($u) => $u->hasRole($instructor));
        $students = $users->filter(fn ($u) => $u->hasRole($student));

        Event::where('starts_at', '>', now()->startOfDay())->delete();

        $this->makeEvents($students, $instructors);

        foreach ($students as $key => $student) {

            foreach ($student->events as $key => $event) {
                $test = $event->task->test;
                if ($test) {
                    // $this->command->info('creating answers for '.$test->id);
                    foreach ($test->questions as $key => $question) {
                        Answer::factory()
                            ->state(fn (array $attributes) => [
                                'question_id' => $question->id,
                                'question_option_id' => $question->questionOptions()->inRandomOrder()->first() ?? NULL,
                                'is_correct' => false, // $option->is_correct,
                                'text' => $question->type == 'OPEN' ? fake()->paragraph() : NULL
                            ])
                            ->recycle([$student])
                            ->create();

                        if (fake()->boolean(75)) {
                            TestRating::factory()
                                ->recycle([$test, $student])
                                ->create();
                        }
                        //         ->recycle($students),
                    }
                }

                // $this->command->info('starting task for '.$event->task->id);

                StartedTask::updateOrCreate(
                    [
                        'event_id' => $event->id,
                        'user_id' => $student->id,
                    ],
                    [
                        'task_id' => $event->task->id,
                        'questions_order' => $test ? ($test?->random_order
                            ? $test->questions()->inRandomOrder()->pluck('id')
                            : $test->questions()->pluck('id')
                        )
                            : NULL

                    ]
                );
            }
        }





        $event_templates = EventTemplate::all();
        $items = [];

        function getAllowed($type)
        {
            switch ($type) {
                case Course::class:
                    return [/* Course::class, */User::class, Task::class, Airport::class, Aircraft::class, Room::class];
                    break;
                case User::class:
                    return [/* Course::class, User::class,*/Task::class, Airport::class, Aircraft::class, Room::class];
                    break;
                case Task::class:
                    return [/* Course::class, */User::class, /* Task::class, */ Airport::class, Aircraft::class, Room::class];
                    break;
                case Airport::class:
                    return [/* Course::class, */User::class, Task::class, /* Airport::class, */ Aircraft::class /*, Room::class */];
                    break;
                case Aircraft::class:
                    return [/* Course::class, */User::class, Task::class, /* Airport::class, */ /* Aircraft::class, */ /* Room::class */];
                    break;
                case Room::class:
                    return [/* Course::class, */User::class, Task::class, /* Airport::class, */ /* Aircraft::class, */ /* Room::class */];
                    break;
                default:
                    return [Task::class];
                    break;
            }
        }

        foreach ($event_templates as $key => $et) {

            $et->items->each->delete();

            $items = TemplateItem::factory(10)
                ->hasAttached(
                    TemplateItem::factory(3)
                        ->state(
                            fn (array $attributes, TemplateItem $template_item) =>
                            [
                                'source_type' => collect(getAllowed($template_item->source_type))->random()
                            ]
                        )
                        ->hasAttached(
                            TemplateItem::factory(2)
                                ->state(
                                    fn (array $attributes, TemplateItem $template_item) =>
                                    [
                                        'source_type' => collect(getAllowed($template_item->source_type))->random()
                                    ]
                                ),
                            ['direct' => true],
                            'children'
                        ),
                    ['direct' => true],
                    'children'
                )
                ->recycle($et)
                ->create();
        }

        foreach (TemplateItem::latest()->get() as $key => $tl) {
            if ($tl?->parent?->id) {
                $parent_id = $tl->parent->id;
                $tl->parents()->sync([]);
                $tl->parents()->sync([$parent_id => ['direct' => true]]);
            }
        }
    }



    public function makeEvents($students, $instructors)
    {

        $studentRole =  EventRole::firstOrCreate(['name' => 'Student']);

        $instructorRole =  EventRole::firstOrCreate(['name' => 'Instructor']);

        $courses = Course::all();

        $last = now()->startOfDay();
        $rooms = Room::count() > 0
            ? Room::all()
            : Room::factory(10)->create();

        // foreach ($courses as $key => $course) {
        //     $last = $last->addMinutes(rand(5, 15));
        //     $s = $last->copy();
        //     $last = $last->addMinutes(rand(10, 90));
        //     $e = $last->copy();

        //     Event::factory()
        //         ->state([
        //             'type' => 'COURSE',
        //             'starts_at' => $s,
        //             'ends_at' => $e,
        //         ])
        //         ->hasAttached($course)
        //         ->has(
        //             EventUser::factory(5)
        //                 ->recycle($studentRole)
        //                 ->recycle($students)
        //         )
        //         ->has(
        //             EventUser::factory()
        //                 ->recycle($instructorRole)
        //                 ->recycle($instructors)
        //         )
        //         ->recycle($rooms)
        //         ->create();
        // }

        $tasks = Task::all();
        $airports = Airport::all();

        foreach ($tasks as $key => $task) {

            $last = $last->addMinutes(rand(5, 15));
            $s = $last->copy();
            $last = $last->addMinutes(rand(10, 90));
            $e = $last->copy();

            $f = Event::factory()
                ->state([
                    'type' => 'TASK',
                    'starts_at' => $s->format('Y-m-d H:i:s'),
                    'ends_at' => $e->format('Y-m-d H:i:s'),
                    'test_starts_at' => $task->test ? $s->copy()->addMinutes(10)->format('Y-m-d H:i:s') : NULL,
                    'locked' => $task?->test?->locked ? true : false,
                    'participation_code' => $task->confirm_participation ? fake()->bothify('######') : NULL
                ])
                ->hasAttached($task)
                ->has(
                    EventUser::factory(in_array($task->type, ['EXPORT_FLIGHT', 'CHECK_FLIGHT', 'SOLO_FLIGHT']) ? 1 : 5)
                        ->recycle($studentRole)
                        ->recycle($students)
                )
                ->has(
                    EventUser::factory()
                        ->recycle($instructorRole)
                        ->recycle($instructors)
                );


            if (in_array($task->type, ['LECTURE', 'THEORY', 'FLIGHT_SIM', 'CHECK_FLIGHT_SIM'])) {
                $f = $f->hasAttached(
                    $rooms->random()
                );
            }

            if (in_array($task->type, ['EXPORT_FLIGHT', 'CHECK_FLIGHT', 'SOLO_FLIGHT'])) {
                $airport = $airports->shuffle()->first();

                $f = $f->hasAttached(
                    $airport
                )
                    ->hasAttached(
                        $airport->aircraft->shuffle()->first()
                    );
            }

            $ev = $f->create();

            if ($task->confirm_participation)
                foreach ($ev->eventUsers ?? [] as $key => $user) {
                    EventParticipation::factory()
                        ->recycle([$user->user, $ev])
                        ->create();
                }
        }
    }
}
Youez - 2016 - github.com/yon3zu
LinuXploit