Added the ability to manage users.

app/Dto/Builder/User.php

@@ -0,0 +1,10 @@
+<?php declare(strict_types=1);
+
+namespace App\Dto\Builder;
+
+final readonly class User
+{
+    public function __construct(
+
+    ) { }
+}

app/Dto/Request/Private/User/Index.php

@@ -0,0 +1,24 @@
+<?php declare(strict_types=1);
+
+namespace App\Dto\Request\Private\User;
+
+use App\Dto\Builder\User;
+use App\Dto\Request\Dto;
+
+final readonly class Index extends Dto
+{
+    public function __construct(
+        private User $userBuilderDto,
+        private int $page
+    ) { }
+
+    public function getUserBuilderDto(): User
+    {
+        return $this->userBuilderDto;
+    }
+
+    public function getPage(): int
+    {
+        return $this->page;
+    }
+}

app/Dto/Request/Private/User/StoreUpdate.php

@@ -0,0 +1,42 @@
+<?php declare(strict_types=1);
+
+namespace App\Dto\Request\Private\User;
+
+use App\Dto\Request\Dto;
+use App\Dto\User\ManyRoleDto;
+
+final readonly class StoreUpdate extends Dto
+{
+    public function __construct(
+        private string $name,
+        private string $email,
+        private bool   $isActive,
+        private ManyRoleDto $roles,
+        private ?string $password = null
+    ) { }
+
+    public function getName(): string
+    {
+        return $this->name;
+    }
+
+    public function getEmail(): string
+    {
+        return $this->email;
+    }
+
+    public function getPassword(): ?string
+    {
+        return $this->password;
+    }
+
+    public function getRoles(): ManyRoleDto
+    {
+        return $this->roles;
+    }
+
+    public function isActive(): bool
+    {
+        return $this->isActive;
+    }
+}

app/Dto/Request/Private/User/UpdatePassword.php

@@ -1,6 +1,6 @@
 <?php declare(strict_types=1);
 
-namespace App\Dto\Request\Private\Profile;
+namespace App\Dto\Request\Private\User;
 
 use App\Dto\Request\Dto;
 

app/Enums/Permission.php

