biiproject-kit-v2/app/Http/Controllers/UserController.php

<?php

namespace App\Http\Controllers;

use App\Exports\UsersExport;
use App\Imports\UsersImport;
use App\Models\User;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Hash;
use Illuminate\Validation\Rules\Password;
use Inertia\Inertia;
use Maatwebsite\Excel\Facades\Excel;
use Spatie\Permission\Models\Role;

class UserController extends Controller
{
    public function index(Request $request)
    {
        $this->authorize('viewAny', User::class);

        $trashed   = $request->input('trashed');
        $search    = $request->input('search');
        $status    = $request->input('status');
        $role      = $request->input('role');
        $sortField = $request->input('sort_field', 'created_at');
        $sortDir   = $request->input('sort_direction', 'desc');
        $perPage   = (int) $request->input('per_page', 15);

        $query = User::with('roles');

        if ($trashed === 'only') {
            $query->onlyTrashed();
        } elseif ($trashed === 'with') {
            $query->withTrashed();
        }

        if ($search) {
            $query->where(function ($q) use ($search) {
                $q->where('first_name', 'like', "%{$search}%")
                  ->orWhere('last_name', 'like', "%{$search}%")
                  ->orWhere('email', 'like', "%{$search}%");
            });
        }

        if ($status) {
            $query->where('status', $status);
        }

        if ($role) {
            $query->role($role);
        }

        $allowedSortFields = ['first_name', 'last_name', 'email', 'status', 'created_at'];
        if (!\in_array($sortField, $allowedSortFields, true)) {
            $sortField = 'created_at';
        }
        $sortDir = $sortDir === 'asc' ? 'asc' : 'desc';

        $users = $query->orderBy($sortField, $sortDir)
                       ->paginate($perPage)
                       ->withQueryString();

        $roles = Role::where('guard_name', 'web')->pluck('name');

        return Inertia::render('Users/Index', [
            'users' => [
                'data'  => $users->items(),
                'meta'  => [
                    'current_page' => $users->currentPage(),
                    'last_page'    => $users->lastPage(),
                    'total'        => $users->total(),
                    'per_page'     => $users->perPage(),
                ],
                'links' => $users->linkCollection()->toArray(),
            ],
            'filters'        => $request->only(['search', 'status', 'role', 'sort_field', 'sort_direction', 'per_page', 'trashed']),
            'availableRoles' => $roles,
        ]);
    }

    public function show(User $user)
    {
        $this->authorize('view', $user);
        $user->load(['roles', 'permissions']);

        return Inertia::render('Users/Show', [
            'viewUser' => $user,
        ]);
    }

    public function store(Request $request)
    {
        $this->authorize('create', User::class);

        $validated = $request->validate([
            'first_name' => 'required|string|max:255',
            'last_name'  => 'required|string|max:255',
            'email'      => 'required|email|unique:users',
            'password'   => ['required', Password::defaults()],
            'status'     => 'in:active,inactive',
            'roles'      => 'nullable|array',
            'roles.*'    => 'string|exists:roles,name',
        ]);

        $user = User::create([
            'first_name' => $validated['first_name'],
            'last_name'  => $validated['last_name'],
            'email'      => $validated['email'],
            'password'   => Hash::make($validated['password']),
            'status'     => $validated['status'] ?? 'active',
        ]);

        if (!empty($validated['roles'])) {
            $user->syncRoles($validated['roles']);
        }

        return back()->with('success', 'User created successfully.');
    }

    public function update(Request $request, User $user)
    {
        $this->authorize('update', $user);

        $validated = $request->validate([
            'first_name' => 'sometimes|string|max:255',
            'last_name'  => 'sometimes|string|max:255',
            'email'      => 'sometimes|email|unique:users,email,' . $user->id,
            'status'     => 'sometimes|in:active,inactive',
            'roles'      => 'nullable|array',
            'roles.*'    => 'string|exists:roles,name',
        ]);

        $roles = $validated['roles'] ?? null;
        unset($validated['roles']);

        $user->update($validated);

        if ($roles !== null) {
            $user->syncRoles($roles);
        }

        return back()->with('success', 'User updated successfully.');
    }

    public function destroy(User $user)
    {
        $this->authorize('delete', $user);

        if ($user->id === auth()->id()) {
            return back()->withErrors(['error' => 'You cannot delete your own account.']);
        }

        $user->delete();

        return back()->with('success', 'Entity moved to archive.');
    }

    public function restore(int $id)
    {
        $user = User::withTrashed()->findOrFail($id);
        $this->authorize('restore', $user);

        $user->restore();

        return back()->with('success', 'Entity restored from archive.');
    }

    public function forceDelete(int $id)
    {
        $user = User::withTrashed()->findOrFail($id);
        $this->authorize('forceDelete', $user);

        if ($user->id === auth()->id()) {
            return back()->withErrors(['error' => 'You cannot delete your own account.']);
        }

        $user->forceDelete();

        return back()->with('success', 'Entity permanently purged.');
    }

    public function bulkArchive(Request $request)
    {
        abort_if(!auth()->user()->can('user.delete'), 403, 'Unauthorized. User delete permission required.');

        $ids = array_filter(
            (array) $request->input('ids', []),
            fn ($id) => (int) $id !== auth()->id()
        );

        User::whereIn('id', $ids)->delete();

        return back()->with('success', \count($ids) . ' users archived.');
    }

    public function bulkRestore(Request $request)
    {
        abort_if(!auth()->user()->can('user.restore'), 403, 'Unauthorized. User restore permission required.');

        $ids = (array) $request->input('ids', []);

        User::withTrashed()->whereIn('id', $ids)->restore();

        return back()->with('success', \count($ids) . ' users restored.');
    }

    public function bulkForceDelete(Request $request)
    {
        abort_if(!auth()->user()->can('user.force-delete'), 403, 'Unauthorized. User permanent deletion permission required.');

        $ids = array_filter(
            (array) $request->input('ids', []),
            fn ($id) => (int) $id !== auth()->id()
        );

        User::withTrashed()->whereIn('id', $ids)->forceDelete();

        return back()->with('success', \count($ids) . ' users permanently deleted.');
    }

    public function export()
    {
        $this->authorize('viewAny', User::class);

        return Excel::download(new UsersExport, 'users-' . now()->format('Y-m-d') . '.xlsx');
    }

    public function import(Request $request)
    {
        $this->authorize('create', User::class);

        $request->validate([
            'file' => 'required|mimes:xlsx,csv,xls|max:5120',
        ]);

        Excel::import(new UsersImport, $request->file('file'));

        return back()->with('success', 'Users imported successfully.');
    }
}