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

Blog / Dashboard Admin, CRUD & Frontend / Membangun Laravel Admin Starte...
Dashboard Admin, CRUD & Frontend

Membangun Laravel Admin Starter: Authentication, Permission, CRUD, Activity Log, dan Settings

AD

Admin HijrahKreativa

Penulis

19 Oct 2026
24 min read
14 views

Menyatukan seluruh seri menjadi satu fondasi panel admin yang siap dipakai ulang: autentikasi dengan Fortify dan 2FA, peran dan izin, layout berbasis komponen dengan menu dinamis, generator CRUD dengan stub kustom, activity log yang bisa ditelusuri, halaman pengaturan, manajemen pengguna, notifikasi, dan test arsitektur.

Overview

Artikel-artikel sebelumnya membahas setiap bagian panel admin secara terpisah. Artikel ini merangkainya menjadi admin starter: proyek dasar yang bisa disalin untuk aplikasi RW, POS, booking, atau SaaS internal, sehingga hari pertama proyek baru langsung dipakai untuk fitur bisnis.

Bedanya dengan artikel Membangun Laravel Starter Kit yang Reusable (yang membahas cara mengemas dan mendistribusikan kit): artikel ini fokus pada isi panel admin dan cara modul-modulnya saling terhubung.

Modul Isi Artikel rujukan
Autentikasi Login, logout, reset password, 2FA, rate limit Login dan Logout Laravel
Otorisasi Role, permission, Policy, super admin Role dan Permission, RBAC
UI Layout, komponen Blade, menu dinamis, Tailwind Blade Components, Tailwind CSS 4
CRUD Generator dengan stub kustom (artikel ini)
Daftar data Filter, pencarian, sorting, pagination Filter, Search, Sorting, dan Pagination
Activity log Pencatatan perubahan dan halaman riwayat Soft Delete, Audit Trail, dan Activity Log
Pengaturan Nama aplikasi, logo, kontak, opsi bisnis (artikel ini)
Pengguna Undang, ubah peran, nonaktifkan (artikel ini)
Notifikasi Lonceng, email, real-time Sistem Notifikasi Laravel
Media Avatar dan logo Media Library

Hasil akhir: repository admin starter dengan struktur yang jelas, generator php artisan make:crud, dan test yang menjaga konsistensi seluruh modul.

Prerequisites

Komponen Versi
PHP 8.4
Laravel 13.x
Laravel Fortify 1.x
spatie/laravel-permission ^8.0
spatie/laravel-activitylog ^5.0
spatie/laravel-medialibrary ^11.0
Tailwind CSS 4.x, Alpine.js 3.x
Database MySQL 8.0+ / PostgreSQL 15+
Redis 7.x (cache, session, queue)
Testing Pest 4

Step-by-step Tutorial

Langkah 1: Struktur Proyek

app/
├── Admin/                          ← inti admin starter
│   ├── Console/MakeCrudCommand.php
│   ├── Http/Controllers/           ← Pengguna, Peran, Pengaturan, AktivitasController
│   ├── Settings/SettingsStore.php
│   ├── Menu/MenuBuilder.php
│   └── AdminServiceProvider.php
├── Enums/{Permission,Role}.php
├── Http/Controllers/Admin/         ← CRUD modul bisnis (hasil generator)
├── Models/
├── Policies/
└── Filters/
config/
├── admin.php                       ← menu, fitur, peran bawaan
stubs/crud/                         ← stub generator CRUD
resources/views/
├── components/                     ← layout, button, form, table, modal, ...
├── admin/                          ← halaman inti (pengguna, peran, pengaturan, aktivitas)
└── admin/<modul>/                  ← halaman modul bisnis (hasil generator)
tests/
├── Arch/
└── Feature/Admin/

Pemisahan app/Admin (inti, jarang diubah) dari modul bisnis memudahkan memperbarui starter tanpa bentrok dengan kode proyek.

Langkah 2: Autentikasi dengan Fortify

Fortify menyediakan backend autentikasi tanpa tampilan, sehingga Anda bebas memakai layout Blade sendiri.