@@ -5,6 +5,7 @@ namespace App\Enums;
 enum Permission: string
 {
     case Role = 'role';
+    case User = 'user';
 
     public function getPermissions(): array
     {

app/Http/Controllers/Private/UsersController.php

@@ -0,0 +1,106 @@
+<?php declare(strict_types=1);
+
+namespace App\Http\Controllers\Private;
+
+use App\Dto\QuerySettingsDto;
+use App\Http\Requests\Private\Users\IndexRequest;
+use App\Http\Requests\Private\Users\StoreUpdateRequest;
+use App\Http\Requests\Private\Users\UpdatePasswordRequest;
+use App\Services\Private\UserService;
+use Illuminate\Http\RedirectResponse;
+use Illuminate\Http\Request;
+use Illuminate\View\View;
+
+class UsersController extends Controller
+{
+    public function __construct(
+        private readonly UserService $userService
+    ) { }
+
+    public function index(IndexRequest $request): View
+    {
+        $user = $request->user();
+        $data = $request->getDto();
+        $querySettingsDto = new QuerySettingsDto(
+            limit: 20,
+            page: $data->getPage(),
+            queryWith: []
+        );
+
+        $result = $this->userService->index($data->getUserBuilderDto(), $querySettingsDto, $user);
+        if ($result->isError()) {
+            $this->errors($result);
+        }
+
+        return view('private/users/index', $result->getData());
+    }
+
+    public function create(Request $request): View
+    {
+        $user = $request->user();
+        $result = $this->userService->create($user);
+        if ($result->isError()) {
+            $this->errors($result);
+        }
+
+        return view('private/users/create', $result->getData());
+    }
+
+    public function edit(int $id, Request $request): View
+    {
+        $user = $request->user();
+        $result = $this->userService->edit($id, $user);
+        if ($result->isError()) {
+            $this->errors($result);
+        }
+
+        return view('private/users/edit', $result->getData());
+    }
+
+    public function store(StoreUpdateRequest $request): RedirectResponse
+    {
+        $data = $request->getDto();
+        $user = $request->user();
+        $result = $this->userService->store($data, $user);
+        if ($result->isError()) {
+            return redirect()->back()->withInput()->withErrors($result->getErrorsOrMessage());
+        }
+
+        return redirect()->route('users.edit', $result->getModel())->withSuccess($result->getMessage());
+    }
+
+    public function update(int $id, StoreUpdateRequest $request): RedirectResponse
+    {
+        $data = $request->getDto();
+        $user = $request->user();
+        $result = $this->userService->update($id, $data, $user);
+        if ($result->isError()) {
+            return redirect()->back()->withInput()->withErrors($result->getErrorsOrMessage());
+        }
+
+        return redirect()->route('users.edit', $result->getModel())->withSuccess($result->getMessage());
+    }
+
+    public function updatePassword(int $id, UpdatePasswordRequest $request): RedirectResponse
+    {
+        $data = $request->getDto();
+        $user = $request->user();
+        $result = $this->userService->updatePassword($id, $data, $user);
+        if ($result->isError()) {
+            return redirect()->back()->withInput()->withErrors($result->getErrorsOrMessage());
+        }
+
+        return redirect()->route('users.edit', $result->getModel())->withSuccess($result->getMessage());
+    }
+
+    public function destroy(int $id, Request $request): RedirectResponse
+    {
+        $user = $request->user();
+        $result = $this->userService->destroy($id, $user);
+        if ($result->isError()) {
+            return redirect()->back()->withInput()->withErrors($result->getErrorsOrMessage());
+        }
+
+        return redirect()->route('users.index')->withSuccess($result->getMessage());
+    }
+}

app/Http/Requests/Private/Profile/UpdatePasswordRequest.php

@@ -3,7 +3,7 @@
 namespace App\Http\Requests\Private\Profile;
 
 use App\Contracts\FormRequestDto;
-use App\Dto\Request\Private\Profile\UpdatePassword;
+use App\Dto\Request\Private\User\UpdatePassword;
 use Illuminate\Foundation\Http\FormRequest;
 use Illuminate\Validation\Rules\Password;
 

app/Http/Requests/Private/Users/IndexRequest.php

@@ -0,0 +1,30 @@
+<?php declare(strict_types=1);
+
+namespace App\Http\Requests\Private\Users;
+
+use App\Contracts\FormRequestDto;
+use App\Dto\Builder\User;
+use App\Dto\Request\Private\User\Index;
+use Illuminate\Foundation\Http\FormRequest;
+
+final class IndexRequest extends FormRequest implements FormRequestDto
+{
+    /**
+     * Get the validation rules that apply to the request.
+     */
+    public function rules(): array
+    {
+        $this->redirect = route('users.index');
+        return [
+            'page' => ['nullable', 'numeric', 'min:1']
+        ];
+    }
+
+    public function getDto(): Index
+    {
+        return new Index(
+            userBuilderDto: new User(),
+            page: (int) $this->input('page', 1)
+        );
+    }
+}

app/Http/Requests/Private/Users/StoreUpdateRequest.php

@@ -0,0 +1,44 @@
+<?php declare(strict_types=1);
+
+namespace App\Http\Requests\Private\Users;
+
+use App\Contracts\FormRequestDto;
+use App\Dto\Request\Private\User\StoreUpdate;
+use App\Dto\User\ManyRoleDto;
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Validation\Rule;
+use Illuminate\Validation\Rules\Password;
+
+final class StoreUpdateRequest extends FormRequest implements FormRequestDto
+{
+    /**
+     * Get the validation rules that apply to the request.
+     */
+    public function rules(): array
+    {
+        $rules = [
+            'name' => ['required', 'max:255'],
+            'email' => ['required', 'email', 'max:255'],
+            'is_active' => ['required', 'boolean'],
+            'roles' => ['array', Rule::exists('roles', 'id')],
+        ];
+
+        if ($this->getMethod() === 'POST') {
+            $rules['password'] = ['required', Password::default()];
+        }
+
+        return $rules;
+    }
+
+
+    public function getDto(): StoreUpdate
+    {
+        return new StoreUpdate(
+            name: $this->input('name'),
+            email: $this->input('email'),
+            isActive: (bool) $this->input('is_active', false),
+            roles: new ManyRoleDto($this->input('roles', [])),
+            password: $this->input('password', null),
+        );
+    }
+}

app/Http/Requests/Private/Users/UpdatePasswordRequest.php

@@ -0,0 +1,26 @@
+<?php declare(strict_types=1);
+
+namespace App\Http\Requests\Private\Users;
+
+use App\Contracts\FormRequestDto;
+use App\Dto\Request\Private\User\UpdatePassword;
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Validation\Rules\Password;
+
+final class UpdatePasswordRequest extends FormRequest implements FormRequestDto
+{
+    /**
+     * Get the validation rules that apply to the request.
+     */
+    public function rules(): array
+    {
+        return [
+            'password' => ['required', Password::default()],
+        ];
+    }
+
+    public function getDto(): UpdatePassword
+    {
+        return new UpdatePassword(password: $this->input('password'));
+    }
+}

app/Models/User.php

@@ -4,6 +4,8 @@ namespace App\Models;
 
 // use Illuminate\Contracts\Auth\MustVerifyEmail;
 use App\Enums\Lang;
+use App\Enums\SystemRole;
+use Illuminate\Database\Eloquent\Casts\Attribute;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Relations\BelongsToMany;
 use Illuminate\Database\Eloquent\SoftDeletes;
@@ -66,4 +68,33 @@ final class User extends Authenticatable
     {
         return $this->belongsToMany(Role::class);
     }
+
+    public function hasRole(string $role): bool
+    {
+        return $this->roles->where('code', $role)->isNotEmpty();
+    }
+
+    public function hasPermission(string $permission): bool
+    {
+        return $this->permissions->search($permission) !== false;
+    }
+
+    protected function isAdmin(): Attribute
+    {
+        return Attribute::make(
+            get: fn () => $this->hasRole(SystemRole::Admin->value),
+        )->shouldCache();
+    }
+
+    protected function permissions(): Attribute
+    {
+        return Attribute::make(
+            get: function () {
+                $roles = $this->roles->modelKeys();
+                return RolePermission::whereIn('role_id', $roles)->select('permission')->pluck('permission');
+            },
+        )->shouldCache();
+    }
+
+
 }

app/Policies/UserPolicy.php

@@ -0,0 +1,33 @@
+<?php declare(strict_types=1);
+
+namespace App\Policies;
+
+use App\Models\User;
+
+final readonly class UserPolicy extends Policy
+{
+    public function viewAny(User $user): bool
+    {
+        return $user->hasPermission('user.view');
+    }
+
+    public function view(User $user, User $userView): bool
+    {
+        return $user->hasPermission('user.view');
+    }
+
+    public function create(User $user): bool
+    {
+        return $user->hasPermission('user.create');
+    }
+
+    public function update(User $user, User $userUpdate): bool
+    {
+        return $user->hasPermission('user.update');
+    }
+
+    public function delete(User $user, User $userDelete): bool
+    {
+        return $user->hasPermission('user.delete');
+    }
+}

app/Repositories/UserRepository.php

@@ -2,13 +2,49 @@
 
 namespace App\Repositories;
 
+use App\Contracts\Search;
 use App\Models\User;
+use App\Dto\Builder\User as UserBuilderDto;
+use App\Services\User\BuilderCommand;
+use App\Services\Search\CreateSearchInstanceCommand;
 use Illuminate\Support\Str;
+use Illuminate\Database\Eloquent\Builder;
 
 final readonly class UserRepository
 {
+    public function __construct(
+        private CreateSearchInstanceCommand $createSearchInstanceCommand,
+        private BuilderCommand $builderCommand
+    ) { }
+
+    public function getUserById(int $id): ?User
+    {
+        return User::query()->where('id', $id)->first();
+    }
+
     public function getUserByEmail(string $email): ?User
     {
         return User::query()->where('email', Str::lower($email))->first();
     }
+
+    public function getUsers(UserBuilderDto $userBuilderDto, array $with = []): Search
+    {
+        $query = $this->builderCommand->execute(
+            query: User::query()->with($with),
+            userBuilderDto: $userBuilderDto
+        );
+
+        return $this->createSearchInstanceCommand->execute($query);
+    }
+
+    public function isExistsEmail(string $email, ?int $exceptId = null): bool
+    {
+        return User::query()
+            ->where('email', Str::lower($email))
+            ->when($exceptId, function (Builder $query, int $exceptId) {
+                $query->where('id', '!=', $exceptId);
+            })
+            ->withTrashed()
+            ->exists();
+    }
 }

app/Services/Private/ProfileService.php

@@ -3,8 +3,8 @@
 namespace App\Services\Private;
 
 use App\Dto\Request\Private\Profile\Update;
-use App\Dto\Request\Private\Profile\UpdatePassword;
 use App\Dto\Request\Private\Profile\UpdateSettings;
+use App\Dto\Request\Private\User\UpdatePassword;
 use App\Models\User;
 use App\ServiceResults\ServiceResultError;
 use App\ServiceResults\ServiceResultSuccess;

app/Services/Private/UserService.php

@@ -0,0 +1,201 @@
+<?php declare(strict_types=1);
+
+namespace App\Services\Private;
+
+use App\Dto\Builder\User as UserBuilderDto;
+use App\Dto\Request\Private\User\StoreUpdate;
+use App\Dto\Request\Private\User\UpdatePassword;
+use App\Models\User;
+use App\Dto\QuerySettingsDto;
+use App\Repositories\RoleRepository;
+use App\Repositories\UserRepository;
+use App\ServiceResults\ServiceResultArray;
+use App\ServiceResults\ServiceResultError;
+use App\ServiceResults\ServiceResultSuccess;
+use App\ServiceResults\StoreUpdateResult;
+use App\Services\Service;
+use App\Services\User\UserCommandHandler;
+use Illuminate\Support\Facades\DB;
+
+final class UserService extends Service
+{
+    public function __construct(
+        private readonly UserRepository $userRepository,
+        private readonly UserCommandHandler $userCommandHandler,
+        private readonly RoleRepository $roleRepository
+    ) { }
+
+    public function index(UserBuilderDto $userBuilderDto, QuerySettingsDto $querySettingsDto, User $user): ServiceResultError | ServiceResultArray
+    {
+        if ($user->cannot('viewAny', User::class)) {
+            return $this->errFobidden(__('Access is denied'));
+        }
+
+        $users = $this->userRepository->getUsers(
+            $userBuilderDto,
+            $querySettingsDto->getQueryWith()
+        )->pagination(
+            $querySettingsDto->getLimit(),
+            $querySettingsDto->getPage()
+        );
+
+        return $this->result([
+            'users' => $users,
+        ]);
+    }
+
+    public function create(User $user): ServiceResultError | ServiceResultArray
+    {
+        if ($user->cannot('create', User::class)) {
+            return $this->errFobidden(__('Access is denied'));
+        }
+
+        return $this->result([
+            'user' => new User(),
+            'roles' => $this->roleRepository->getRolesForSelect(),
+            'userRoles' => [],
+        ]);
+    }
+
+    public function edit(int $id, User $user): ServiceResultError | ServiceResultArray
+    {
+        $modelUser = $this->userRepository->getUserById($id);
+
+        if (is_null($modelUser)) {
+            return $this->errNotFound(__('Not Found'));
+        }
+
+        if ($user->cannot('view', $modelUser)) {
+            return $this->errFobidden(__('Access is denied'));
+        }
+
+        $userRoles = $modelUser->roles()->withTrashed()->pluck('id')->toArray();
+        return $this->result([
+            'user' => $modelUser,
+            'roles' => $this->roleRepository->getRolesForSelect($userRoles),
+            'userRoles' => $userRoles,
+        ]);
+    }
+
+    public function store(StoreUpdate $data, User $user): ServiceResultError | StoreUpdateResult
+    {
+        if ($user->cannot('create', User::class)) {
+            return $this->errFobidden(__('Access is denied'));
+        }
+
+        if ($this->userRepository->isExistsEmail($data->getEmail())) {
+            return $this->errValidate(
+                __('validation.unique', ['attribute' => __('validation.attributes.email')]),
+                ['code' => __('validation.unique', ['attribute' => __('validation.attributes.email')])]
+            );
+        }
+
+        try {
+            $modelUser = DB::transaction(function () use ($data) {
+                $dataUser = $this->getDataUser($data);
+
+                $modelUser = $this->userCommandHandler->handleStore($dataUser, $data->getPassword());
+                $this->userCommandHandler->handleConfirmationByEmail($modelUser);
+                $this->userCommandHandler->handleSyncRoles($modelUser, $data->getRoles());
+
+                return $modelUser;
+            });
+        } catch (\Throwable $e) {
+            report($e);
+            return $this->errService(__('Server Error'));
+        }
+
+        return $this->resultStoreUpdateModel($modelUser, __('The user was successfully created'));
+    }
+
+    public function update(int $id, StoreUpdate $data, User $user): ServiceResultError | StoreUpdateResult
+    {
+        $modelUser = $this->userRepository->getUserById($id);
+
+        if (is_null($modelUser)) {
+            return $this->errNotFound(__('Not Found'));
+        }
+
+        if ($user->cannot('update', $modelUser)) {
+            return $this->errFobidden(__('Access is denied'));
+        }
+
+        if ($this->userRepository->isExistsEmail($data->getEmail(), $modelUser->id)) {
+            return $this->errValidate(
+                __('validation.unique', ['attribute' => __('validation.attributes.email')]),
+                ['code' => __('validation.unique', ['attribute' => __('validation.attributes.email')])]
+            );
+        }
+
+        try {
+            $modelUser = DB::transaction(function () use ($data, $modelUser) {
+                $dataUser = $this->getDataUser($data);
+
+                $modelUser = $this->userCommandHandler->handleUpdate($modelUser, $dataUser);
+                $this->userCommandHandler->handleSyncRoles($modelUser, $data->getRoles());
+
+                return $modelUser;
+            });
+        } catch (\Throwable $e) {
+            report($e);
+            return $this->errService(__('Server Error'));
+        }
+
+        return $this->resultStoreUpdateModel($modelUser, __('The user was successfully updated'));
+    }
+
+    public function updatePassword(int $id, UpdatePassword $data, User $user): ServiceResultError | StoreUpdateResult
+    {
+        $modelUser = $this->userRepository->getUserById($id);
+
+        if (is_null($modelUser)) {
+            return $this->errNotFound(__('Not Found'));
+        }
+
+        if ($user->cannot('update', $modelUser)) {
+            return $this->errFobidden(__('Access is denied'));
+        }
+
+        try {
+            $this->userCommandHandler->handleUpdatePassword($modelUser, $data->getPassword());
+        } catch (\Throwable $e) {
+            report($e->getMessage());
+            return $this->errService($e->getMessage());
+        }
+
+        return $this->resultStoreUpdateModel($modelUser, __('The password has been changed'));
+    }
+
+    public function destroy(int $id, User $user): ServiceResultError | ServiceResultSuccess
+    {
+        $modelUser = $this->userRepository->getUserById($id);
+
+        if (is_null($modelUser)) {
+            return $this->errNotFound(__('Not Found'));
+        }
+
+        if ($user->cannot('delete', $modelUser)) {
+            return $this->errFobidden(__('Access is denied'));
+        }
+
+        try {
+            DB::transaction(function () use ($modelUser) {
+                $this->userCommandHandler->handleDestroy($modelUser);
+            });
+        } catch (\Throwable $e) {
+            report($e);
+            return $this->errService(__('Server Error'));
+        }
+
+        return $this->ok(__('The user has been deleted'));
+    }
+
+    private function getDataUser(StoreUpdate $data): array
+    {
+        return [
+            'is_active' => $data->isActive(),
+            'name' => $data->getName(),
+            'email' => $data->getEmail(),
+        ];
+    }
+}

app/Services/User/BuilderCommand.php

@@ -0,0 +1,15 @@
+<?php declare(strict_types=1);
+
+namespace App\Services\User;
+
+use App\Dto\Builder\User as UserBuilderDto;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Relations\Relation;
+
+final readonly class BuilderCommand
+{
+    public function execute(Relation | Builder $query, UserBuilderDto $userBuilderDto): Relation | Builder
+    {
+        return $query;
+    }
+}

app/Services/User/UserCommandHandler.php

@@ -54,4 +54,9 @@ final readonly class UserCommandHandler
     {
         return Hash::make($password);
     }
+
+    public function handleDestroy(User $user): void
+    {
+        $user->delete();
+    }
 }

