Source code aplikasi, template web, dan ebook. Unduh dari akun setelah bayar. Lihat produk

Blog / Studi Kasus / Membangun Sistem Pre-Order Lar...
Studi Kasus

Membangun Sistem Pre-Order Laravel: Alur Produk, DP, Pelunasan, Produksi, dan Pengiriman

AD

Admin HijrahKreativa

Penulis

19 Oct 2026
16 min read
23 views

Merancang sistem pre-order yang rapi: skema database, state machine status pesanan, kuota anti-oversell, pembayaran DP dan pelunasan, pengingat otomatis, sampai pengiriman.

Pendahuluan

Pre-order (PO) adalah model penjualan di mana pelanggan memesan dan membayar sebelum barang diproduksi atau tersedia. Pola ini umum untuk produk custom, fashion musiman, makanan, atau barang impor. Keuntungannya jelas: arus kas lebih sehat dan risiko stok mati berkurang.

Namun sistemnya lebih rumit daripada e-commerce biasa karena pesanan melewati banyak tahap dan dua kali pembayaran:

Buka PO ► Pesan ► Bayar DP ► Produksi ► Tagih Pelunasan ► Lunas ► Kirim ► Selesai

Tanpa rancangan yang baik, yang sering terjadi: status pesanan kacau, stok terjual melebihi kuota, pelanggan lupa melunasi, atau pembayaran tercatat ganda. Artikel ini membahas rancangan yang bisa dijadikan fondasi.

1. Memahami Alur Bisnis

Sebelum menulis kode, sepakati dulu aturan bisnisnya.

Tahap Pemicu Hasil
Periode PO Admin membuka PO dengan tanggal buka, tutup, dan kuota Produk bisa dipesan
Pemesanan Pelanggan checkout Pesanan dibuat, kuota dikunci, tagihan DP terbit
Bayar DP Pelanggan membayar (batas waktu) Pesanan dikonfirmasi; bila lewat batas, pesanan dibatalkan dan kuota dikembalikan
Produksi Setelah PO ditutup atau sesuai jadwal Admin menandai mulai dan selesai produksi
Pelunasan Produksi selesai Tagihan sisa terbit, pengingat dikirim otomatis
Pengiriman Pesanan lunas Admin mengisi nomor resi, pelanggan mendapat notifikasi
Selesai Barang diterima Pesanan ditutup

Keputusan bisnis yang perlu dijawab sejak awal (dan memengaruhi desain):

  • Berapa persen DP, tetap per produk atau bisa berbeda?
  • Apakah DP bisa dikembalikan jika PO dibatalkan oleh penjual? Bagaimana jika pembeli yang membatalkan?
  • Berapa lama batas waktu bayar DP dan pelunasan?
  • Apa yang terjadi bila pelanggan tidak melunasi?
  • Apakah ongkir dihitung di awal atau saat pelunasan?

2. Rancangan Database

Aturan dasar untuk uang: simpan dalam bilangan bulat (rupiah, tanpa desimal), bukan float, agar tidak ada kesalahan pembulatan.