composer require laravel/fortify
php artisan fortify:install
php artisan migrate
// config/fortify.php
'views' => true,
'features' => [
    Features::resetPasswords(),
    Features::updateProfileInformation(),
    Features::updatePasswords(),
    Features::twoFactorAuthentication(['confirm' => true, 'confirmPassword' => true]),
    // registrasi sengaja tidak diaktifkan: pengguna diundang oleh admin
],
// app/Providers/FortifyServiceProvider.php
public function boot(): void
{
    Fortify::loginView(fn () => view('auth.login'));
    Fortify::requestPasswordResetLinkView(fn () => view('auth.forgot-password'));
    Fortify::resetPasswordView(fn ($request) => view('auth.reset-password', ['request' => $request]));
    Fortify::twoFactorChallengeView(fn () => view('auth.two-factor-challenge'));
    Fortify::confirmPasswordView(fn () => view('auth.confirm-password'));

    // Tolak akun nonaktif dengan pesan umum
    Fortify::authenticateUsing(function (Request $request) {
        $user = User::where('email', Str::lower($request->email))->first();

        return $user && $user->is_active && Hash::check($request->password, $user->password) ? $user : null;
    });

    RateLimiter::for('login', fn (Request $request) => [
        Limit::perMinute(5)->by(Str::lower((string) $request->input('email')).'|'.$request->ip()),
        Limit::perMinute(20)->by($request->ip()),
    ]);

    RateLimiter::for('two-factor', fn (Request $request) => Limit::perMinute(5)->by($request->session()->get('login.id')));
}

Wajibkan 2FA untuk peran sensitif dengan middleware sederhana:

// app/Http/Middleware/RequireTwoFactor.php
public function handle(Request $request, Closure $next): Response
{
    $user = $request->user();

    if ($user?->hasAnyRole(config('admin.wajib_2fa')) && ! $user->hasEnabledTwoFactorAuthentication()) {
        return redirect()->route('profil.keamanan')
            ->with('status', 'Aktifkan autentikasi dua faktor untuk melanjutkan.');
    }

    return $next($request);
}

Tambahkan trait TwoFactorAuthenticatable dari Fortify ke model User.

Langkah 3: Peran, Izin, dan Grup Route Admin

Gunakan enum dan seeder dari artikel Cara Menerapkan Role dan Permission, dengan izin inti starter:

// app/Enums/Permission.php (inti)
enum Permission: string
{
    case PenggunaKelola  = 'pengguna.kelola';
    case PeranKelola     = 'peran.kelola';
    case PengaturanUbah  = 'pengaturan.ubah';
    case AktivitasLihat  = 'aktivitas.lihat';
    // izin modul bisnis ditambahkan oleh generator CRUD (Langkah 6)
}
// config/admin.php
return [
    'prefix'    => 'admin',
    'wajib_2fa' => ['super-admin', 'admin', 'bendahara'],

    'menu' => [
        ['label' => 'Dasbor',     'route' => 'admin.dashboard',        'icon' => 'home',     'can' => null],
        ['label' => 'Data Warga', 'route' => 'admin.warga.index',      'icon' => 'users',    'can' => 'warga.lihat'],
        ['label' => 'Kas',        'route' => 'admin.kas.index',        'icon' => 'wallet',   'can' => 'kas.lihat'],
        ['grup'  => 'Sistem', 'items' => [
            ['label' => 'Pengguna',   'route' => 'admin.pengguna.index',   'icon' => 'user-cog', 'can' => 'pengguna.kelola'],
            ['label' => 'Peran',      'route' => 'admin.peran.index',      'icon' => 'shield',   'can' => 'peran.kelola'],
            ['label' => 'Pengaturan', 'route' => 'admin.pengaturan.edit',  'icon' => 'settings', 'can' => 'pengaturan.ubah'],
            ['label' => 'Aktivitas',  'route' => 'admin.aktivitas.index',  'icon' => 'history',  'can' => 'aktivitas.lihat'],
        ]],
    ],
];
// routes/admin.php
use App\Admin\Http\Controllers\{AktivitasController, PengaturanController, PenggunaController, PeranController};

Route::get('/', \App\Http\Controllers\Admin\DashboardController::class)->name('dashboard');

Route::resource('pengguna', PenggunaController::class)->except('show')->middleware('can:pengguna.kelola');
Route::post('pengguna/{pengguna}/nonaktifkan', [PenggunaController::class, 'nonaktifkan'])
    ->middleware(['can:pengguna.kelola', 'password.confirm'])->name('pengguna.nonaktifkan');

Route::resource('peran', PeranController::class)->only(['index', 'edit', 'update'])->middleware('can:peran.kelola');

Route::get('pengaturan', [PengaturanController::class, 'edit'])->middleware('can:pengaturan.ubah')->name('pengaturan.edit');
Route::put('pengaturan', [PengaturanController::class, 'update'])->middleware('can:pengaturan.ubah')->name('pengaturan.update');

Route::get('aktivitas', [AktivitasController::class, 'index'])->middleware('can:aktivitas.lihat')->name('aktivitas.index');

// ── Modul bisnis (ditambahkan oleh make:crud) ──
// bootstrap/app.php
->withRouting(
    web: __DIR__.'/../routes/web.php',
    commands: __DIR__.'/../routes/console.php',
    health: '/up',
    then: function () {
        Route::middleware(['web', 'auth', 'auth.session', 'active', 'two-factor.required'])
            ->prefix(config('admin.prefix'))
            ->name('admin.')
            ->group(base_path('routes/admin.php'));
    },
)
->withMiddleware(function (Middleware $middleware) {
    $middleware->alias([
        'active'              => \App\Http\Middleware\EnsureUserIsActive::class,
        'two-factor.required' => \App\Http\Middleware\RequireTwoFactor::class,
    ]);
})

