store-manage/app/Models/AdminUser.php

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Relations\BelongsToMany;
use Illuminate\Database\Eloquent\Relations\HasOne;
use Illuminate\Support\Collection;
use Slowlyo\OwlAdmin\Admin;
use Slowlyo\OwlAdmin\Models\AdminUser as Model;

class AdminUser extends Model
{
    /**
     * @var \Illuminate\Support\Collection
     */
    protected $allAbilities;

    protected static function booted(): void
    {
        static::updated(function (AdminUser $model) {
            if ($model->wasChanged(['name', 'avatar'])) {
                $model->employee()->update([
                    'name' => $model->name,
                    'avatar' => $model->avatar,
                ]);
            }
        });
    }

    public function roles(): BelongsToMany
    {
        return $this->belongsToMany(Admin::adminRoleModel(), 'admin_role_users', 'user_id', 'role_id')->withTimestamps();
    }

    public function employee(): HasOne
    {
        return $this->hasOne(Employee::class);
    }

    /**
     * 获取此用户的全部能力
     */
    public function allAbilities(): Collection
    {
        if ($this->allAbilities) {
            return $this->allAbilities;
        }

        $model = Admin::adminPermissionModel();
        $allPermissions = $model::all(['id', 'parent_id', 'slug'])->keyBy('id');

        /** @var \Illuminate\Database\Eloquent\Collection 此用户的所有角色的权限集合 */
        $rolePermissions = $this->roles
            ->pluck('permissions')
            ->flatten()
            ->keyBy('id');

        $abilities = $rolePermissions->map(fn ($permission) => $permission->slug);

        foreach ($rolePermissions as $rolePermission) {
            if (is_null($rolePermission->parent_id) || $abilities->has($rolePermission->parent_id)) {
                continue;
            }

            $parent = $allPermissions->get($rolePermission->parent_id);

            while ($parent) {
                $abilities->put($parent->id, $parent->slug);

                if (is_null($parent->parent_id)) {
                    break;
                }

                $parent = $allPermissions->get($parent->parent_id);
            }
        }

        unset($allPermissions, $rolePermissions);

        return $this->allAbilities = $abilities;
    }

    public function can($abilities, $arguments = []): bool
    {
        if (empty($abilities)) {
            return true;
        }

        if ($this->isAdministrator()) {
            return true;
        }

        return collect($abilities)->every(
            fn ($ability) => $this->allAbilities()->contains($ability)
        );
    }

    public function allMenus(): Collection
    {
        $model = Admin::adminMenuModel();
        $allMenus = $model::all()->keyBy($this->getKeyName());

        if ($this->isAdministrator()) {
            return $allMenus;
        }

        /** @var \Illuminate\Database\Eloquent\Collection */
        $roleMenus = $this->roles
            ->pluck('menus')
            ->flatten()
            ->keyBy($this->getKeyName());

        $allRoleMenus = $roleMenus->collect();

        foreach ($roleMenus as $roleMenu) {
            if (is_null($roleMenu->parent_id) || $allRoleMenus->has($roleMenu->parent_id)) {
                continue;
            }

            $parent = $allMenus->get($roleMenu->parent_id);

            while ($parent) {
                $allRoleMenus->put($parent->id, $parent);

                if (is_null($parent->parent_id)) {
                    break;
                }

                $parent = $allMenus->get($parent->parent_id);
            }
        }

        unset($allMenus, $roleMenus);

        return $allRoleMenus;
    }
}