php artisan make:model PreorderBatch -m
php artisan make:model Preorder -m
php artisan make:model Payment -m
php artisan make:model PreorderStatusLog -m
// Periode PO untuk sebuah produk
Schema::create('preorder_batches', function (Blueprint $table) {
    $table->id();
    $table->foreignId('product_id')->constrained()->cascadeOnDelete();
    $table->string('name');                                   // "PO Batch 1 - Lebaran"
    $table->unsignedBigInteger('price');                      // harga per unit (rupiah)
    $table->unsignedTinyInteger('dp_percent')->default(50);   // persen DP
    $table->unsignedInteger('quota');
    $table->unsignedInteger('sold')->default(0);
    $table->timestamp('opens_at');
    $table->timestamp('closes_at');
    $table->date('estimated_ready_at')->nullable();           // estimasi selesai produksi
    $table->unsignedSmallInteger('dp_deadline_hours')->default(24);
    $table->unsignedSmallInteger('balance_deadline_days')->default(7);
    $table->string('status')->default('draft');               // draft, open, closed, producing, done, cancelled
    $table->timestamps();

    $table->index(['status', 'opens_at', 'closes_at']);
});
// Pesanan pre-order
Schema::create('preorders', function (Blueprint $table) {
    $table->id();
    $table->string('number')->unique();                       // PO-20261019-0001
    $table->foreignId('user_id')->constrained();
    $table->foreignId('preorder_batch_id')->constrained();
    $table->unsignedInteger('quantity');
    $table->unsignedBigInteger('subtotal');
    $table->unsignedBigInteger('shipping_cost')->default(0);
    $table->unsignedBigInteger('total');
    $table->unsignedBigInteger('dp_amount');
    $table->unsignedBigInteger('balance_amount');
    $table->string('status')->default('awaiting_dp');
    $table->timestamp('dp_due_at')->nullable();
    $table->timestamp('balance_due_at')->nullable();
    $table->string('shipping_courier')->nullable();
    $table->string('tracking_number')->nullable();
    $table->json('shipping_address');
    $table->timestamps();

    $table->index(['status', 'dp_due_at']);
    $table->index(['status', 'balance_due_at']);
});
// Pembayaran (DP dan pelunasan dipisah sebagai baris berbeda)
Schema::create('payments', function (Blueprint $table) {
    $table->id();
    $table->foreignId('preorder_id')->constrained()->cascadeOnDelete();
    $table->string('type');                                   // dp | balance
    $table->unsignedBigInteger('amount');
    $table->string('status')->default('pending');             // pending, paid, expired, failed
    $table->string('reference')->nullable()->unique();        // ID transaksi dari payment gateway
    $table->timestamp('paid_at')->nullable();
    $table->timestamps();
});

// Riwayat perubahan status (audit)
Schema::create('preorder_status_logs', function (Blueprint $table) {
    $table->id();
    $table->foreignId('preorder_id')->constrained()->cascadeOnDelete();
    $table->string('from_status')->nullable();
    $table->string('to_status');
    $table->foreignId('changed_by')->nullable()->constrained('users')->nullOnDelete();
    $table->string('note')->nullable();
    $table->timestamps();
});

Kolom reference yang unique penting untuk mencegah satu notifikasi pembayaran diproses dua kali (lihat bagian webhook).

3. Status sebagai Enum dan Aturan Transisi

Status yang disimpan sebagai string bebas mudah rusak ("lunas" vs "Lunas" vs "paid"). Gunakan enum PHP, dan definisikan transisi mana yang sah.

// app/Enums/PreorderStatus.php
namespace App\Enums;

enum PreorderStatus: string
{
    case AwaitingDp     = 'awaiting_dp';        // menunggu pembayaran DP
    case DpPaid         = 'dp_paid';            // DP lunas, menunggu produksi
    case InProduction   = 'in_production';
    case AwaitingBalance= 'awaiting_balance';   // produksi selesai, tagihan pelunasan terbit
    case FullyPaid      = 'fully_paid';
    case Shipped        = 'shipped';
    case Completed      = 'completed';
    case Cancelled      = 'cancelled';

    public function label(): string
    {
        return match ($this) {
            self::AwaitingDp      => 'Menunggu DP',
            self::DpPaid          => 'DP Dibayar',
            self::InProduction    => 'Dalam Produksi',
            self::AwaitingBalance => 'Menunggu Pelunasan',
            self::FullyPaid       => 'Lunas',
            self::Shipped         => 'Dikirim',
            self::Completed       => 'Selesai',
            self::Cancelled       => 'Dibatalkan',
        };
    }