Semua route di routes/admin.php otomatis mendapat autentikasi, status akun aktif, dan kewajiban 2FA. Developer yang menambah route baru tidak perlu mengingat middleware ini.

Langkah 4: Menu Dinamis

// app/Admin/Menu/MenuBuilder.php
namespace App\Admin\Menu;

use App\Models\User;
use Illuminate\Support\Collection;

final class MenuBuilder
{
    public function untuk(?User $user): Collection
    {
        return collect(config('admin.menu'))
            ->map(function ($item) use ($user) {
                if (isset($item['grup'])) {
                    $items = collect($item['items'])->filter(fn ($i) => $this->boleh($i, $user))->values();
                    return $items->isEmpty() ? null : ['grup' => $item['grup'], 'items' => $items];
                }
                return $this->boleh($item, $user) ? $item : null;
            })
            ->filter()
            ->values();
    }

    private function boleh(array $item, ?User $user): bool
    {
        return $item['can'] === null || (bool) $user?->can($item['can']);
    }
}
// app/Admin/AdminServiceProvider.php
public function boot(): void
{
    View::composer('components.layouts.admin', fn ($view) =>
        $view->with('menu', app(MenuBuilder::class)->untuk(auth()->user())));
}

Grup menu yang semua itemnya tersembunyi tidak ditampilkan sama sekali, sehingga warga tidak melihat judul "Sistem" kosong.

Langkah 5: Layout Admin Berbasis Komponen

Layout <x-layouts.admin> memakai komponen dari artikel Membuat Reusable Blade Components, ditambah sidebar, lonceng notifikasi, dan menu pengguna:

{{-- resources/views/components/layouts/admin.blade.php --}}
@props(['title' => null])
<!doctype html>
<html lang="id" class="{{ request()->cookie('tema') === 'gelap' ? 'dark' : '' }}">
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta name="csrf-token" content="{{ csrf_token() }}">
    <title>{{ $title ? "{$title} · " : '' }}{{ setting('aplikasi.nama', config('app.name')) }}</title>
    @vite(['resources/css/app.css', 'resources/js/app.js'])
</head>
<body class="min-h-screen bg-slate-50 dark:bg-slate-950" x-data="{ sidebar: false }">
    <aside class="fixed inset-y-0 left-0 z-40 w-64 -translate-x-full border-r bg-white transition lg:translate-x-0 dark:bg-slate-900"
           :class="sidebar && 'translate-x-0'">
        <div class="flex h-16 items-center gap-2 px-5 font-display font-bold">
            <img src="{{ setting('aplikasi.logo_url', asset('images/logo.svg')) }}" alt="" class="size-8"> {{ setting('aplikasi.nama', config('app.name')) }}
        </div>
        <x-admin.menu :menu="$menu" />
    </aside>

    <div class="lg:pl-64">
        <header class="sticky top-0 z-30 flex h-16 items-center justify-between border-b bg-white/80 px-4 backdrop-blur dark:bg-slate-900/80">
            <button class="lg:hidden" x-on:click="sidebar = !sidebar" aria-label="Menu">☰</button>
            <h1 class="font-semibold">{{ $title }}</h1>
            <div class="flex items-center gap-2">
                <x-lonceng-notifikasi />
                <x-admin.menu-pengguna />
            </div>
        </header>

        <main class="p-4 sm:p-6">
            <x-flash />
            {{ $slot }}
        </main>
    </div>
    @stack('scripts')
</body>
</html>

Fungsi setting() berasal dari modul pengaturan (Langkah 8).

Langkah 6: Tetapkan Konvensi Modul CRUD

Sebelum membuat generator, tetapkan konvensi setiap modul CRUD, sehingga stub bisa ditulis sekali:

Bagian Konvensi
Model App\Models\{Model} dengan LogsActivity
Izin {modul}.lihat, {modul}.buat, {modul}.ubah, {modul}.hapus
Policy App\Policies\{Model}Policy, memeriksa izin di atas
Request Store{Model}Request, Update{Model}Request
Filter App\Filters\{Model}Filter dengan pencarian dan sort daftar putih
Controller App\Http\Controllers\Admin\{Model}Controller (resource, tanpa show bila tidak perlu)
View admin/{modul}/index.blade.php, admin/{modul}/form.blade.php
Test tests/Feature/Admin/{Model}CrudTest.php

Langkah 7: Generator CRUD dengan Stub Kustom

Generator menghasilkan semua file di atas dari stub, lalu developer melengkapi kolom dan aturan bisnisnya.

// app/Admin/Console/MakeCrudCommand.php
namespace App\Admin\Console;

