Buat/Edit Acara Berulang – Panel Admin Cepat

Saat mengerjakan aplikasi kalender, dan menggunakan modul Kalender Sistem, kami mendapat beberapa pertanyaan dari pelanggan kami, bagaimana cara menanganinya peristiwa yang terjadi secara rutin – setiap hari, minggu atau bulan. Ada beberapa cara untuk melakukan pendekatan ini, dan artikel ini akan menunjukkan salah satunya.

---

Contoh dari Google Kalender

Secara umum, kami ingin mencapai sesuatu yang dapat dilakukan oleh Google Kalender – Anda menambahkan acara, menetapkan bahwa acara tersebut berulang, dan kemudian acara tersebut muncul di kalender Anda setiap kali diperlukan.

Itu bagian yang mudah. Sekarang, jika kita ingin mengedit beberapa acara di masa depan, kalender akan menanyakan apakah kita ingin mengubah semua acara lain di masa depan untuk pola ini.

---

Contoh dengan Laravel + FullCalendar

Jadi, kami telah membuat proyek serupa di Laravel (tautan repositori Github ada di akhir artikel), yang berfungsi seperti ini.

Bagian 1. Saat membuat acara, sistem menanyakan apakah acara tersebut berulang.

Jika peristiwa tersebut berulang, maka sistem secara otomatis menghasilkan X peristiwa di masa depan, satu tahun ke depan. Jika event harian, maka di DB Anda akan memiliki 365 event, untuk event mingguan akan ada 52 record, dan event bulanan akan membuat 12 entri di DB.

Semua acara rutin dibuat dengan bidang acara.event_id nilai acara “induk”.

Kemudian kalender berbasis FullCalendar kami menampilkan acara seperti ini:

Bagian 2. Saat mengedit salah satu acara rutin, sistem akan meminta multi-pembaruan.

Bagian 3. Sama halnya dengan menghapus acara yang berulang, sistem akan memunculkan pertanyaan.

Ini hanya salah satu cara untuk menangani kejadian berulang, Anda dapat memilih untuk membuat SATU acara saja, dengan beberapa pengaturan tambahan, tapi menurut saya hal berulang otomatis ini lebih nyaman.

Selain itu, Anda juga dapat menulis skrip yang membuat lebih banyak peristiwa berulang di masa depan ketika tampilan satu tahun yang kami pilih mendekati akhir.

---

Cara kerjanya ada di kode

Beberapa hal yang perlu ditunjukkan kepada Anda di sini:

Migrasi tabel DB:

Schema::create('events', function (Blueprint $table) {
    $table->increments('id');
    $table->string('name');
    $table->datetime('start_time');
    $table->datetime('end_time');
    $table->string('recurrence'); // daily/weekly/monthly/none
    $table->unsignedInteger('event_id')->nullable(); // foreign key to itself
    $table->foreign('event_id')->references('id')->on('events');
    $table->timestamps();
    $table->softDeletes();
});

Lalu, masuk app/Event.php model kita memiliki hubungan dengan dirinya sendiri:

class Event extends Model
{

    public function events()
    {
        return $this->hasMany(Event::class, 'event_id', 'id');
    }

    public function event()
    {
        return $this->belongsTo(Event::class, 'event_id');
    }
}

Metode pengontrol di EventsController.php untuk menyimpan dan mengedit acara sangat sederhana:

public function store(StoreEventRequest $request)
{
    Event::create($request->all());
    return redirect()->route('admin.systemCalendar');
}

public function update(UpdateEventRequest $request, Event $event)
{
    $event->update($request->all());
    return redirect()->route('admin.systemCalendar');
}

Dan kemudian seluruh “keajaiban” ada di dalamnya Pengamat mengajukan app/Observer/RecurrenceObserver.phpini kode lengkapnya:

class RecurrenceObserver
{

    public static function created(Event $event)
    {
        if(!$event->event()->exists())
        {
            $recurrences = [
                'daily'     => [
                    'times'     => 365,
                    'function'  => 'addDay'
                ],
                'weekly'    => [
                    'times'     => 52,
                    'function'  => 'addWeek'
                ],
                'monthly'    => [
                    'times'     => 12,
                    'function'  => 'addMonth'
                ]
            ];
            $startTime = Carbon::parse($event->start_time);
            $endTime = Carbon::parse($event->end_time);
            $recurrence = $recurrences[$event->recurrence] ?? null;

            if($recurrence)
                for($i = 0; $i < $recurrence['times']; $i++)
                {
                    $startTime->{$recurrence['function']}();
                    $endTime->{$recurrence['function']}();
                    $event->events()->create([
                        'name'          => $event->name,
                        'start_time'    => $startTime,
                        'end_time'      => $endTime,
                        'recurrence'    => $event->recurrence,
                    ]);
                }
        }
    }

    public function updated(Event $event)
    {
        if ($event->events()->exists() || $event->event)
        {
            $startTime = Carbon::parse($event->getOriginal('start_time'))->diffInSeconds($event->start_time, false);
            $endTime = Carbon::parse($event->getOriginal('end_time'))->diffInSeconds($event->end_time, false);
            if($event->event)
                $childEvents = $event->event->events()->whereDate('start_time', '>', $event->getOriginal('start_time'))->get();
            else
                $childEvents = $event->events;

            foreach($childEvents as $childEvent)
            {
                if($startTime)
                    $childEvent->start_time = Carbon::parse($childEvent->start_time)->addSeconds($startTime);
                if($endTime)
                    $childEvent->end_time = Carbon::parse($childEvent->end_time)->addSeconds($endTime);
                if($event->isDirty('name') && $childEvent->name == $event->getOriginal('name'))
                    $childEvent->name = $event->name;
                $childEvent->saveQuietly();
            }
        }

        if($event->isDirty('recurrence') && $event->recurrence != 'none')
            self::created($event);
    }

    public function deleted(Event $event)
    {
        if($event->events()->exists())
            $events = $event->events()->pluck('id');
        else if($event->event)
            $events = $event->event->events()->whereDate('start_time', '>', $event->start_time)->pluck('id');
        else
            $events = [];
        
        Event::whereIn('id', $events)->delete();
    }
}

Kami mendaftarkan pengamat di app/Penyedia/AppServiceProvider.php:

class AppServiceProvider extends ServiceProvider
{
    public function boot()
    {
        Event::observe(RecurrenceObserver::class);
    }
}

Hal terakhir adalah fungsinya $childEvent->saveQuietly(); ditembakkan dari diperbarui() metode pengamat. Tujuannya adalah untuk memperbarui acara dan bukan pengamat kebakaran lagi. Jadi, di dalam app/Event.php kami punya ini:

public function saveQuietly()
{
    return static::withoutEvents(function () {
        return $this->save();
    });
}

Jadi, itu saja untuk demonya. Anda dapat menemukan repositori di Github dan bermain-main, atau menyesuaikan dengan kebutuhan Anda.

Anda dapat membaca lebih lanjut tentang Eloquent Observers di dokumentasi resmi Laravel di sini.

Terakhir, Anda dapat membaca tentang logika umum menyimpan acara berulang di sini di StackOverflow, karena ini bukan hanya masalah untuk Laravel atau FullCalendar pada khususnya.