    /** @return list<self> */
    public function allowedNext(): array
    {
        return match ($this) {
            self::AwaitingDp      => [self::DpPaid, self::Cancelled],
            self::DpPaid          => [self::InProduction, self::Cancelled],
            self::InProduction    => [self::AwaitingBalance, self::Cancelled],
            self::AwaitingBalance => [self::FullyPaid, self::Cancelled],
            self::FullyPaid       => [self::Shipped],
            self::Shipped         => [self::Completed],
            self::Completed, self::Cancelled => [],
        };
    }

    public function canTransitionTo(self $next): bool
    {
        return in_array($next, $this->allowedNext(), true);
    }
}
// app/Models/Preorder.php
protected function casts(): array
{
    return [
        'status'         => PreorderStatus::class,
        'shipping_address' => 'array',
        'dp_due_at'      => 'datetime',
        'balance_due_at' => 'datetime',
    ];
}

Diagram alurnya:

              ┌────────────┐   bayar DP    ┌─────────┐   mulai    ┌──────────────┐
  checkout ─► │ awaiting_dp│ ────────────► │ dp_paid │ ─────────► │in_production │
              └─────┬──────┘               └────┬────┘            └──────┬───────┘
                    │ lewat batas / batal       │ batal                  │ selesai
                    ▼                           ▼                        ▼
              ┌───────────┐                                      ┌────────────────┐
              │ cancelled │ ◄──────────────────────────────────  │awaiting_balance│
              └───────────┘            batal / lewat batas       └───────┬────────┘
                                                                         │ bayar sisa
                       ┌───────────┐   resi    ┌─────────┐  diterima     ▼
                       │ completed │ ◄──────── │ shipped │ ◄──────── ┌──────────┐
                       └───────────┘           └─────────┘   kirim   │fully_paid│
                                                                     └──────────┘

4. Service Perubahan Status (Satu Pintu)

Jangan mengubah status langsung dari banyak tempat ($po->status = ...). Pusatkan di satu service yang memvalidasi transisi, mencatat log, dan menjalankan efek samping (notifikasi, pengembalian kuota).

// app/Services/PreorderStateService.php
namespace App\Services;

use App\Enums\PreorderStatus;
use App\Models\{Preorder, PreorderStatusLog};
use Illuminate\Support\Facades\DB;
use InvalidArgumentException;

class PreorderStateService
{
    public function transition(Preorder $preorder, PreorderStatus $to, ?int $userId = null, ?string $note = null): Preorder
    {
        return DB::transaction(function () use ($preorder, $to, $userId, $note) {
            // kunci baris agar dua proses tidak mengubah status bersamaan
            $po = Preorder::whereKey($preorder->id)->lockForUpdate()->firstOrFail();

            if (! $po->status->canTransitionTo($to)) {
                throw new InvalidArgumentException(
                    "Transisi {$po->status->value} -> {$to->value} tidak diizinkan."
                );
            }

            $from = $po->status;
            $po->update(['status' => $to]);

            PreorderStatusLog::create([
                'preorder_id' => $po->id,
                'from_status' => $from->value,
                'to_status'   => $to->value,
                'changed_by'  => $userId,
                'note'        => $note,
            ]);

            // efek samping tertentu
            if ($to === PreorderStatus::Cancelled) {
                $po->batch()->decrement('sold', $po->quantity);   // kembalikan kuota
            }

            return $po;
        });
    }
}

Efek samping yang butuh waktu, seperti email dan WhatsApp, jangan dikerjakan di sini secara langsung. Kirim sebagai job dengan afterCommit() (lihat artikel Laravel Queue).

5. Checkout: Kuota Tanpa Oversell

Masalah klasik: kuota 100, tersisa 1, dan dua pelanggan checkout bersamaan. Tanpa penguncian, keduanya berhasil dan kuota terlampaui. Solusinya adalah transaksi dengan lockForUpdate.

// app/Services/PreorderCheckoutService.php
namespace App\Services;

use App\Enums\PreorderStatus;
use App\Models\{Payment, Preorder, PreorderBatch, User};
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\ValidationException;