use Illuminate\Console\Command;
use Illuminate\Filesystem\Filesystem;
use Illuminate\Support\Str;

use function Laravel\Prompts\{confirm, info, note, text};

class MakeCrudCommand extends Command
{
    protected $signature = 'make:crud {model : Nama model, misalnya Pengumuman} {--force : Timpa file yang sudah ada}';
    protected $description = 'Membuat modul CRUD admin (model, migration, policy, request, filter, controller, view, test)';

    public function handle(Filesystem $files): int
    {
        $model = Str::studly($this->argument('model'));
        $modul = Str::of($model)->kebab()->toString();          // pengumuman, transaksi-kas
        $tabel = Str::of($model)->snake()->plural()->toString(); // pengumumans → sesuaikan bila perlu

        $tabel = text('Nama tabel', default: $tabel, required: true);
        $label = text('Label tampilan (jamak)', default: Str::headline($model), required: true);

        $ganti = [
            '{{ model }}'       => $model,
            '{{ modelVar }}'    => Str::camel($model),
            '{{ modul }}'       => $modul,
            '{{ modulIzin }}'   => Str::of($modul)->replace('-', '_')->toString(),
            '{{ tabel }}'       => $tabel,
            '{{ label }}'       => $label,
        ];

        $peta = [
            'model.stub'          => app_path("Models/{$model}.php"),
            'policy.stub'         => app_path("Policies/{$model}Policy.php"),
            'request.store.stub'  => app_path("Http/Requests/Admin/Store{$model}Request.php"),
            'request.update.stub' => app_path("Http/Requests/Admin/Update{$model}Request.php"),
            'filter.stub'         => app_path("Filters/{$model}Filter.php"),
            'controller.stub'     => app_path("Http/Controllers/Admin/{$model}Controller.php"),
            'view.index.stub'     => resource_path("views/admin/{$modul}/index.blade.php"),
            'view.form.stub'      => resource_path("views/admin/{$modul}/form.blade.php"),
            'test.stub'           => base_path("tests/Feature/Admin/{$model}CrudTest.php"),
            'migration.stub'      => database_path('migrations/'.now()->format('Y_m_d_His')."_create_{$tabel}_table.php"),
        ];

        foreach ($peta as $stub => $tujuan) {
            if ($files->exists($tujuan) && ! $this->option('force')) {
                $this->components->warn("Dilewati (sudah ada): {$tujuan}");
                continue;
            }

            $isi = strtr($files->get(base_path("stubs/crud/{$stub}")), $ganti);
            $files->ensureDirectoryExists(dirname($tujuan));
            $files->put($tujuan, $isi);
            $this->components->info('Dibuat: '.str_replace(base_path().'/', '', $tujuan));
        }

        $this->tambahRoute($files, $model, $modul);
        $this->tambahIzin($files, $modul);

        note(implode(PHP_EOL, [
            'Langkah berikutnya:',
            "1. Lengkapi kolom di migration dan \$fillable model {$model}.",
            "2. Lengkapi aturan validasi di Store/Update{$model}Request.",
            "3. Tambahkan menu di config/admin.php (izin: {$ganti['{{ modulIzin }}']}.lihat).",
            '4. php artisan migrate && php artisan db:seed --class=RolePermissionSeeder',
            "5. php artisan test --filter={$model}CrudTest",
        ]));

        return self::SUCCESS;
    }

    private function tambahRoute(Filesystem $files, string $model, string $modul): void
    {
        $baris = "Route::resource('{$modul}', \\App\\Http\\Controllers\\Admin\\{$model}Controller::class)->except('show');";
        $path = base_path('routes/admin.php');

        if (! str_contains($files->get($path), $baris)) {
            $files->append($path, PHP_EOL.$baris.PHP_EOL);
            $this->components->info("Route ditambahkan: admin/{$modul}");
        }
    }

    private function tambahIzin(Filesystem $files, string $modul): void
    {
        $izin = Str::of($modul)->replace('-', '_');
        $this->components->info("Tambahkan izin ke enum Permission: {$izin}.lihat, {$izin}.buat, {$izin}.ubah, {$izin}.hapus");
    }
}

Contoh stub controller:

// stubs/crud/controller.stub
<?php

namespace App\Http\Controllers\Admin;

use App\Filters\{{ model }}Filter;
use App\Http\Controllers\Controller;
use App\Http\Requests\Admin\{Store{{ model }}Request, Update{{ model }}Request};
use App\Models\{{ model }};
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Gate;

class {{ model }}Controller extends Controller
{
    public function index(Request $request)
    {
        Gate::authorize('viewAny', {{ model }}::class);

        $filter = new {{ model }}Filter($request->validate({{ model }}Filter::rules()));

        return view('admin.{{ modul }}.index', [
            'items'  => $filter->apply({{ model }}::query(), $request->user())->paginate(15)->withQueryString(),
            'filter' => $filter->params(),
        ]);
    }