app/View/Components/Private/Forms/Checkbox.php

@@ -0,0 +1,57 @@
+<?php declare(strict_types=1);
+
+namespace App\View\Components\Private\Forms;
+
+use Illuminate\Support\Str;
+use Illuminate\View\View;
+
+final class Checkbox extends Form
+{
+    public function __construct(
+        private readonly string $title,
+        private readonly string $name,
+        private readonly string $checkboxValue,
+        private readonly ?string $userValue = '',
+        private readonly ?string $notCheckedValue = null
+    ) { }
+
+    protected function getName(): string
+    {
+        return $this->name;
+    }
+
+    private function getTitle(): string
+    {
+        return Str::ucfirst($this->title);
+    }
+
+    private function getCheckboxValue(): string
+    {
+        return (string) old($this->getRequestName(), $this->checkboxValue);
+    }
+
+    public function getUserValue(): string
+    {
+        return (string) $this->userValue;
+    }
+
+    public function getNotCheckedValue(): ?string
+    {
+        return $this->notCheckedValue;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function render(): View
+    {
+        return view('private.components.forms.checkbox', [
+            'title' => $this->getTitle(),
+            'name' => $this->getName(),
+            'requestName' => $this->getRequestName(),
+            'checkboxValue' => $this->getCheckboxValue(),
+            'userValue' => $this->getUserValue(),
+            'notCheckedValue' => $this->getNotCheckedValue(),
+        ]);
+    }
+}

app/View/Components/Private/Forms/MultiCheckbox.php

@@ -0,0 +1,53 @@
+<?php declare(strict_types=1);
+
+namespace App\View\Components\Private\Forms;
+
+use Illuminate\Support\Str;
+use Illuminate\View\View;
+
+final class MultiCheckbox extends Form
+{
+    /**
+     * @param string $title
+     * @param string $name
+     * @param array $list = [ [key => value], ... ]
+     * @param array $value
+     */
+    public function __construct(
+        private readonly string $title,
+        private readonly string $name,
+        private readonly array $list,
+        private readonly array $value = []
+    ) { }
+
+    protected function getName(): string
+    {
+        return $this->name;
+    }
+
+    private function getTitle(): string
+    {
+        return Str::ucfirst($this->title);
+    }
+
+    private function getValue(): array
+    {
+        return old($this->getRequestName(), $this->value);
+    }
+
+    private function getList(): array
+    {
+        return $this->list;
+    }
+
+    public function render(): View
+    {
+        return view('private.components.forms.multi_checkbox', [
+            'title' => $this->getTitle(),
+            'name' => $this->getName(),
+            'requestName' => $this->getRequestName(),
+            'list' => $this->getList(),
+            'value' => $this->getValue()
+        ]);
+    }
+}