class PreorderCheckoutService
{
    public function checkout(User $user, int $batchId, int $qty, array $address, int $shipping = 0): Preorder
    {
        return DB::transaction(function () use ($user, $batchId, $qty, $address, $shipping) {

            $batch = PreorderBatch::whereKey($batchId)->lockForUpdate()->firstOrFail();

            if ($batch->status !== 'open' || now()->lt($batch->opens_at) || now()->gt($batch->closes_at)) {
                throw ValidationException::withMessages(['batch' => 'Periode pre-order tidak aktif.']);
            }

            if ($batch->sold + $qty > $batch->quota) {
                throw ValidationException::withMessages([
                    'qty' => 'Kuota tidak mencukupi. Sisa: '.($batch->quota - $batch->sold),
                ]);
            }

            $subtotal = $batch->price * $qty;
            $total    = $subtotal + $shipping;
            $dp       = (int) ceil($subtotal * $batch->dp_percent / 100);   // DP dari subtotal
            $balance  = $total - $dp;

            $batch->increment('sold', $qty);

            $po = Preorder::create([
                'number'            => $this->makeNumber(),
                'user_id'           => $user->id,
                'preorder_batch_id' => $batch->id,
                'quantity'          => $qty,
                'subtotal'          => $subtotal,
                'shipping_cost'     => $shipping,
                'total'             => $total,
                'dp_amount'         => $dp,
                'balance_amount'    => $balance,
                'status'            => PreorderStatus::AwaitingDp,
                'dp_due_at'         => now()->addHours($batch->dp_deadline_hours),
                'shipping_address'  => $address,
            ]);

            Payment::create([
                'preorder_id' => $po->id,
                'type'        => 'dp',
                'amount'      => $dp,
            ]);

            return $po;
        });
    }

    private function makeNumber(): string
    {
        return 'PO-'.now()->format('Ymd').'-'.str_pad((string) random_int(1, 9999), 4, '0', STR_PAD_LEFT);
    }
}

Hal yang perlu diperhatikan:

  • Harga diambil dari database ($batch->price), bukan dari input form, agar tidak bisa dimanipulasi.
  • dp + balance = total selalu. ceil pada DP memastikan tidak ada selisih pembulatan.
  • Nomor acak bisa bertabrakan. Karena kolom number bersifat unique, tangani UniqueConstraintViolationException dengan mencoba ulang, atau gunakan urutan harian dari tabel counter.
  • lockForUpdate hanya berlaku di dalam transaksi dan di database yang mendukungnya (MySQL InnoDB mendukung).

6. Pembayaran: DP, Lalu Pelunasan

Integrasi dengan payment gateway (Midtrans, Xendit, dan sejenisnya) mengikuti pola yang sama: Anda membuat tagihan, pelanggan membayar di sisi gateway, dan gateway memberi tahu aplikasi lewat webhook.

Menerima webhook dengan aman dan idempotent

Webhook bisa terkirim lebih dari sekali. Penanganannya harus aman diulang.

// app/Http/Controllers/PaymentWebhookController.php
public function handle(Request $request, PreorderStateService $state)
{
    // 1) verifikasi signature sesuai dokumentasi gateway (contoh generik HMAC)
    $signature = hash_hmac('sha256', $request->getContent(), config('services.gateway.secret'));
    abort_unless(hash_equals($signature, (string) $request->header('X-Signature')), 403);

    $reference = $request->input('reference');
    $status    = $request->input('status');            // 'paid' | 'expired' | 'failed'

    DB::transaction(function () use ($reference, $status, $state) {
        $payment = Payment::where('reference', $reference)->lockForUpdate()->firstOrFail();

        // 2) idempotensi: sudah diproses, abaikan
        if ($payment->status === 'paid') {
            return;
        }

        if ($status !== 'paid') {
            $payment->update(['status' => $status]);
            return;
        }

        $payment->update(['status' => 'paid', 'paid_at' => now()]);

        $po = $payment->preorder;

        if ($payment->type === 'dp') {
            $state->transition($po, PreorderStatus::DpPaid, note: 'DP dibayar');
        } else {
            $state->transition($po, PreorderStatus::FullyPaid, note: 'Pelunasan dibayar');
        }
    });

    return response()->json(['ok' => true]);
}