    public function create()
    {
        Gate::authorize('create', {{ model }}::class);

        return view('admin.{{ modul }}.form', ['{{ modelVar }}' => new {{ model }}]);
    }

    public function store(Store{{ model }}Request $request)
    {
        {{ model }}::create($request->validated());

        return redirect()->route('admin.{{ modul }}.index')->with('status', '{{ label }} berhasil ditambahkan.');
    }

    public function edit({{ model }} ${{ modelVar }})
    {
        Gate::authorize('update', ${{ modelVar }});

        return view('admin.{{ modul }}.form', compact('{{ modelVar }}'));
    }

    public function update(Update{{ model }}Request $request, {{ model }} ${{ modelVar }})
    {
        ${{ modelVar }}->update($request->validated());

        return redirect()->route('admin.{{ modul }}.index')->with('status', '{{ label }} berhasil diperbarui.');
    }

    public function destroy({{ model }} ${{ modelVar }})
    {
        Gate::authorize('delete', ${{ modelVar }});

        ${{ modelVar }}->delete();

        return redirect()->route('admin.{{ modul }}.index')->with('status', '{{ label }} berhasil dihapus.');
    }
}

Stub filter mengikuti pola class filter pada artikel Cara Membuat Filter, Search, Sorting, dan Pagination yang Efisien, ditambah method statis rules() (aturan validasi parameter daftar) dan method params() (parameter yang sudah tervalidasi untuk dikirim ke view).

Contoh stub policy:

// stubs/crud/policy.stub
<?php

namespace App\Policies;

use App\Models\{ {{ model }}, User };

class {{ model }}Policy
{
    public function viewAny(User $user): bool        { return $user->can('{{ modulIzin }}.lihat'); }
    public function view(User $user, {{ model }} $m): bool  { return $user->can('{{ modulIzin }}.lihat'); }
    public function create(User $user): bool         { return $user->can('{{ modulIzin }}.buat'); }
    public function update(User $user, {{ model }} $m): bool { return $user->can('{{ modulIzin }}.ubah'); }
    public function delete(User $user, {{ model }} $m): bool { return $user->can('{{ modulIzin }}.hapus'); }
}

Stub test langsung menguji izin dan alur dasar:

// stubs/crud/test.stub
<?php

use App\Models\{ {{ model }}, User };

beforeEach(fn () => $this->seed(\Database\Seeders\RolePermissionSeeder::class));

it('menolak pengguna tanpa izin {{ modulIzin }}.lihat', function () {
    $user = User::factory()->create()->assignRole('warga');

    $this->actingAs($user)->get(route('admin.{{ modul }}.index'))->assertForbidden();
});

it('admin dapat membuka daftar {{ label }}', function () {
    $admin = User::factory()->create()->assignRole('admin');
    {{ model }}::factory()->count(3)->create();

    $this->actingAs($admin)->get(route('admin.{{ modul }}.index'))->assertOk();
});

Karena middleware two-factor.required aktif di grup admin, pastikan factory User untuk test admin menghasilkan pengguna dengan 2FA aktif (misalnya state ->withTwoFactor()), atau nonaktifkan kewajiban tersebut di lingkungan testing lewat config(['admin.wajib_2fa' => []]).

Publikasikan juga stub bawaan Laravel bila ingin menyesuaikan hasil make:model, make:request, dan lainnya:

php artisan stub:publish

Pemakaian:

php artisan make:crud Pengumuman
  INFO  Dibuat: app/Models/Pengumuman.php
  INFO  Dibuat: app/Policies/PengumumanPolicy.php
  INFO  Dibuat: app/Http/Requests/Admin/StorePengumumanRequest.php
  ...
  INFO  Route ditambahkan: admin/pengumuman

  Langkah berikutnya:
  1. Lengkapi kolom di migration dan $fillable model Pengumuman.
  ...

Generator sengaja tidak mencoba menebak kolom atau aturan validasi. Bagian itu adalah keputusan bisnis yang harus ditulis developer; generator hanya menghapus pekerjaan berulang yang membosankan dan rawan lupa (Policy, izin, route, test).

Langkah 8: Modul Pengaturan

Gunakan SettingsStore dari artikel Membangun Laravel Starter Kit yang Reusable (tabel settings key-value dengan cache), lalu tambahkan definisi field agar halaman pengaturan dibuat dari satu daftar:

// config/admin.php → 'pengaturan'
'pengaturan' => [
    'Aplikasi' => [
        'aplikasi.nama'    => ['label' => 'Nama aplikasi', 'type' => 'text', 'rules' => ['required', 'string', 'max:100']],
        'aplikasi.zona'    => ['label' => 'Zona waktu', 'type' => 'select',
                               'options' => ['Asia/Jakarta' => 'WIB', 'Asia/Makassar' => 'WITA', 'Asia/Jayapura' => 'WIT'],
                               'rules' => ['required', 'timezone']],
    ],
    'Kontak' => [
        'kontak.alamat'    => ['label' => 'Alamat sekretariat', 'type' => 'textarea', 'rules' => ['nullable', 'string', 'max:255']],
        'kontak.telepon'   => ['label' => 'Telepon', 'type' => 'text', 'rules' => ['nullable', 'string', 'max:20']],
    ],
    'Keuangan' => [
        'kas.batas_persetujuan_pengurus' => ['label' => 'Batas pengeluaran wajib persetujuan pengurus (Rp)',
                                             'type' => 'number', 'rules' => ['required', 'integer', 'min:0']],
        'iuran.nominal_default'          => ['label' => 'Nominal iuran bulanan (Rp)', 'type' => 'number',
                                             'rules' => ['required', 'integer', 'min:0']],
    ],
],
// app/Admin/Http/Controllers/PengaturanController.php
namespace App\Admin\Http\Controllers;

use App\Admin\Settings\SettingsStore;
use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use Illuminate\Support\Arr;

class PengaturanController extends Controller
{
    public function edit(SettingsStore $settings)
    {
        return view('admin.pengaturan.edit', [
            'grup'  => config('admin.pengaturan'),
            'nilai' => $settings->all(),
        ]);
    }

    public function update(Request $request, SettingsStore $settings)
    {
        $definisi = collect(config('admin.pengaturan'))->collapse();

        // Kunci berisi titik; validasi memakai nama field dengan "__" sebagai pengganti
        $rules = $definisi->mapWithKeys(fn ($d, $key) => [str_replace('.', '__', $key) => $d['rules']])->all();
        $data = $request->validate($rules);

        $lama = Arr::only($settings->all(), $definisi->keys()->all());
        $baru = collect($data)->mapWithKeys(fn ($v, $k) => [str_replace('__', '.', $k) => $v])->all();

        $settings->set($baru);

        $berubah = array_keys(array_diff_assoc(array_map('strval', $baru), array_map('strval', $lama)));
        if ($berubah) {
            activity('pengaturan')->causedBy($request->user())
                ->withProperties(['diubah' => $berubah])
                ->log('Pengaturan aplikasi diubah');
        }

        return back()->with('status', 'Pengaturan disimpan.');
    }
}

Field di form pengaturan diberi nama dengan __ sebagai pengganti titik (misalnya aplikasi__nama), karena titik pada nama field dibaca Laravel sebagai array bertingkat. Hanya kunci yang didefinisikan di konfigurasi yang bisa diubah; kunci lain dari input diabaikan karena tidak ada di $rules. Perubahan pengaturan dicatat ke activity log.

Logo aplikasi disimpan dengan media library (koleksi logo pada model khusus Aplikasi atau pada model pengaturan), mengikuti artikel Media Library.

Langkah 9: Manajemen Pengguna

Admin starter tidak membuka registrasi publik. Pengguna diundang oleh admin:

// app/Admin/Http/Controllers/PenggunaController.php (bagian penting)
public function store(Request $request)
{
    $data = $request->validate([
        'name'    => ['required', 'string', 'max:100'],
        'email'   => ['required', 'email', 'max:255', 'unique:users,email'],
        'peran'   => ['required', 'array', 'min:1'],
        'peran.*' => [Rule::in($this->peranYangBolehDiberikan($request->user()))],
    ]);

    $user = User::create([
        'name'     => $data['name'],
        'email'    => Str::lower($data['email']),
        'password' => Str::password(32),         // acak; pengguna mengatur sendiri lewat tautan
        'is_active'=> true,
    ])->syncRoles($data['peran']);

    Password::sendResetLink(['email' => $user->email]);   // email "atur password" berfungsi sebagai undangan

    activity('pengguna')->performedOn($user)->causedBy($request->user())
        ->withProperties(['peran' => $data['peran']])->log('Pengguna diundang');

    return redirect()->route('admin.pengguna.index')->with('status', 'Undangan dikirim ke '.$user->email);
}

public function nonaktifkan(Request $request, User $pengguna)
{
    abort_if($pengguna->is($request->user()), 422, 'Anda tidak dapat menonaktifkan akun sendiri.');

    $pengguna->forceFill(['is_active' => false, 'remember_token' => null])->save();
    DB::table('sessions')->where('user_id', $pengguna->id)->delete();   // putus semua sesi
    $pengguna->tokens()->delete();                                       // cabut token API

    activity('pengguna')->performedOn($pengguna)->causedBy($request->user())->log('Pengguna dinonaktifkan');

    return back()->with('status', 'Pengguna dinonaktifkan.');
}