Beberapa aturan penting untuk pembayaran:

  • Selalu verifikasi signature webhook dan cocokkan jumlah yang dibayar dengan amount di database.
  • Jangan percaya status "sukses" dari redirect browser. Sumber kebenaran hanya webhook atau pengecekan status langsung ke API gateway.
  • Kecualikan route webhook dari CSRF ($middleware->validateCsrfTokens(except: ['webhook/*'])) dan jangan pasang middleware auth di sana.
  • Batasi dan catat semua request webhook untuk keperluan audit.

Menerbitkan tagihan pelunasan

Dilakukan saat admin menandai produksi selesai.

// app/Services/PreorderProductionService.php
public function markReady(PreorderBatch $batch, PreorderStateService $state): void
{
    $batch->preorders()
        ->where('status', PreorderStatus::InProduction)
        ->each(function (Preorder $po) use ($state, $batch) {
            $state->transition($po, PreorderStatus::AwaitingBalance, note: 'Produksi selesai');

            $po->update(['balance_due_at' => now()->addDays($batch->balance_deadline_days)]);

            Payment::create([
                'preorder_id' => $po->id,
                'type'        => 'balance',
                'amount'      => $po->balance_amount,
            ]);

            NotifikasiPelunasan::dispatch($po)->afterCommit();
        });
}

Untuk jumlah pesanan yang besar, ganti each dengan chunkById atau jadikan satu job per pesanan agar tidak melewati batas waktu eksekusi.

7. Otomatisasi dengan Scheduler

Dua pekerjaan berulang yang wajib otomatis: membatalkan DP yang kedaluwarsa dan mengingatkan pelunasan.

php artisan make:command Preorder/ExpireUnpaid
php artisan make:command Preorder/RemindBalance
// app/Console/Commands/Preorder/ExpireUnpaid.php
protected $signature = 'preorder:expire-unpaid';

public function handle(PreorderStateService $state): int
{
    Preorder::where('status', PreorderStatus::AwaitingDp)
        ->where('dp_due_at', '<', now())
        ->each(function (Preorder $po) use ($state) {
            $po->payments()->where('status', 'pending')->update(['status' => 'expired']);
            $state->transition($po, PreorderStatus::Cancelled, note: 'DP melewati batas waktu');
        });

    return self::SUCCESS;
}
// app/Console/Commands/Preorder/RemindBalance.php
protected $signature = 'preorder:remind-balance';

public function handle(): int
{
    // ingatkan 3 hari dan 1 hari sebelum jatuh tempo
    foreach ([3, 1] as $days) {
        Preorder::where('status', PreorderStatus::AwaitingBalance)
            ->whereDate('balance_due_at', now()->addDays($days)->toDateString())
            ->each(fn ($po) => IngatkanPelunasan::dispatch($po, $days));
    }

    return self::SUCCESS;
}
// routes/console.php
use Illuminate\Support\Facades\Schedule;

Schedule::command('preorder:expire-unpaid')->everyTenMinutes()->onOneServer()->withoutOverlapping();
Schedule::command('preorder:remind-balance')->dailyAt('09:00')->onOneServer();

Cek hasilnya:

php artisan schedule:list
php artisan preorder:expire-unpaid
  */10 * * * *  php artisan preorder:expire-unpaid ........ Next Due: 8 minutes from now
  0    9 * * *  php artisan preorder:remind-balance ....... Next Due: 14 hours from now

Tentukan kebijakan untuk pesanan yang tidak dilunasi sampai lewat batas. Pilihan umum: pesanan dibatalkan dan DP hangus, DP dikembalikan sebagian, atau tenggang waktu tambahan. Apa pun pilihannya, tulis jelas di syarat dan ketentuan yang disetujui pelanggan saat checkout.