/** Admin biasa tidak boleh memberikan peran super-admin */
private function peranYangBolehDiberikan(User $pemberi): array
{
    $semua = Role::pluck('name')->all();

    return $pemberi->hasRole('super-admin') ? $semua : array_values(array_diff($semua, ['super-admin']));
}

Pengaman yang sering terlupa:

  • Eskalasi hak akses: admin biasa tidak boleh memberikan peran yang lebih tinggi dari miliknya.
  • Mengunci diri sendiri: admin tidak bisa menonaktifkan atau mencabut peran adminnya sendiri.
  • Sesi aktif: menonaktifkan akun harus memutus sesi dan token yang sedang berjalan.
  • Aksi sensitif dilindungi password.confirm.

Langkah 10: Activity Log yang Bisa Ditelusuri

Pasang LogsActivity (spatie/laravel-activitylog v5) di model bisnis lewat stub model generator:

// stubs/crud/model.stub (sebagian)
use Spatie\Activitylog\Models\Concerns\LogsActivity;
use Spatie\Activitylog\Support\LogOptions;

class {{ model }} extends Model
{
    use HasFactory, LogsActivity;

    public function getActivitylogOptions(): LogOptions
    {
        return LogOptions::defaults()
            ->logFillable()
            ->logExcept(['updated_at'])
            ->logOnlyDirty()
            ->dontLogEmptyChanges()
            ->useLogName('{{ modul }}');
    }
}

Halaman aktivitas dengan filter:

// app/Admin/Http/Controllers/AktivitasController.php
public function index(Request $request)
{
    $f = $request->validate([
        'log'     => ['nullable', 'string', 'max:50'],
        'pelaku'  => ['nullable', 'integer'],
        'dari'    => ['nullable', 'date'],
        'sampai'  => ['nullable', 'date', 'after_or_equal:dari'],
    ]);

    $aktivitas = Activity::query()
        ->with(['causer:id,name', 'subject'])
        ->when($f['log'] ?? null, fn ($q, $log) => $q->where('log_name', $log))
        ->when($f['pelaku'] ?? null, fn ($q, $id) => $q->where('causer_id', $id)->where('causer_type', (new User)->getMorphClass()))
        ->when($f['dari'] ?? null, fn ($q, $d) => $q->where('created_at', '>=', Carbon::parse($d, 'Asia/Jakarta')->startOfDay()->utc()))
        ->when($f['sampai'] ?? null, fn ($q, $d) => $q->where('created_at', '<=', Carbon::parse($d, 'Asia/Jakarta')->endOfDay()->utc()))
        ->latest()
        ->paginate(30)
        ->withQueryString();

    return view('admin.aktivitas.index', [
        'aktivitas' => $aktivitas,
        'daftarLog' => Activity::query()->distinct()->orderBy('log_name')->pluck('log_name'),
        'filter'    => $f,
    ]);
}

Tampilkan perubahan dalam bahasa manusia: "Bendahara Ani mengubah jumlah dari Rp 250.000 menjadi Rp 275.000 pada Transaksi Kas #128". Kolom attribute_changes di v5 berisi attributes (nilai baru) dan old (nilai lama).

Jadwalkan pembersihan sesuai retensi yang disepakati:

Schedule::command('activitylog:clean')->daily();

Langkah 11: Installer dan Seeder Demo

Gunakan perintah kit:install dari artikel Membangun Laravel Starter Kit yang Reusable untuk membuat super admin, menjalankan migrasi, dan menyiapkan peran. Tambahkan seeder demo yang hanya berjalan di lokal:

// database/seeders/DatabaseSeeder.php
public function run(): void
{
    $this->call(RolePermissionSeeder::class);
    $this->call(PengaturanAwalSeeder::class);

    if (app()->isLocal()) {
        $this->call(DemoSeeder::class);      // pengguna per peran + data contoh
    }
}

DemoSeeder membuat akun admin@demo.test, bendahara@demo.test, pengurus@demo.test, dan warga@demo.test dengan password yang dicetak di terminal, sehingga developer baru bisa langsung mencoba semua peran.

Langkah 12: Test Arsitektur dan Konsistensi

// tests/Arch/AdminStarterTest.php
arch('controller admin bebas dd() dan dump()')
    ->expect('App\Http\Controllers\Admin')
    ->not->toUse(['dd', 'dump']);

arch('semua model bisnis mencatat aktivitas')
    ->expect('App\Models')
    ->classes()
    ->toUseTrait(\Spatie\Activitylog\Models\Concerns\LogsActivity::class)
    ->ignoring([\App\Models\User::class, \App\Models\Notifikasi::class]);

arch('inti admin tidak bergantung pada controller modul bisnis')
    ->expect('App\Admin')
    ->not->toUse('App\Http\Controllers\Admin');