8. Produksi dan Pengiriman di Panel Admin

Admin membutuhkan tampilan yang menjawab pertanyaan operasional:

  • Berapa pesanan per batch, dan berapa yang sudah DP atau lunas?
  • Berapa unit yang harus diproduksi? (dihitung dari pesanan dengan DP lunas)
  • Pesanan mana yang siap dikirim (lunas tetapi belum ada resi)?
// ringkasan produksi per batch
$ringkasan = Preorder::query()
    ->where('preorder_batch_id', $batch->id)
    ->whereIn('status', [PreorderStatus::DpPaid, PreorderStatus::InProduction, PreorderStatus::AwaitingBalance, PreorderStatus::FullyPaid])
    ->selectRaw('status, COUNT(*) as pesanan, SUM(quantity) as unit')
    ->groupBy('status')
    ->get();
status            pesanan   unit
dp_paid                64    118
in_production          20     35
awaiting_balance       12     19
fully_paid              8     11

Menandai pengiriman

// app/Http/Controllers/Admin/PreorderShipmentController.php
public function store(Request $request, Preorder $preorder, PreorderStateService $state)
{
    $this->authorize('ship', $preorder);

    $data = $request->validate([
        'courier'         => ['required', 'string', 'max:50'],
        'tracking_number' => ['required', 'string', 'max:100'],
    ]);

    $preorder->update([
        'shipping_courier' => $data['courier'],
        'tracking_number'  => $data['tracking_number'],
    ]);

    $state->transition($preorder, PreorderStatus::Shipped, $request->user()->id, 'Resi diinput');

    KirimNotifikasiResi::dispatch($preorder)->afterCommit();

    return back()->with('success', 'Resi tersimpan dan pelanggan diberi tahu.');
}

Untuk pengiriman massal, sediakan fitur impor CSV (kolom: nomor PO dan nomor resi) yang diproses sebagai job. Ini menghemat banyak waktu saat ratusan paket dikirim sekaligus.

9. Halaman Pelanggan

Pelanggan perlu melihat di mana posisi pesanannya dan apa yang harus dilakukan berikutnya. Linimasa status membantu.

{{-- resources/views/preorders/show.blade.php (ringkas) --}}
<h1>{{ $preorder->number }}</h1>
<p>Status: <strong>{{ $preorder->status->label() }}</strong></p>

@php
    $steps = [
        'awaiting_dp'      => 'Bayar DP',
        'in_production'    => 'Produksi',
        'awaiting_balance' => 'Pelunasan',
        'shipped'          => 'Dikirim',
        'completed'        => 'Selesai',
    ];
@endphp

<ol class="timeline">
    @foreach ($steps as $key => $label)
        <li @class(['active' => $preorder->status->value === $key])>{{ $label }}</li>
    @endforeach
</ol>

@if ($preorder->status === \App\Enums\PreorderStatus::AwaitingDp)
    <p>Bayar DP <strong>Rp {{ number_format($preorder->dp_amount, 0, ',', '.') }}</strong>
       sebelum {{ $preorder->dp_due_at->translatedFormat('d F Y H:i') }}.</p>
@elseif ($preorder->status === \App\Enums\PreorderStatus::AwaitingBalance)
    <p>Pelunasan <strong>Rp {{ number_format($preorder->balance_amount, 0, ',', '.') }}</strong>
       sebelum {{ $preorder->balance_due_at->translatedFormat('d F Y') }}.</p>
@endif

Tampilkan juga estimasi selesai produksi (estimated_ready_at) dan tegaskan bahwa itu estimasi, bukan janji pasti. Komunikasi yang jujur soal keterlambatan mengurangi komplain.