// tests/Feature/Admin/KonsistensiTest.php
use Illuminate\Support\Facades\{Gate, Route};

it('setiap model punya policy', function () {
    $tanpaPolicy = collect(glob(app_path('Models/*.php')))
        ->map(fn ($f) => 'App\\Models\\'.basename($f, '.php'))
        ->reject(fn ($m) => in_array($m, [\App\Models\User::class, \App\Models\Notifikasi::class], true))
        ->filter(fn ($m) => Gate::getPolicyFor($m) === null)
        ->values();

    expect($tanpaPolicy)->toBeEmpty();
});

it('setiap item menu mengarah ke route yang ada', function () {
    $routes = collect(config('admin.menu'))
        ->flatMap(fn ($i) => isset($i['grup']) ? $i['items'] : [$i])
        ->pluck('route');

    $routes->each(fn ($r) => expect(Route::has($r))->toBeTrue("Route {$r} tidak ada"));
});

it('semua route admin memakai middleware wajib', function () {
    collect(Route::getRoutes()->getRoutes())
        ->filter(fn ($r) => str_starts_with((string) $r->getName(), 'admin.'))
        ->each(fn ($r) => expect($r->gatherMiddleware())
            ->toContain('auth', 'active', 'two-factor.required'));
});

it('admin biasa tidak bisa memberi peran super-admin', function () {
    $this->seed(\Database\Seeders\RolePermissionSeeder::class);
    config(['admin.wajib_2fa' => []]);
    $admin = User::factory()->create()->assignRole('admin');

    $this->actingAs($admin)->post(route('admin.pengguna.store'), [
        'name' => 'X', 'email' => 'x@contoh.id', 'peran' => ['super-admin'],
    ])->assertSessionHasErrors('peran.0');
});

Test konsistensi ini adalah "pagar" admin starter: setiap modul baru otomatis diperiksa memiliki Policy, activity log, route yang terlindungi, dan menu yang valid.

Troubleshooting

Error / Gejala Penyebab Solusi
Semua test admin mendapat redirect Middleware wajib 2FA aktif di test Set config(['admin.wajib_2fa' => []]) di test atau buat state factory dengan 2FA aktif
Route [admin.xxx.index] not defined di menu Menu ditambahkan sebelum route Jalankan test konsistensi menu; tambahkan route lewat generator
Halaman Fortify memakai tampilan bawaan View belum didaftarkan Daftarkan Fortify::loginView() dan view lain di provider
Akun nonaktif masih bisa login authenticateUsing tidak memeriksa is_active Periksa is_active di callback Fortify dan middleware active
Generator menimpa pekerjaan developer Dijalankan ulang dengan --force Jangan pakai --force kecuali modul masih kosong; commit sebelum menjalankan generator
Izin modul baru tidak dikenali Enum diperbarui tetapi seeder belum dijalankan / cache izin db:seed --class=RolePermissionSeeder dan permission:cache-reset
Pengaturan tidak berubah di server lain Cache pengaturan lokal per server Gunakan Redis sebagai cache bersama
Activity log membengkak Mencatat semua kolom termasuk yang sering berubah logOnlyDirty(), logExcept(), retensi dan activitylog:clean

Best Practices

Keamanan

  • Registrasi publik dimatikan; pengguna diundang oleh admin.
  • Grup route admin memaksa auth, active, dan 2FA untuk peran sensitif.
  • Cegah eskalasi hak akses dan penguncian diri sendiri di manajemen pengguna.
  • Nonaktifkan akun berarti memutus sesi dan mencabut token.
  • Catat perubahan peran, pengguna, dan pengaturan ke activity log.

Performa

  • Cache izin (Spatie), pengaturan (SettingsStore), dan angka dasbor di Redis.
  • Daftar data memakai class filter dengan indeks yang sesuai dan pagination yang tepat.
  • Queue untuk email, notifikasi, konversi media, dan ekspor.

Maintainability

  • Pisahkan inti starter (app/Admin) dari modul bisnis.
  • Generator CRUD menegakkan konvensi: setiap modul punya Policy, izin, Request, Filter, activity log, dan test sejak lahir.
  • Konfigurasi menu dan pengaturan di satu file (config/admin.php).
  • Test arsitektur dan konsistensi menjaga konvensi tetap dipatuhi seiring proyek tumbuh.
  • Perbarui starter di repository tersendiri, lalu salurkan perubahannya ke proyek turunan (lihat artikel Membangun Laravel Starter Kit yang Reusable).

Related Articles

Last Tested

Komponen Versi
Laravel 13.x
PHP 8.4
Laravel Fortify 1.x
spatie/laravel-permission 8.x
spatie/laravel-activitylog 5.x
spatie/laravel-medialibrary 11.x
Tailwind CSS 4.3.x
Pest 4.x
Tanggal 19 Oktober 2026

Bagikan artikel:

Artikel lainnya