10. Keamanan dan Integritas Data

  • Otorisasi: pelanggan hanya boleh melihat pesanannya sendiri (Policy view), dan hanya admin yang bisa mengubah status produksi dan pengiriman. Ini mencegah IDOR.
  • Harga dari server: jangan pernah menerima harga, DP, atau total dari klien.
  • Transaksi dan penguncian: semua operasi yang menyentuh kuota atau status dibungkus DB::transaction dengan lockForUpdate.
  • Idempotensi webhook: reference unik dan pengecekan status paid sebelum memproses.
  • Rate limiting pada checkout agar tidak diserbu bot saat PO dibuka:
Route::post('/preorder/checkout', [PreorderController::class, 'store'])
    ->middleware(['auth', 'throttle:10,1']);
  • Audit: tabel preorder_status_logs mencatat siapa mengubah apa dan kapan. Sangat berguna saat ada sengketa.
  • Beban saat PO dibuka: lonjakan trafik terjadi di menit pertama. Siapkan cache untuk halaman produk, queue untuk notifikasi, dan pastikan kuota hanya diperiksa lewat transaksi.

11. Pengujian

Uji dua hal paling berisiko: kuota dan transisi status.

public function test_kuota_tidak_bisa_terlampaui(): void
{
    $batch = PreorderBatch::factory()->open()->create(['quota' => 5, 'sold' => 4, 'price' => 100000]);
    $user  = User::factory()->create();

    $service = app(PreorderCheckoutService::class);

    $service->checkout($user, $batch->id, 1, ['kota' => 'Depok']);

    $this->expectException(ValidationException::class);
    $service->checkout($user, $batch->id, 1, ['kota' => 'Depok']);   // kuota habis
}

public function test_dp_dan_pelunasan_selalu_sama_dengan_total(): void
{
    $batch = PreorderBatch::factory()->open()->create(['price' => 123457, 'dp_percent' => 30, 'quota' => 10]);

    $po = app(PreorderCheckoutService::class)
        ->checkout(User::factory()->create(), $batch->id, 3, ['kota' => 'Depok'], 20000);

    $this->assertSame($po->total, $po->dp_amount + $po->balance_amount);
}

public function test_transisi_tidak_sah_ditolak(): void
{
    $po = Preorder::factory()->create(['status' => PreorderStatus::AwaitingDp]);

    $this->expectException(\InvalidArgumentException::class);
    app(PreorderStateService::class)->transition($po, PreorderStatus::Shipped);
}

public function test_webhook_ganda_tidak_memproses_dua_kali(): void
{
    // kirim payload yang sama dua kali, pastikan status dan log hanya berubah sekali
}

Checklist Implementasi

  • ☐ Aturan bisnis (persen DP, batas waktu, kebijakan pembatalan) disepakati dan tertulis.
  • ☐ Uang disimpan sebagai integer, dan dp + sisa = total selalu terjaga.
  • ☐ Status memakai enum dengan aturan transisi di satu service.
  • ☐ Checkout memakai transaksi dan lockForUpdate untuk kuota.
  • ☐ Webhook diverifikasi signature-nya, idempotent, dan jumlahnya dicocokkan.
  • ☐ Scheduler membatalkan DP kedaluwarsa dan mengirim pengingat pelunasan.
  • ☐ Notifikasi dikirim lewat queue dengan afterCommit().
  • ☐ Setiap perubahan status tercatat di log audit.
  • ☐ Policy membatasi akses pelanggan dan admin.
  • ☐ Ada test untuk kuota, transisi status, dan webhook ganda.
  • ☐ Syarat dan ketentuan (DP, pelunasan, pembatalan) tampil jelas saat checkout.

Penutup

Sistem pre-order pada dasarnya adalah state machine dengan dua kali pembayaran. Jika statusnya terdefinisi tegas, kuota dilindungi transaksi, pembayaran idempotent, dan tugas rutin diserahkan ke scheduler dan queue, maka alur yang tampak rumit menjadi dapat diprediksi dan mudah dilacak. Mulailah dari satu batch sederhana, uji dengan data nyata, lalu kembangkan fitur seperti refund, multi-produk dalam satu pesanan, atau integrasi ongkir otomatis.

Bagikan artikel:

Artikel lainnya