add authorization to all fib services

Reviewed-on: #28

.gitignore

@@ -1,2 +1,3 @@
 .idea
-.env
+.env
+front

backend/.env.example

@@ -63,3 +63,15 @@ AWS_BUCKET=
 AWS_USE_PATH_STYLE_ENDPOINT=false
 
 VITE_APP_NAME="${APP_NAME}"
+
+FIB_AUTHORIZATION_URL=
+FIB_CLIENT_ID=
+FIB_CLIENT_SECRET=
+
+FIB_CREATE_PAYMENT_URL
+
+FIB_CHECK_PAYMENT_STATUS_URL
+
+FIB_CANCEL_PAYMENT_URL
+
+FIB_REFUND_URL

backend/Dockerfile

@@ -21,7 +21,7 @@ WORKDIR /var/www/payment
 
 COPY . .
 
-RUN chmod -R 665 /var/www/payment/storage /var/www/payment/bootstrap/cache
+RUN chmod -R 775 /var/www/payment/storage /var/www/payment/bootstrap/cache
 
 # Install Composer
 COPY --from=composer:latest /usr/bin/composer /usr/bin/composer
@@ -30,7 +30,6 @@ ENV COMPOSER_ALLOW_SUPERUSER=1
 # Default command
 CMD composer install ;\
     composer dump-autoload --optimize --classmap-authoritative ;\
-    php artisan key:generate ;\
     php artisan migrate ;\
     php artisan db:seed ;\
     php-fpm

backend/app/Admin/Controllers/AuthController.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace App\Admin\Controllers;
+
+use App\Admin\Requests\Auth\LoginRequest;
+use App\Admin\Requests\Auth\RegisterRequest;
+use App\Http\Controllers\Controller;
+use App\Models\Expert;
+use App\Traits\ApiResponse;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\Hash;
+
+class AuthController extends Controller
+{
+    use ApiResponse;
+
+    public function login(LoginRequest $request): JsonResponse
+    {
+        $credentials = ['password' => $request->password];
+
+        if (filter_var($request->login, FILTER_VALIDATE_EMAIL)) {
+            $credentials['email'] = $request->login;
+        } else {
+            $credentials['username'] = $request->login;
+        }
+
+        if (Auth::guard('expert')->attempt($credentials)) {
+            $request->session()->regenerate();
+
+            return $this->successResponse();
+        }
+
+        return $this->errorResponse(__('messages.incorrect_or_username_password'));
+    }
+
+    public function logout(Request $request): JsonResponse
+    {
+        Auth::guard('expert')->logout();
+
+        $request->session()->invalidate();
+
+        $request->session()->regenerateToken();
+
+        return $this->successResponse();
+    }
+}

backend/app/Admin/Controllers/DocumentationController.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace App\Admin\Controllers;
+
+use App\Admin\Requests\Documentation\RejectRequest;
+use App\Facades\DataTable\DataTableFacade;
+use App\Http\Controllers\Controller;
+use App\Models\User;
+use App\Traits\ApiResponse;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class DocumentationController extends Controller
+{
+    use ApiResponse;
+
+    public function index(Request $request): array
+    {
+        return DataTableFacade::run(
+            User::query(),
+            $request,
+            allowedFilters: ['*'],
+            allowedSortings: ['*'],
+            allowedSelects: [
+                'id', 'first_name', 'last_name', 'national_id',
+                'phone_number', 'postal_code', 'city_id', 'province_id',
+                'province_name', 'city_name', 'address'
+            ]
+        );
+    }
+
+    public function files(User $user): JsonResponse
+    {
+        return $this->successResponse($user->load('documents'));
+    }
+
+    public function confirm(User $user): JsonResponse
+    {
+        $user->update([
+            'authority_level' => 1
+        ]);
+
+        return $this->successResponse();
+    }
+
+    public function reject(RejectRequest $request, User $user): JsonResponse
+    {
+        $user->update([
+            'kyc_status' => 0,
+            'kyc_reject_reason' => $request->kyc_reject_reason
+        ]);
+
+        return $this->successResponse();
+    }
+}

backend/app/Admin/Controllers/ExpertManagementController.php

@@ -0,0 +1,112 @@
+<?php
+
+namespace App\Admin\Controllers;
+
+use App\Admin\Requests\ExpertManagement\StoreRequest;
+use App\Admin\Requests\ExpertManagement\UpdateRequest;
+use App\Facades\DataTable\DataTableFacade;
+use App\Http\Controllers\Controller;
+use App\Models\City;
+use App\Models\Expert;
+use App\Models\Province;
+use App\Traits\ApiResponse;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Hash;
+use Throwable;
+
+class ExpertManagementController extends Controller
+{
+    use ApiResponse;
+
+    /**
+     * Display a listing of the resource.
+     */
+    public function index(Request $request): JsonResponse
+    {
+        $data = DataTableFacade::run(
+            Expert::query(),
+            $request,
+            allowedFilters: ['*'],
+            allowedSortings: ['*'],
+            allowedSelects: ['id', 'username', 'first_name', 'last_name', 'phone_number', 'email', 'national_id'],
+        );
+
+        return response()->json($data);
+    }
+
+    /**
+     * Store a newly created resource in storage.
+     */
+    public function store(StoreRequest $request): JsonResponse
+    {
+        $province = Province::query()->find($request->province_id);
+        $city = City::query()->find($request->city_id);
+
+        Expert::query()->create([
+            'username' => $request->username,
+            'first_name' => $request->first_name,
+            'last_name' => $request->last_name,
+            'national_id' => $request->national_id,
+            'password' => Hash::make($request->password),
+            'email' => $request->email,
+            'phone_number' => $request->phone_number,
+            'province_id' => $request->province_id,
+            'province_name' => $province->name,
+            'city_id' => $request->city_id,
+            'city_name' => $city->name,
+        ]);
+
+        return $this->successResponse();
+    }
+
+    /**
+     * Display the specified resource.
+     */
+    public function show(Expert $expert): JsonResponse
+    {
+        return $this->successResponse($expert->load(['roles','permissions'])
+        );
+    }
+
+    /**
+     * Update the specified resource in storage.
+     */
+    public function update(UpdateRequest $request, Expert $expert): JsonResponse
+    {
+        $province = Province::query()->find($request->province_id);
+        $city = City::query()->find($request->city_id);
+
+        $expert->update([
+            'username' => $request->username,
+            'first_name' => $request->first_name,
+            'last_name' => $request->last_name,
+            'national_id' => $request->national_id,
+            'password' => Hash::make($request->password),
+            'email' => $request->email,
+            'phone_number' => $request->phone_number,
+            'province_id' => $request->province_id,
+            'province_name' => $province->name,
+            'city_id' => $request->city_id,
+            'city_name' => $city->name,
+        ]);
+
+        return $this->successResponse();
+    }
+
+    /**
+     * Remove the specified resource from storage.
+     * @throws Throwable
+     */
+    public function destroy(Expert $expert): JsonResponse
+    {
+        DB::transaction(function () use ($expert) {
+            $expert->roles()->detach();
+            $expert->permissions()->detach();
+            $expert->delete();
+        });
+
+        return $this->successResponse();
+    }
+}

backend/app/Admin/Controllers/PermissionManagementController.php

@@ -0,0 +1,78 @@
+<?php
+
+namespace App\Admin\Controllers;
+
+use App\Admin\Requests\PermissionManagement\StoreRequest;
+use App\Admin\Requests\PermissionManagement\UpdateRequest;
+use App\Facades\DataTable\DataTableFacade;
+use App\Http\Controllers\Controller;
+use App\Traits\ApiResponse;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Spatie\Permission\Models\Permission;
+
+class PermissionManagementController extends Controller
+{
+    /**
+     * Display a listing of the resource.
+     */
+    use ApiResponse;
+
+    /**
+     * Display a listing of the resource.
+     */
+    public function index(Request $request): JsonResponse
+    {
+        return response()->json(
+            DataTableFacade::run(
+                Permission::query(),
+                $request,
+                allowedFilters: ['*'],
+                allowedSortings: ['*']
+            )
+        );
+    }
+
+    /**
+     * Store a newly created resource in storage.
+     */
+    public function store(StoreRequest $request): JsonResponse
+    {
+        Permission::create([
+            'name' => $request->name,
+            'guard_name' => 'web',
+        ]);
+
+        return $this->successResponse();
+    }
+
+    /**
+     * Display the specified resource.
+     */
+    public function show(Permission $permission): JsonResponse
+    {
+        return $this->successResponse($permission);
+    }
+
+    /**
+     * Update the specified resource in storage.
+     */
+    public function update(UpdateRequest $request, Permission $permission): JsonResponse
+    {
+        $permission->update([
+            'name' => $request->name,
+        ]);
+
+        return $this->successResponse();
+    }
+
+    /**
+     * Remove the specified resource from storage.
+     */
+    public function destroy(Permission $permission): JsonResponse
+    {
+        $permission->delete();
+
+        return $this->successResponse();
+    }
+}

backend/app/Admin/Controllers/ProfileController.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace App\Admin\Controllers;
+
+use App\Admin\Requests\Profile\ChangePasswordRequest;
+use App\Admin\Requests\Profile\EditRequest;
+use App\Admin\Resources\ExpertResource;
+use App\Http\Controllers\Controller;
+use App\Traits\ApiResponse;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\Hash;
+
+class ProfileController extends Controller
+{
+    use ApiResponse;
+
+    public function info(): JsonResponse
+    {
+        return $this->successResponse(new ExpertResource(Auth::guard('expert')->user()));
+    }
+
+    public function edit(EditRequest $request): JsonResponse
+    {
+        $expert = $request->user('expert');
+
+        $expert->update([
+            'username' => $request->username,
+            'first_name' => $request->first_name,
+            'last_name' => $request->last_name,
+            'email' => $expert->email,
+            'national_id' => $request->national_id,
+            'phone_number' => $request->phone_number,
+            'province_id' => $request->province_id,
+            'city_id' => $request->city_id,
+        ]);
+
+        return $this->successResponse();
+    }
+
+    public function changePassword(ChangePasswordRequest $request): JsonResponse
+    {
+        $expert = Auth::guard('expert')->user();
+
+        if (! Hash::check($request->current_password, $expert->password))
+        {
+            return $this->errorResponse(__('messages.incorrect_current_password'));
+        }
+
+        $expert->update([
+            'password' => Hash::make($request->new_password)
+        ]);
+
+        return $this->successResponse();
+    }
+}

backend/app/Admin/Controllers/RoleManagementController.php

@@ -0,0 +1,77 @@
+<?php
+
+namespace App\Admin\Controllers;
+
+use App\Admin\Requests\RoleManagement\StoreRequest;
+use App\Admin\Requests\RoleManagement\UpdateRequest;
+use App\Facades\DataTable\DataTableFacade;
+use App\Http\Controllers\Controller;
+use App\Traits\ApiResponse;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\DB;
+use Spatie\Permission\Models\Role;
+use Throwable;
+
+class RoleManagementController extends Controller
+{
+    use ApiResponse;
+
+    public function index(Request $request): JsonResponse
+    {
+        $data = DataTableFacade::run(
+            Role::query(),
+            $request,
+            allowedFilters: ['*'],
+            allowedSortings: ['*'],
+            allowedSelects: ['id', 'name']
+        );
+
+        return response()->json($data);
+    }
+
+    /**
+     * @throws Throwable
+     */
+    public function store(StoreRequest $request): JsonResponse
+    {
+        DB::transaction(function () use ($request) {
+            $role = Role::create([
+                'name' => $request->name,
+                'guard_name' => 'web',
+            ]);
+
+            $role->givePermissionTo($request->permissions);
+        });
+
+        return $this->successResponse();
+    }
+
+    /**
+     * @throws Throwable
+     */
+    public function update(UpdateRequest $request, Role $role): JsonResponse
+    {
+        DB::transaction(function () use ($request, $role) {
+            $role->update([
+                'name' => $request->name,
+                'guard_name' => 'web',
+            ]);
+
+            $role->syncPermissions($request->permissions);
+        });
+
+        return $this->successResponse();
+    }
+
+    public function show(Role $role): JsonResponse
+    {
+        return $this->successResponse($role);
+    }
+
+    public function destroy(Role $role): JsonResponse
+    {
+        $role->delete();
+        return $this->successResponse();
+    }
+}

backend/app/Admin/Controllers/UserManagementController.php

@@ -0,0 +1,113 @@
+<?php
+
+namespace App\Admin\Controllers;
+
+use App\Admin\Requests\UserManagement\StoreRequest;
+use App\Admin\Requests\UserManagement\UpdateRequest;
+use App\Facades\DataTable\DataTableFacade;
+use App\Http\Controllers\Controller;
+use App\Models\City;
+use App\Models\Province;
+use App\Models\User;
+use App\Traits\ApiResponse;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Hash;
+use Throwable;
+
+class UserManagementController extends Controller
+{
+    use ApiResponse;
+
+    public function index(Request $request): JsonResponse
+    {
+        $data = DataTableFacade::run(
+            User::query(),
+            $request,
+            allowedFilters: ['*'],
+            allowedSortings: ['*'],
+            allowedSelects: ['id', 'username','first_name', 'last_name','kyc_status','national_id',
+                'phone_number','postal_code','province_id','province_name', 'city_id', 'city_name',
+                'birth_date','tax_id', 'password', 'email'],
+        );
+
+        return response()->json($data);
+    }
+
+    /**
+     * Store a newly created resource in storage.
+     */
+    public function store(StoreRequest $request): JsonResponse
+    {
+        $province = Province::query()->find($request->province_id);
+        $city = City::query()->find($request->city_id);
+
+        User::query()->create([
+            'username' => $request->username,
+            'first_name' => $request->first_name,
+            'last_name' => $request->last_name,
+            'national_id' => $request->national_id,
+            'password' => Hash::make($request->password),
+            'email' => $request->email,
+            'birth_date' => $request->birth_date,
+            'phone_number' => $request->phone_number,
+            'postal_code' => $request->postal_code,
+            'address' => $request->address,
+            'province_id' => $request->province_id,
+            'province_name' => $province->name,
+            'city_id' => $request->city_id,
+            'city_name' => $city->name,
+        ]);
+
+        return $this->successResponse();
+    }
+
+
+    /**
+     * Display the specified resource.
+     */
+    public function show(User $user): JsonResponse
+    {
+        return $this->successResponse($user);
+
+    }
+
+    /**
+     * Update the specified resource in storage.
+     */
+    public function update(UpdateRequest $request, User $user): JsonResponse
+    {
+        $province = Province::query()->find($request->province_id);
+        $city = City::query()->find($request->city_id);
+
+        $user->update([
+            'first_name' => $request->first_name,
+            'username' => $request->username,
+            'last_name' => $request->last_name,
+            'national_id' => $request->national_id,
+            'password' => Hash::make($request->password),
+            'email' => $request->email,
+            'birth_date' => $request->birth_date,
+            'phone_number' => $request->phone_number,
+            'postal_code' => $request->postal_code,
+            'address' => $request->address,
+            'province_id' => $request->province_id,
+            'province_name' => $province->name,
+            'city_id' => $request->city_id,
+            'city_name' => $city->name,
+        ]);
+
+        return $this->successResponse();
+    }
+
+    /**
+     * Remove the specified resource from storage.
+     * @throws Throwable
+     */
+    public function destroy(User $user): JsonResponse
+    {
+        $user->delete();
+
+        return $this->successResponse();
+    }
+}

backend/app/Admin/Requests/Auth/LoginRequest.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace App\Admin\Requests\Auth;
+
+use Illuminate\Contracts\Validation\ValidationRule;
+use Illuminate\Foundation\Http\FormRequest;
+
+class LoginRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, ValidationRule|array|string>
+     */
+    public function rules(): array
+    {
+        return [
+            'login' => 'required|string',
+            'password' => 'required|string',
+        ];
+    }
+}

backend/app/Admin/Requests/Auth/RegisterRequest.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Admin\Requests\Auth;
+
+use Illuminate\Contracts\Validation\ValidationRule;
+use Illuminate\Foundation\Http\FormRequest;
+
+class RegisterRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, ValidationRule|array|string>
+     */
+    public function rules(): array
+    {
+        return [
+            'username' => 'required|unique:experts,username',
+            'email' => 'required|email|unique:experts,email',
+            'password' => 'required|string|regex:/^(?=.*[a-zA-Z])(?=.*\d).+$/|min:6|confirmed',
+        ];
+    }
+}

backend/app/Admin/Requests/Documentation/RejectRequest.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Admin\Requests\Documentation;
+
+use Illuminate\Contracts\Validation\ValidationRule;
+use Illuminate\Foundation\Http\FormRequest;
+
+class RejectRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, ValidationRule|array|string>
+     */
+    public function rules(): array
+    {
+        return [
+            'kyc_reject_reason' => 'required|string',
+        ];
+    }
+}

backend/app/Admin/Requests/ExpertManagement/StoreRequest.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace App\Admin\Requests\ExpertManagement;
+
+use Illuminate\Contracts\Validation\ValidationRule;
+use Illuminate\Foundation\Http\FormRequest;
+
+class StoreRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, ValidationRule|array|string>
+     */
+    public function rules(): array
+    {
+        return [
+            'username' => 'required|string|max:255|unique:experts,username',
+            'first_name' => 'required|string|max:255',
+            'last_name' => 'required|string|max:255',
+            'national_id' => 'required|string|max:20|unique:experts,national_id',
+            'password' => 'required|string|min:8|confirmed',
+            'email' => 'required|email|max:255|unique:experts,email',
+            'phone_number' => 'required|string|max:20|unique:experts,phone_number',
+            'province_id' => 'required|integer|exists:provinces,id',
+            'city_id' => 'required|integer|exists:cities,id',
+            ];
+    }
+}

backend/app/Admin/Requests/ExpertManagement/UpdateRequest.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace App\Admin\Requests\ExpertManagement;
+
+use Illuminate\Contracts\Validation\ValidationRule;
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Validation\Rule;
+
+/**
+ * @property mixed $expert
+ */
+class UpdateRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, ValidationRule|array|string>
+     */
+    public function rules(): array
+    {
+        return [
+            'username' => ['string', 'max:255',
+                Rule::unique('experts', 'username')->ignore($this->expert->id),],
+            'first_name' => 'string|max:255',
+            'last_name' => 'string|max:255',
+            'national_id' => ['string', 'max:20',
+                Rule::unique('experts', 'national_id')->ignore($this->expert->id),],
+            'password' => 'string|min:8|confirmed',
+            'email' => ['email', 'max:255',
+                Rule::unique('experts', 'email')->ignore($this->expert->id),],
+            'phone_number' => ['string', 'max:20',
+                Rule::unique('experts', 'phone_number')->ignore($this->expert->id),],
+            'province_id' => 'required|integer|exists:provinces,id',
+            'city_id' => 'required|integer|exists:cities,id',
+        ];
+    }
+}

backend/app/Admin/Requests/PermissionManagement/StoreRequest.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Admin\Requests\PermissionManagement;
+
+use Illuminate\Contracts\Validation\ValidationRule;
+use Illuminate\Foundation\Http\FormRequest;
+
+class StoreRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, ValidationRule|array|string>
+     */
+    public function rules(): array
+    {
+        return [
+            'name' => 'required|string|unique:permissions,name',
+        ];
+    }
+}

backend/app/Admin/Requests/PermissionManagement/UpdateRequest.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace App\Admin\Requests\PermissionManagement;
+
+use Illuminate\Contracts\Validation\ValidationRule;
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Validation\Rule;
+
+/**
+ * @property mixed $permission
+ */
+class UpdateRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, ValidationRule|array|string>
+     */
+    public function rules(): array
+    {
+        return [
+            'name' => ['required', 'string', 'max:255', Rule::unique('permissions', 'name')->ignore($this->permission->id)],
+        ];
+    }
+}

backend/app/Admin/Requests/Profile/ChangePasswordRequest.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace App\Admin\Requests\Profile;
+
+use Illuminate\Contracts\Validation\ValidationRule;
+use Illuminate\Foundation\Http\FormRequest;
+
+class ChangePasswordRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, ValidationRule|array|string>
+     */
+    public function rules(): array
+    {
+        return [
+            'current_password' => 'required|string|regex:/^(?=.*[a-zA-Z])(?=.*\d).+$/|min:8',
+            'new_password' => 'required|string|regex:/^(?=.*[a-zA-Z])(?=.*\d).+$/|min:8',
+        ];
+    }
+}

backend/app/Admin/Requests/Profile/EditRequest.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Admin\Requests\Profile;
+
+use Illuminate\Contracts\Validation\ValidationRule;
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Validation\Rule;
+use Illuminate\Validation\Validator;
+
+class EditRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, ValidationRule|array|string>
+     */
+    public function rules(): array
+    {
+        return [
+            'username' => 'string|max:255',
+            'first_name' => 'required|string',
+            'last_name' => 'required|string',
+            'national_id' => 'required',
+            'email' => 'string|email|max:255',
+            'phone_number' => 'string',
+            'province_id' => 'string',
+            'city_id' => 'string',
+        ];
+    }
+}

backend/app/Admin/Requests/RoleManagement/StoreRequest.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Admin\Requests\RoleManagement;
+
+use Illuminate\Contracts\Validation\ValidationRule;
+use Illuminate\Foundation\Http\FormRequest;
+
+class StoreRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, ValidationRule|array|string>
+     */
+    public function rules(): array
+    {
+        return [
+            'name' => 'required|string|unique:roles,name',
+            'permissions' => 'array',
+            'permissions.*' => 'integer|exists:permissions,id',
+        ];
+    }
+}

backend/app/Admin/Requests/RoleManagement/UpdateRequest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace App\Admin\Requests\RoleManagement;
+
+use Illuminate\Contracts\Validation\ValidationRule;
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Validation\Rule;
+
+/**
+ * @property mixed $role
+ */
+class UpdateRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, ValidationRule|array|string>
+     */
+    public function rules(): array
+    {
+        return [
+            'name' => ['string', 'max:255', Rule::unique('roles', 'name')->ignore($this->role->id)],
+            'permissions' => 'array',
+            'permissions.*' => 'integer|exists:permissions,id',
+        ];
+    }
+}

backend/app/Admin/Requests/UserManagement/StoreRequest.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace App\Admin\Requests\UserManagement;
+
+use Illuminate\Contracts\Validation\ValidationRule;
+use Illuminate\Foundation\Http\FormRequest;
+
+class StoreRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, ValidationRule|array|string>
+     */
+    public function rules(): array
+    {
+        return [
+            'username' => 'required|string|max:255|unique:users,username',
+            'first_name' => 'required|string|max:255',
+            'last_name' => 'required|string|max:255',
+            'national_id' => 'required|string|max:20|unique:users,national_id',
+            'password' => 'required|string|min:6|confirmed',
+            'email' => 'required|email|max:255|unique:users,email',
+            'birth_date' => 'nullable|date',
+            'phone_number' => 'required|string|max:20|unique:users,phone_number',
+            'postal_code' => 'nullable|string|max:20',
+            'address' => 'nullable|string|max:1000',
+            'province_id' => 'required|integer|exists:provinces,id',
+            'city_id' => 'required|integer|exists:cities,id',
+        ];
+    }
+}

backend/app/Admin/Requests/UserManagement/UpdateRequest.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace App\Admin\Requests\UserManagement;
+
+use Illuminate\Contracts\Validation\ValidationRule;
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Validation\Rule;
+
+/**
+ * @property mixed $user
+ */
+class UpdateRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, ValidationRule|array|string>
+     */
+    public function rules(): array
+    {
+
+        return [
+            'username' => ['string', 'max:255',
+            Rule::unique('users', 'username')->ignore($this->user->id),],
+            'first_name' => 'string|max:255',
+            'last_name' => 'string|max:255',
+            'national_id' => ['string', 'max:20',
+                Rule::unique('users', 'national_id')->ignore($this->user->id),],
+            'password' => 'string|min:8|confirmed',
+            'email' => ['email', 'max:255',
+                Rule::unique('users', 'email')->ignore($this->user->id),],
+            'birth_date' => 'nullable|date',
+            'phone_number' => ['string', 'max:20',
+                Rule::unique('users', 'phone_number')->ignore($this->user->id),],
+            'postal_code' => 'nullable|string|max:20',
+            'address' => 'nullable|string|max:1000',
+            'province_id' => 'integer|exists:provinces,id',
+            'city_id' => 'integer|exists:cities,id',
+        ];
+    }
+}

backend/app/Admin/Resources/ExpertResource.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Admin\Resources;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class ExpertResource extends JsonResource
+{
+    /**
+     * Transform the resource into an array.
+     *
+     * @return array<string, mixed>
+     */
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => $this->id,
+            'username' => $this->username,
+            'email' => $this->email,
+        ];
+    }
+}
+

backend/app/Enums/BusinessTypeEnum.php

@@ -0,0 +1,66 @@
+<?php
+
+namespace App\Enums;
+
+enum BusinessTypeEnum: int
+{
+    case MEDICAL = 1;
+    case LEGAL = 2;
+    case ENGINEERING = 3;
+    case EDUCATION = 4;
+    case CONSULTING = 5;
+    case BEAUTY = 6;
+    case TECHNICAL_SERVICES = 7;
+    case FINANCIAL = 8;
+    case REAL_ESTATE = 9;
+    case RESTAURANT = 10;
+    case SHOP = 11;
+    case TRANSPORTATION = 12;
+    case ART = 13;
+    case SPORT = 14;
+    case OTHER = 15;
+
+    public function label(): string
+    {
+        return match ($this) {
+            self::MEDICAL => 'medical',
+            self::LEGAL => 'legal',
+            self::ENGINEERING => 'engineering',
+            self::EDUCATION => 'education',
+            self::CONSULTING => 'consulting',
+            self::BEAUTY => 'beauty',
+            self::TECHNICAL_SERVICES => 'technical_services',
+            self::FINANCIAL => 'financial',
+            self::REAL_ESTATE => 'real_estate',
+            self::RESTAURANT => 'restaurant',
+            self::SHOP => 'shop',
+            self::TRANSPORTATION => 'transportation',
+            self::ART => 'art',
+            self::SPORT => 'sport',
+            self::OTHER => 'other',
+        };
+    }
+
+    public static function name($id): string
+    {
+        $mapArray = [
+            1 => 'medical',
+            2 => 'legal',
+            3 => 'engineering',
+            4 => 'education',
+            5 => 'consulting',
+            6 => 'beauty',
+            7 => 'technical_services',
+            8 => 'financial',
+            9 => 'real_estate',
+            10 => 'restaurant',
+            11 => 'shop',
+            12 => 'transportation',
+            13 => 'art',
+            14 => 'sport',
+            15 => 'other',
+        ];
+
+        return $mapArray[$id];
+    }
+}

backend/app/Enums/PaymentStatusEnum.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Enums;
+
+enum PaymentStatusEnum:int
+{
+    case Unpaid = 0;
+    case Cancelled = 1;
+    case Expired = 2;
+    case Paid = 3;
+    case Refunded = 4;
+
+    public function label(): string
+    {
+        return match ($this) {
+            self::Unpaid => 'unpaid',
+            self::Cancelled => 'cancelled',
+            self::Expired => 'expired',
+            self::Paid => 'paid',
+            self::Refunded => 'refunded',
+        };
+    }
+}

backend/app/Facades/DataTable/DataTable.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace App\Facades\DataTable;
+
+use App\Services\DataTable\DataTableInput;
+use App\Services\DataTable\DataTableService;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Contracts\Database\Query\Builder;
+use Illuminate\Http\Request;
+use App\Services\DataTable\Exceptions\InvalidParameterInterface;
+
+class DataTable
+{
+    /**
+     * Extracts data from request, passes to datatable service and prepares data for response.
+     * @param Model|Builder $mixed
+     * @param Request $request
+     * @param array $allowedFilters
+     * @param array $allowedRelations
+     * @param array $allowedSortings
+     * @param array $allowedSelects
+     * @return array
+     * @throws InvalidParameterInterface if input parameters are invalid.
+     */
+    public function run(
+        Model|Builder $mixed,
+        Request       $request,
+        array         $allowedFilters = [],
+        array         $allowedRelations = [],
+        array         $allowedSortings = [],
+        array         $allowedSelects = [],
+        array         $allowedGroupBy = []
+    ): array
+    {
+
+        $filters = json_decode($request->filters);
+        $sorting = json_decode($request->sorting);
+        $rels = $request->rels ?: array();
+
+        $dataTableInput = new DataTableInput(
+            $request->start,
+            $request->size,
+            $filters,
+            $sorting,
+            $rels,
+            $allowedFilters,
+            $allowedSortings,
+            $allowedGroupBy
+        );
+
+        $query = $this->makeQueryFromModel($mixed);
+
+        $dataTableService = (new DataTableService($query, $dataTableInput))
+            ->setAllowedFilters($allowedFilters)
+            ->setAllowedRelations($allowedRelations)
+            ->setAllowedSortings($allowedSortings)
+            ->setAllowedSelects($allowedSelects)
+            ->setAllowedGroupBy($allowedGroupBy);
+
+        return $dataTableService->getData();
+    }
+
+    protected function makeQueryFromModel(Model|Builder $mixed): Builder
+    {
+        return ($mixed instanceof Model) ? $mixed->query() : $mixed;
+    }
+}

backend/app/Facades/DataTable/DataTableFacade.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace App\Facades\DataTable;
+
+use Illuminate\Support\Facades\Facade;
+
+class DataTableFacade extends Facade
+{
+    protected static function getFacadeAccessor(): string
+    {
+        return DataTable::class;
+    }
+}

backend/app/Facades/File/File.php

@@ -0,0 +1,113 @@
+<?php
+
+namespace App\Facades\File;
+
+use Illuminate\Support\Facades\Storage;
+use Illuminate\Http\File as HttpFile;
+use Illuminate\Http\UploadedFile;
+use Illuminate\Support\Str;
+use InvalidArgumentException;
+
+class File
+{
+    public function save(HttpFile|UploadedFile $file, string $path, string $name = null, string $disk = 'public'): string
+    {
+        return Storage::disk($disk)->putFileAs(
+            $path,
+            $file,
+            $name ?? Str::uuid() . '.' . $file->extension()
+        );
+    }
+
+    /**
+     * @param string $filePath
+     * @param bool $url_is_absolute
+     * @param string $disk
+     * @return void
+     * @throws InvalidArgumentException when filePath is empty.
+     */
+    public function delete(string $filePath, bool $url_is_absolute = false, string $disk = 'public'): void
+    {
+        if (!$filePath){
+            throw new InvalidArgumentException('File path is invalid.');
+        }
+
+        if ($url_is_absolute) {
+            $needle = 'storage/';
+            $pos = strpos($filePath, $needle);
+            $filePath = substr($filePath, $pos + strlen($needle));
+        }
+
+        if (Storage::disk($disk)->exists($filePath)) {
+            Storage::disk($disk)->delete($filePath);
+        }
+    }
+
+    public function deleteContent($file_path): bool
+    {
+        if (file_exists($file_path)) {
+            file_put_contents($file_path, '');
+
+            return true;
+        }
+        return false;
+    }
+
+    public function tail($file_path, $lines = 100, $buffer = 2048): bool|string
+    {
+        // Open file
+        $file = @fopen($file_path, "rb");
+        if ($file === false) {
+            return false;
+        }
+
+        // Jump to last character
+        fseek($file, -1, SEEK_END);
+
+        // Read it and adjust line number if necessary
+        // (Otherwise the result would be wrong if file doesn't end with a blank line)
+        if (fread($file, 1) != "\n") {
+            $lines -= 1;
+        }
+
+        // Start reading
+        $output = '';
+        $chunk = '';
+
+        // While we would like more
+        while (ftell($file) > 0 && $lines >= 0) {
+
+            // Figure out how far back we should jump
+            $seek = min(ftell($file), $buffer);
+
+            // Do the jump (backwards, relative to where we are)
+            fseek($file, -$seek, SEEK_CUR);
+
+            // Read a chunk and prepend it to our output
+            $output = ($chunk = fread($file, $seek)) . $output;
+
+            // Jump back to where we started reading
+            fseek($file, -mb_strlen($chunk, '8bit'), SEEK_CUR);
+
+            // Decrease our line counter
+            $lines -= substr_count($chunk, "\n");
+        }
+
+        // While we have too many lines
+        // (Because of buffer size we might have read too many)
+        while ($lines++ < 0) {
+
+            // Find first newline and remove all text before that
+            $output = substr($output, strpos($output, "\n") + 1);
+        }
+
+        // Close file and return
+        fclose($file);
+        return trim($output);
+    }
+
+    public function deleteDirectory(string $path, string $disk = 'public'): void
+    {
+        Storage::disk($disk)->deleteDirectory($path);
+    }
+}

backend/app/Facades/File/FileFacade.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace App\Facades\File;
+
+use Illuminate\Support\Facades\Facade;
+
+class FileFacade extends Facade
+{
+    protected static function getFacadeAccessor(): string
+    {
+        return File::class;
+    }
+}

backend/app/Mail/LoginNotificationMail.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace App\Mail;
+
+use App\Models\User;
+use Illuminate\Bus\Queueable;
+use Illuminate\Mail\Mailable;
+use Illuminate\Mail\Mailables\Content;
+use Illuminate\Mail\Mailables\Envelope;
+use Illuminate\Queue\SerializesModels;
+
+class LoginNotificationMail extends Mailable
+{
+    use Queueable, SerializesModels;
+
+    public function __construct(
+        public User $user
+    ) {
+        //
+    }
+
+    public function envelope(): Envelope
+    {
+        return new Envelope(
+            subject: 'Login Notification Mail',
+        );
+    }
+
+    public function content(): Content
+    {
+        return new Content(
+            view: 'emails.login-notification',
+        );
+    }
+
+    public function attachments(): array
+    {
+        return [];
+    }
+}

backend/app/Models/BusinessType.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Models;
+
+use Database\Factories\BusinessTypeFactory;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+
+class BusinessType extends Model
+{
+    /** @use HasFactory<BusinessTypeFactory> */
+    use HasFactory;
+
+    protected $guarded = ['id'];
+}

backend/app/Models/City.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Models;
+
+use Database\Factories\CityFactory;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+
+class City extends Model
+{
+    /** @use HasFactory<CityFactory> */
+    use HasFactory;
+
+    protected $guarded = ['id'];
+}

backend/app/Models/Document.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace App\Models;
+
+use Database\Factories\DocumentFactory;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\MorphTo;
+use Illuminate\Database\Eloquent\Casts\Attribute;
+use Illuminate\Support\Facades\Storage;
+
+class Document extends Model
+{
+    /** @use HasFactory<DocumentFactory> */
+    use HasFactory;
+
+    protected $guarded = ['id'];
+
+    public function documentable(): MorphTo
+    {
+        return $this->morphTo();
+    }
+
+    protected function url(): Attribute
+    {
+        return Attribute::make(
+            get: fn($value) => Storage::disk('public')->url($value)
+        );
+    }
+}

backend/app/Models/Expert.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Models;
+
+use Database\Factories\ExpertFactory;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Notifications\Notifiable;
+use Illuminate\Foundation\Auth\User as Authenticatable;
+use Spatie\Permission\Traits\HasRoles;
+
+/**
+ * @method roles()
+ * @method permissions()
+ */
+class Expert extends Authenticatable
+{
+    /** @use HasFactory<ExpertFactory> */
+
+    use Notifiable,HasFactory,HasRoles;
+
+    protected $guarded = ['id'];
+    protected string $guard_name = 'web';
+}

backend/app/Models/FibTransaction.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+
+class FibTransaction extends Model
+{
+    /** @use HasFactory<\Database\Factories\FibTransactionFactory> */
+    use HasFactory;
+
+    protected $guarded = ['id'];
+}

backend/app/Models/FibTransactionStatus.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+
+class FibTransactionStatus extends Model
+{
+    /** @use HasFactory<\Database\Factories\FibTransactionStatusFactory> */
+    use HasFactory;
+}

backend/app/Models/Payment.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Models;
+
+use Database\Factories\PaymentFactory;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+
+class Payment extends Model
+{
+    /** @use HasFactory<PaymentFactory> */
+    use HasFactory;
+
+    protected $guarded = ['id'];
+}

backend/app/Models/PaymentStatus.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Models;
+
+use Database\Factories\PaymentStatusFactory;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+
+class PaymentStatus extends Model
+{
+    /** @use HasFactory<PaymentStatusFactory> */
+    use HasFactory;
+
+    protected $guarded = ['id'];
+}

backend/app/Models/Province.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Models;
+
+use Database\Factories\ProvinceFactory;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+
+class Province extends Model
+{
+    /** @use HasFactory<ProvinceFactory> */
+    use HasFactory;
+
+    protected $guarded = ['id'];
+}

backend/app/Models/Transaction.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Models;
+
+use Database\Factories\TransactionFactory;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+
+class Transaction extends Model
+{
+    /** @use HasFactory<TransactionFactory> */
+    use HasFactory;
+
+    protected $guarded = ['id'];
+}

backend/app/Models/User.php

@@ -4,30 +4,36 @@ namespace App\Models;
 
 // use Illuminate\Contracts\Auth\MustVerifyEmail;
 use Database\Factories\UserFactory;
-use Illuminate\Database\Eloquent\Attributes\Fillable;
+use Illuminate\Database\Eloquent\Attributes\Guarded;
 use Illuminate\Database\Eloquent\Attributes\Hidden;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Relations\MorphToMany;
 use Illuminate\Foundation\Auth\User as Authenticatable;
 use Illuminate\Notifications\Notifiable;
+use Illuminate\Support\Facades\Hash;
+use Laravel\Passport\Bridge\Client;
 use Laravel\Passport\HasApiTokens;
 
-#[Fillable(['name', 'email', 'password'])]
-#[Hidden(['password', 'remember_token'])]
+#[Guarded(['id'])]
+#[Hidden(['password'])]
 class User extends Authenticatable
 {
     /** @use HasFactory<UserFactory> */
     use HasFactory, Notifiable, HasApiTokens;
+    protected $guarded = ['id'];
 
-    /**
-     * Get the attributes that should be cast.
-     *
-     * @return array<string, string>
-     */
-    protected function casts(): array
+    public function documents(): MorphToMany
     {
-        return [
-            'email_verified_at' => 'datetime',
-            'password' => 'hashed',
-        ];
+        return $this->morphToMany(Document::class, 'documentable');
+    }
+
+    public function validateForPassportPasswordGrant(string $password): bool
+    {
+        return Hash::check($password, $this->password);
+    }
+
+    public function findForPassport(string $username, Client $client): User
+    {
+        return $this->where('username', $username)->first();
     }
 }

backend/app/Models/UserGateway.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Models;
+
+use Database\Factories\UserGatewayFactory;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+
+class UserGateway extends Model
+{
+    /** @use HasFactory<UserGatewayFactory> */
+    use HasFactory;
+
+    protected $guarded = ['id'];
+}

backend/app/Providers/AppServiceProvider.php

@@ -4,6 +4,7 @@ namespace App\Providers;
 
 use Illuminate\Support\ServiceProvider;
 use Laravel\Passport\Passport;
+use Carbon\CarbonInterval;
 
 class AppServiceProvider extends ServiceProvider
 {
@@ -21,5 +22,8 @@ class AppServiceProvider extends ServiceProvider
     public function boot(): void
     {
         Passport::enablePasswordGrant();
+        Passport::tokensExpireIn(CarbonInterval::minutes(1));
+        Passport::refreshTokensExpireIn(CarbonInterval::minutes(5));
+        Passport::personalAccessTokensExpireIn(CarbonInterval::minutes(1));
     }
 }

backend/app/Providers/DataTableServiceProvider.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace App\Providers;
+
+use App\Facades\DataTable\DataTable;
+use Illuminate\Support\ServiceProvider;
+
+class DataTableServiceProvider extends ServiceProvider
+{
+    /**
+     * Register services.
+     */
+    public function register(): void
+    {
+        $this->app->bind('datatable', function () {
+            return new DataTable();
+        });
+    }
+
+    /**
+     * Bootstrap services.
+     */
+    public function boot(): void
+    {
+        //
+    }
+}

backend/app/Providers/FileServiceProvider.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace App\Providers;
+
+use App\Facades\File\File;
+use Illuminate\Support\ServiceProvider;
+
+class FileServiceProvider extends ServiceProvider
+{
+    /**
+     * Register services.
+     */
+    public function register(): void
+    {
+        $this->app->bind('file', function () {
+            return new File();
+        });
+    }
+
+    /**
+     * Bootstrap services.
+     */
+    public function boot(): void
+    {
+        //
+    }
+}

backend/app/Services/DataTable/DataTableInput.php

@@ -0,0 +1,83 @@
+<?php
+
+namespace App\Services\DataTable;
+
+use App\Services\DataTable\Filter\Filter;
+use App\Services\DataTable\Sort\Sort;
+
+class DataTableInput
+{
+    /**
+     * @param int $start
+     * @param int $size
+     * @param array $filters
+     * @param array $sorting
+     * @param array $rels
+     */
+    public function __construct(
+        private ?int   $start,
+        private ?int   $size,
+        private array $filters,
+        private ?array $sorting,
+        private array $rels,
+        private array $allowedFilters,
+        private array $allowedSortings,
+        private ?array $GroupBy,
+    )
+    {
+    }
+
+    public function getStart(): ?int
+    {
+        return $this->start;
+    }
+
+    public function getSize(): ?int
+    {
+        return $this->size;
+    }
+
+    /**
+     * @return array returns an array of Filter objects
+     */
+    public function getFilters(): array
+    {
+        $filters = array();
+
+        foreach ($this->filters as $filter) {
+            $filters[] = new Filter(
+                $filter->id,
+                $filter->value,
+                $filter->fn,
+                $filter->datatype,
+                $this->allowedFilters
+            );
+        }
+
+        return $filters;
+    }
+
+    /**
+     * @return array
+     */
+    public function getSorting(): ?array
+    {
+        $sorts = [];
+        if (!empty($this->sorting)){
+            foreach ($this->sorting as $sort) {
+                $sorts[] =  new Sort($sort->id, $sort->desc, $this->allowedSortings);
+            }
+        }
+        return $sorts;
+    }
+
+    public function getRelations(): array
+    {
+        return $this->rels;
+    }
+
+    public function getGroupBy(): ?array
+    {
+        return $this->GroupBy;
+    }
+}

backend/app/Services/DataTable/DataTableService.php

@@ -0,0 +1,128 @@
+<?php
+
+namespace App\Services\DataTable;
+
+use App\Services\DataTable\Filter\ApplyFilter;
+use App\Services\DataTable\Sort\ApplySort;
+use Illuminate\Contracts\Database\Query\Builder;
+
+class DataTableService
+{
+
+    protected array $allowedFilters;
+    protected array $allowedRelations;
+    protected array $allowedSortings;
+    protected array $allowedSelects;
+    protected array $allowedGroupBy;
+    private int $totalRowCount;
+
+    public function __construct(
+        protected Builder      $query,
+        private DataTableInput $dataTableInput
+    )
+    {
+    }
+
+    public function setAllowedFilters(array $allowedFilters): DataTableService
+    {
+        $this->allowedFilters = $allowedFilters;
+        return $this;
+    }
+
+    public function setAllowedRelations(array $allowedRelations): DataTableService
+    {
+        $this->allowedRelations = $allowedRelations;
+        return $this;
+    }
+
+    public function setAllowedSortings(array $allowedSortings): DataTableService
+    {
+        $this->allowedSortings = $allowedSortings;
+        return $this;
+    }
+
+    public function setAllowedSelects(array $allowedSelects): DataTableService
+    {
+        $this->allowedSelects = $allowedSelects;
+        return $this;
+    }
+
+    public function setAllowedGroupBy(array $allowedGroupBy): DataTableService
+    {
+        $this->allowedGroupBy = $allowedGroupBy;
+        return $this;
+    }
+
+    /**
+     * Handle 'getData' operations
+     * @return array
+     */
+    public function getData(): array
+    {
+        $query = $this->buildQuery();
+        $data = $query->get();
+
+        return array(
+            'data' => $data,
+            'meta' => [
+                'totalRowCount' => $this->totalRowCount
+            ]
+        );
+    }
+
+    protected function buildQuery(): Builder
+    {
+        $query = $this->query;
+
+        foreach ($this->dataTableInput->getFilters() as $filter) {
+            $query = (new ApplyFilter($query, $filter))->apply();
+        }
+
+        $query = $this->applySelect($query, $this->allowedSelects);
+        $query = $this->includeRelationsInQuery($query, $this->allowedRelations);
+        $query = $this->applyGroupBy($query, $this->allowedGroupBy);
+
+        $this->totalRowCount = $query->count();
+
+        if (!is_null($this->dataTableInput->getStart())) {
+            $query->offset($this->dataTableInput->getStart());
+        }
+
+        if(!is_null($this->dataTableInput->getSize())){
+            $query->limit($this->dataTableInput->getSize());
+        }
+
+        $sorting = $this->dataTableInput->getSorting();
+        foreach ($sorting as $sort){
+            $query = (new ApplySort($query, $sort))->apply();
+        }
+
+        return $query;
+    }
+
+    protected function applySelect(Builder $query, array $selectedFields): Builder
+    {
+        if (!empty($selectedFields)) {
+            $query->select($selectedFields);
+        }
+
+        return $query;
+    }
+
+    protected function applyGroupBy(Builder $query, array $groupBy): Builder
+    {
+        return empty($groupBy) ? $query : $query->groupBy($groupBy);
+    }
+
+    protected function includeRelationsInQuery(Builder $query, array $rels): Builder
+    {
+        if (!empty($rels)) {
+            $query->with($rels);
+        }
+
+        return $query;
+    }
+
+    // (later) define mapping of relation names to prevent relation name expose.
+    // (later) define mapping of column names to prevent column name expose.
+}

backend/app/Services/DataTable/Enums/DataType.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Services\DataTable\Enums;
+
+enum DataType: string
+{
+    case NUMERIC = 'numeric';
+    case TEXT = 'text';
+    case DATE = 'date';
+
+    public static function values(): array
+    {
+       return array_column(self::cases(), 'value');
+    }
+}

backend/app/Services/DataTable/Enums/SearchType.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace App\Services\DataTable\Enums;
+
+enum SearchType: string
+{
+    case CONTAINS = 'contains';
+    case EQUALS = 'equals';
+    case NOT_EQUALS = 'notEquals';
+    case BETWEEN = 'between';
+    case GREATER_THAN = 'greaterThan';
+    case LESS_THAN = 'lessThan';
+    case FUZZY = 'fuzzy';
+
+    public static function values(): array
+    {
+       return array_column(self::cases(), 'value');
+    }
+}

backend/app/Services/DataTable/Exceptions/InvalidFilterException.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Services\DataTable\Exceptions;
+
+use Exception;
+
+class InvalidFilterException extends Exception implements InvalidParameterInterface
+{
+    protected $fieldName;
+
+    public function __construct($fieldName, $message = "", $code = 400, \Throwable $previous = null)
+    {
+        $this->fieldName = $fieldName;
+        parent::__construct($message, $code, $previous);
+    }
+
+    public function getFieldName()
+    {
+        return $this->fieldName;
+    }
+}

backend/app/Services/DataTable/Exceptions/InvalidParameterInterface.php

@@ -0,0 +1,7 @@
+<?php
+
+namespace App\Services\DataTable\Exceptions;
+
+interface InvalidParameterInterface
+{
+}

backend/app/Services/DataTable/Exceptions/InvalidRelationException.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Services\DataTable\Exceptions;
+
+use Exception;
+
+class InvalidRelationException extends Exception implements InvalidParameterInterface
+{
+    protected $fieldName;
+
+    public function __construct($fieldName, $message = "", $code = 400, \Throwable $previous = null)
+    {
+        $this->fieldName = $fieldName;
+        parent::__construct($message, $code, $previous);
+    }
+
+    public function getFieldName()
+    {
+        return $this->fieldName;
+    }
+}

backend/app/Services/DataTable/Exceptions/InvalidSortingException.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Services\DataTable\Exceptions;
+
+use Exception;
+
+class InvalidSortingException extends Exception implements InvalidParameterInterface
+{
+    protected $fieldName;
+
+    public function __construct($fieldName, $message = "", $code = 400, \Throwable $previous = null)
+    {
+        $this->fieldName = $fieldName;
+        parent::__construct($message, $code, $previous);
+    }
+
+    public function getFieldName()
+    {
+        return $this->fieldName;
+    }
+}

backend/app/Services/DataTable/Filter/ApplyFilter.php

@@ -0,0 +1,84 @@
+<?php
+
+namespace App\Services\DataTable\Filter;
+
+use App\Services\DataTable\Enums\SearchType;
+use App\Services\DataTable\Exceptions\InvalidFilterException;
+use App\Services\DataTable\Filter\SearchFunctions\FilterBetween;
+use App\Services\DataTable\Filter\SearchFunctions\FilterContains;
+use App\Services\DataTable\Filter\SearchFunctions\FilterEquals;
+use App\Services\DataTable\Filter\SearchFunctions\FilterGreaterThan;
+use App\Services\DataTable\Filter\SearchFunctions\FilterLessThan;
+use App\Services\DataTable\Filter\SearchFunctions\FilterNotEquals;
+use App\Services\DataTable\Filter\SearchFunctions\SearchFilter;
+use Illuminate\Contracts\Database\Query\Builder;
+
+class ApplyFilter
+{
+    private SearchFilter $searchFilter;
+
+    /**
+     * @param Builder $query
+     * @param Filter $filter
+     */
+    public function __construct(
+        private Builder $query,
+        private Filter  $filter,
+    )
+    {
+    }
+
+    public function apply(): Builder
+    {
+        $filter = $this->filter;
+        $query = $this->query;
+
+        $searchType = SearchType::from($filter->getFn());
+        switch ($searchType) {
+            case SearchType::CONTAINS:
+                $this->searchFilter = new FilterContains($query, $filter);
+                break;
+
+            case SearchType::EQUALS:
+                $this->searchFilter = new FilterEquals($query, $filter);
+                break;
+
+            case SearchType::NOT_EQUALS:
+                $this->searchFilter = new FilterNotEquals($query, $filter);
+                break;
+
+            case SearchType::BETWEEN:
+                $this->searchFilter = new FilterBetween($query, $filter);
+                break;
+
+            case SearchType::GREATER_THAN:
+                $this->searchFilter = new FilterGreaterThan($query, $filter);
+                break;
+
+            case SearchType::LESS_THAN:
+                $this->searchFilter = new FilterLessThan($query, $filter);
+                break;
+
+            default:
+                $searchFunction = $filter->getFn();
+                throw new InvalidFilterException($searchFunction, "search function `$searchFunction` is invalid.");
+
+        }
+
+        $relation = $this->filter->getRelation();
+        return method_exists($this->query->getModel(), $relation) ? $this->applyFilterToRelation($relation) : $this->searchFilter->apply();
+    }
+
+    protected function applyFilterToRelation(string $relation): Builder
+    {
+        return $this->query->whereHas($relation, function (Builder $query) {
+            $this->filter->removeRelationFromId();
+            $this->applyFilter($query, $this->filter);
+        });
+    }
+
+    private function applyFilter(Builder $query, Filter $filter): Builder
+    {
+        return (new ApplyFilter($query, $filter))->apply();
+    }
+}

backend/app/Services/DataTable/Filter/Filter.php

@@ -0,0 +1,73 @@
+<?php
+
+namespace App\Services\DataTable\Filter;
+
+use App\Services\DataTable\Validators\FilterValidator;
+
+class Filter
+{
+    private static FilterValidator $filterValidator;
+
+    /**
+     * @param string $id
+     * @param string|int|array $value
+     * @param string $fn
+     * @param string $datatype
+     * @param array $allowedFilters
+     * @throws \App\Services\DataTable\Exceptions\InvalidFilterException
+     */
+    public function __construct(
+        private string           $id,
+        private string|int|array $value,
+        private string           $fn,
+        private string           $datatype,
+        private array $allowedFilters
+    )
+    {
+        self::$filterValidator = FilterValidator::getInstance();
+        self::$filterValidator->isValid($this, $this->allowedFilters);
+    }
+
+    public function getId(): string
+    {
+        return $this->id;
+    }
+
+    public function getValue(): array|int|string
+    {
+        return $this->value;
+    }
+
+    public function getFn(): string
+    {
+        return $this->fn;
+    }
+
+    public function getDatatype(): string
+    {
+        return $this->datatype;
+    }
+
+    public function getRelation(): string
+    {
+        $fieldArray = explode('.', $this->id);
+        return count($fieldArray) > 1 ? $fieldArray[0] : '';
+    }
+
+    public function getColumn(): string
+    {
+        $fieldArray = explode('.', $this->id);
+        return array_pop($fieldArray);
+    }
+
+    public function removeRelationFromId(): void
+    {
+        $this->id = $this->getColumn();
+    }
+
+    public function setValue(int|array|string $value): void
+    {
+        $this->value = $value;
+    }
+
+}

backend/app/Services/DataTable/Filter/SearchFunctions/FilterBetween.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace App\Services\DataTable\Filter\SearchFunctions;
+
+use Illuminate\Contracts\Database\Query\Builder;
+
+class FilterBetween extends SearchFilter
+{
+
+    public function apply(): Builder
+    {
+        $query = $this->query;
+        [$minVal, $maxVal] = $this->filter->getValue();
+
+        if ($minVal) {
+            if ($this->filter->getDatatype() == "date") {
+                $minVal = $minVal . " 00:00:00";
+            }
+            $this->filter->setValue($minVal);
+            $query = (new FilterGreaterThanOrEqual($this->query, $this->filter))->apply();
+        }
+
+        if ($maxVal) {
+            if ($this->filter->getDatatype() == "date") {
+                $maxVal = $maxVal . " 23:59:59";
+            }
+            $this->filter->setValue($maxVal);
+            $query = (new FilterLessThanOrEqual($this->query, $this->filter))->apply();
+        }
+
+        return $query;
+    }
+}

backend/app/Services/DataTable/Filter/SearchFunctions/FilterContains.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Services\DataTable\Filter\SearchFunctions;
+
+use App\Services\DataTable\Enums\DataType;
+use Illuminate\Contracts\Database\Query\Builder;
+
+class FilterContains extends SearchFilter
+{
+
+    public function apply(): Builder
+    {
+        $column = $this->filter->getId();
+        $value = '%' . $this->filter->getValue() . '%';
+
+        if ($this->filter->getDatatype() == DataType::TEXT->value) {
+            $query = $this->searchIgnoreCase($column, $value);
+
+        } else {
+            $query = $this->query->where($column, 'LIKE', $value);
+        }
+
+        return $query;
+    }
+
+    private function searchIgnoreCase(string $column, string $value): Builder
+    {
+        $value = strtolower($value);
+        return $this->query->whereRaw("LOWER($column) LIKE ?", [$value]);
+    }
+}

backend/app/Services/DataTable/Filter/SearchFunctions/FilterEquals.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace App\Services\DataTable\Filter\SearchFunctions;
+
+use App\Services\DataTable\Enums\DataType;
+use Illuminate\Contracts\Database\Query\Builder;
+
+class FilterEquals extends SearchFilter
+{
+
+    public function apply(): Builder
+    {
+        $column = $this->filter->getId();
+        $value = $this->filter->getValue();
+
+        if ($this->filter->getDatatype() == DataType::TEXT->value) {
+            $query = $this->searchIgnoreCase($column, $value);
+        } else {
+            $query = $this->query->where($column, $value);
+        }
+
+        return $query;
+    }
+
+    private function searchIgnoreCase(string $column, string $value): Builder
+    {
+        $value = strtolower($value);
+        return $this->query->whereRaw("LOWER($column) = ?", [$value]);
+    }
+}

backend/app/Services/DataTable/Filter/SearchFunctions/FilterGreaterThan.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace App\Services\DataTable\Filter\SearchFunctions;
+
+use App\Services\DataTable\Enums\DataType;
+use Illuminate\Contracts\Database\Query\Builder;
+
+class FilterGreaterThan extends SearchFilter
+{
+
+    public function apply(): Builder
+    {
+        $value = ($this->filter->getDatatype() == DataType::NUMERIC) ?
+            (float)$this->filter->getValue() : $this->filter->getValue();
+
+        return $this->query->where($this->filter->getId(), '>', $value);
+    }
+}

backend/app/Services/DataTable/Filter/SearchFunctions/FilterGreaterThanOrEqual.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace App\Services\DataTable\Filter\SearchFunctions;
+
+use App\Services\DataTable\Enums\DataType;
+use Illuminate\Contracts\Database\Query\Builder;
+
+class FilterGreaterThanOrEqual extends SearchFilter
+{
+
+    public function apply(): Builder
+    {
+        $value = ($this->filter->getDatatype() == DataType::NUMERIC) ?
+            (float)$this->filter->getValue() : $this->filter->getValue();
+
+        return $this->query->where($this->filter->getId(), '>=', $value);
+    }
+}

backend/app/Services/DataTable/Filter/SearchFunctions/FilterLessThan.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace App\Services\DataTable\Filter\SearchFunctions;
+
+use App\Services\DataTable\Enums\DataType;
+use Illuminate\Contracts\Database\Query\Builder;
+
+class FilterLessThan extends SearchFilter
+{
+
+    public function apply(): Builder
+    {
+        $value = ($this->filter->getDatatype() == DataType::NUMERIC) ?
+            (float)$this->filter->getValue() : $this->filter->getValue();
+
+        return $this->query->where($this->filter->getId(), '<', $value);
+    }
+}

backend/app/Services/DataTable/Filter/SearchFunctions/FilterLessThanOrEqual.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace App\Services\DataTable\Filter\SearchFunctions;
+
+use App\Services\DataTable\Enums\DataType;
+use Illuminate\Contracts\Database\Query\Builder;
+
+class FilterLessThanOrEqual extends SearchFilter
+{
+
+    public function apply(): Builder
+    {
+        $value = ($this->filter->getDatatype() == DataType::NUMERIC) ?
+            (float)$this->filter->getValue() : $this->filter->getValue();
+
+        return $this->query->where($this->filter->getId(), '<=', $value);
+    }
+}

backend/app/Services/DataTable/Filter/SearchFunctions/FilterNotEquals.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Services\DataTable\Filter\SearchFunctions;
+
+use Illuminate\Contracts\Database\Query\Builder;
+
+class FilterNotEquals extends SearchFilter
+{
+
+    public function apply(): Builder
+    {
+        $column = $this->filter->getId();
+        $value = $this->filter->getValue();
+
+        return $this->query->whereNot($column, $value);
+    }
+}

backend/app/Services/DataTable/Filter/SearchFunctions/SearchFilter.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Services\DataTable\Filter\SearchFunctions;
+
+use App\Services\DataTable\Filter\Filter;
+use Illuminate\Contracts\Database\Query\Builder;
+
+abstract class SearchFilter
+{
+    /**
+     * @param Builder $query
+     * @param Filter $filter
+     */
+    public function __construct(
+        protected Builder $query,
+        protected Filter  $filter,
+    )
+    {
+    }
+
+    abstract public function apply(): Builder;
+}

backend/app/Services/DataTable/Sort/ApplySort.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Services\DataTable\Sort;
+
+use Illuminate\Contracts\Database\Query\Builder;
+
+class ApplySort
+{
+
+    /**
+     * @param Builder $query
+     * @param ?Sort $sort
+     */
+    public function __construct(
+        private Builder $query,
+        private ?Sort    $sort,
+    )
+    {
+    }
+
+    public function apply(): Builder
+    {
+        $query = $this->query;
+
+        if (!is_null($this->sort)) {
+            $query->orderBy($this->sort->getId(), $this->sort->getDirection());
+        }
+
+        return $query;
+    }
+}

backend/app/Services/DataTable/Sort/Sort.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace App\Services\DataTable\Sort;
+
+use App\Services\DataTable\Validators\SortingValidator;
+
+class Sort
+{
+    private static SortingValidator $sortingValidator;
+
+    /**
+     * @param string $id
+     * @param bool $desc
+     * @param array $allowedSortings
+     * @throws \App\Services\DataTable\Exceptions\InvalidSortingException
+     */
+    public function __construct(
+        private string $id,
+        private bool   $desc,
+        private array $allowedSortings,
+    )
+    {
+        self::$sortingValidator = SortingValidator::getInstance();
+        self::$sortingValidator->isValid($this, $this->allowedSortings);
+    }
+
+    /**
+     * @return string
+     */
+    public function getId(): string
+    {
+        return $this->id;
+    }
+
+    public function getDirection(): string
+    {
+        return $this->desc === true ? 'desc' : 'asc';
+    }
+}

backend/app/Services/DataTable/Validators/FilterValidator.php

@@ -0,0 +1,69 @@
+<?php
+
+namespace App\Services\DataTable\Validators;
+
+use App\Services\DataTable\Enums\SearchType;
+use App\Services\DataTable\Enums\DataType;
+use App\Services\DataTable\Exceptions\InvalidFilterException;
+use App\Services\DataTable\Filter\Filter;
+
+class FilterValidator
+{
+    private static $instance;
+
+    private function __construct()
+    {
+    }
+
+    public static function getInstance(): FilterValidator
+    {
+        if (!isset(self::$instance)) {
+            self::$instance = new static();
+        }
+
+        return self::$instance;
+    }
+
+    public function isValid(Filter $filter, array $allowedFilters): bool
+    {
+        if (!$this->isAllowed($filter, $allowedFilters)) {
+            $filterId = $filter->getId();
+            throw new InvalidFilterException($filter->getId(), "filtering field `$filterId` is not allowed.");
+        }
+
+        if (!$this->isValidSearchFunction($filter)) {
+            $searchFunction = $filter->getFn();
+            throw new InvalidFilterException($searchFunction, "search function `$searchFunction` is invalid.");
+        }
+
+        if ($this->isValidDataType($filter) == -1) {
+            throw new InvalidFilterException(null, "datatype property is not set in `filters` array.");
+        }
+
+        if (!$this->isValidDataType($filter)) {
+            $datatype = $filter->getDatatype();
+            throw new InvalidFilterException($datatype, "datatype `$datatype` is invalid.");
+        }
+
+        return true;
+    }
+
+    protected function isAllowed(Filter $filter, array $allowedFilters): bool
+    {
+        return $allowedFilters == ['*'] || in_array($filter->getId(), $allowedFilters);
+    }
+
+    protected function isValidSearchFunction(Filter $filter): bool
+    {
+        $searchFunction = $filter->getFn();
+        return isset($searchFunction) && in_array($searchFunction, SearchType::values());
+    }
+
+    protected function isValidDataType(Filter $filter): int
+    {
+        if (!property_exists($filter, 'datatype'))
+            return -1;
+
+        return $filter->getDatatype() && in_array($filter->getDatatype(), DataType::values()) ? 1 : 0;
+    }
+}

backend/app/Services/DataTable/Validators/RelationValidator.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace App\Services\DataTable\Validators;
+
+use App\Services\DataTable\Exceptions\InvalidRelationException;
+
+class RelationValidator
+{
+    public static function validate(?array $rels, array $allowedRelations): bool
+    {
+        foreach ($rels as $relation) {
+
+            if (!self::isAllowed($relation, $allowedRelations)) {
+                throw new InvalidRelationException($relation, "relation `$relation` is not allowed.");
+            }
+        }
+
+        return true;
+    }
+
+    public static function isAllowed(string $relation, array $allowedRelations): bool
+    {
+        return !$relation || in_array($relation, $allowedRelations);
+    }
+}

backend/app/Services/DataTable/Validators/SortingValidator.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace App\Services\DataTable\Validators;
+
+use App\Services\DataTable\Exceptions\InvalidSortingException;
+use App\Services\DataTable\Sort\Sort;
+
+class SortingValidator
+{
+    private static $instance;
+
+    private function __construct()
+    {
+    }
+
+    public static function getInstance(): SortingValidator
+    {
+        if (!isset(self::$instance)) {
+            self::$instance = new static();
+        }
+
+        return self::$instance;
+    }
+
+    public function isValid(Sort $sorting, array $allowedSortings): bool
+    {
+        if (!$this->isAllowed($sorting, $allowedSortings)) {
+            $sortId = $sorting->getId();
+            throw new InvalidSortingException($sortId, "sorting field `$sortId` is not allowed.");
+        }
+
+        return true;
+    }
+
+    protected function isAllowed(Sort $sorting, array $allowedSortings): bool
+    {
+        return $allowedSortings == ['*'] || in_array($sorting->getId(), $allowedSortings);
+    }
+}

backend/app/Services/FIB/AuthorizationService.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace App\Services\FIB;
+
+use Exception;
+use Illuminate\Http\Client\ConnectionException;
+use Illuminate\Support\Facades\Http;
+use Illuminate\Support\Facades\Log;
+
+class AuthorizationService
+{
+    protected string $url;
+    protected string $channelName;
+    protected array $inputParameters;
+
+    public function __construct()
+    {
+        $this->url = config('fib.authorization.url');
+        $this->channelName = 'fib_authorization';
+        $this->inputParameters = [
+            'client_id' => config('fib.authorization.client_id'),
+            'client_secret' => config('fib.authorization.client_secret'),
+            'grant_type' => 'client_credentials',
+        ];
+    }
+
+    /**
+     * @throws Exception
+     */
+    public function run(): array
+    {
+        try {
+            return $this->sendRequest();
+        }
+        catch (Exception $e) {
+            Log::channel($this->channelName)
+                ->error(get_class($this),
+                    [
+                        'message' => $e->getMessage(),
+                    ]
+                );
+
+            throw $e;
+        }
+    }
+
+    /**
+     * @throws ConnectionException
+     */
+    public function sendRequest(): array
+    {
+        return Http::asForm()
+            ->throw()
+            ->post($this->url, $this->inputParameters)
+            ->json();
+    }
+}

backend/app/Services/FIB/CancelPaymentService.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace App\Services\FIB;
+
+use Exception;
+use Illuminate\Http\Client\ConnectionException;
+use Illuminate\Support\Facades\Http;
+use Illuminate\Support\Facades\Log;
+
+class CancelPaymentService
+{
+    protected string $url;
+    protected string $channelName;
+    protected AuthorizationService $authorizationService;
+
+    public function __construct(AuthorizationService $authorizationService)
+    {
+        $this->url = config('fib.cancelPayment.url');
+        $this->channelName = '';
+        $this->authorizationService = $authorizationService;
+    }
+
+    /**
+     * @throws Exception
+     */
+    public function run(): array
+    {
+        try {
+            return $this->sendRequest();
+        }
+        catch (Exception $e) {
+            Log::channel($this->channelName)
+                ->error(get_class($this),
+                    [
+                        'message' => $e->getMessage(),
+                    ]
+                );
+
+            throw $e;
+        }
+    }
+
+    /**
+     * @throws ConnectionException
+     * @throws Exception
+     */
+    public function sendRequest(): array
+    {
+        return Http::withHeaders([
+            'Authorization' => 'Bearer ' . $this->getToken(),
+            'Content-Type' => 'application/json',
+            ])
+            ->throw()
+            ->withoutVerifying()
+            ->post($this->url)
+            ->json();
+    }
+
+    /**
+     * @throws Exception
+     */
+    public function getToken(): string
+    {
+        $data =  $this->authorizationService->run();
+        return $data['access_token'];
+    }
+}

backend/app/Services/FIB/CheckPaymentStatusService.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace App\Services\FIB;
+
+use Exception;
+use Illuminate\Http\Client\ConnectionException;
+use Illuminate\Support\Facades\Http;
+use Illuminate\Support\Facades\Log;
+
+class CheckPaymentStatusService
+{
+    protected string $url;
+    protected string $channelName;
+    protected AuthorizationService $authorizationService;
+
+    public function __construct(AuthorizationService $authorizationService)
+    {
+        $this->url = config('fib.checkPaymentStatus.url');
+        $this->channelName = 'fib_status';
+        $this->authorizationService = $authorizationService;
+    }
+
+    /**
+     * @throws Exception
+     */
+    public function run(): array
+    {
+        try {
+            return $this->sendRequest();
+        }
+        catch (Exception $e) {
+            Log::channel($this->channelName)
+                ->error(get_class($this),
+                    [
+                        'message' => $e->getMessage(),
+                    ]
+                );
+
+            throw $e;
+        }
+    }
+
+    /**
+     * @throws ConnectionException
+     * @throws Exception
+     */
+    public function sendRequest(): array
+    {
+        return Http::withHeaders([
+            'Authorization' => 'Bearer ' . $this->getToken(),
+            'Content-Type' => 'application/json',
+            ])
+            ->throw()
+            ->withoutVerifying()
+            ->post($this->url)
+            ->json();
+    }
+
+    /**
+     * @throws Exception
+     */
+    public function getToken(): string
+    {
+        $data =  $this->authorizationService->run();
+        return $data['access_token'];
+    }
+}

backend/app/Services/FIB/CreatePaymentService.php

@@ -0,0 +1,73 @@
+<?php
+
+namespace App\Services\FIB;
+
+use Exception;
+use Illuminate\Http\Client\ConnectionException;
+use Illuminate\Support\Facades\Http;
+use Illuminate\Support\Facades\Log;
+
+class CreatePaymentService
+{
+    protected string $url;
+    protected string $channelName;
+    protected array $inputParameters;
+    protected AuthorizationService $authorizationService;
+
+    public function __construct(AuthorizationService $authorizationService)
+    {
+        $this->url = config('fib.createPayment.url');
+        $this->channelName = 'fib_create_payment';
+        $this->authorizationService = $authorizationService;
+    }
+
+    public function setInputParameters(array $inputParameters): void
+    {
+        $this->inputParameters = $inputParameters;
+    }
+
+    /**
+     * @throws Exception
+     */
+    public function run(): array
+    {
+        try {
+            return $this->sendRequest();
+        }
+        catch (Exception $e) {
+            Log::channel($this->channelName)
+                ->error(get_class($this),
+                    [
+                        'message' => $e->getMessage(),
+                    ]
+                );
+
+            throw $e;
+        }
+    }
+
+    /**
+     * @throws ConnectionException
+     * @throws Exception
+     */
+    public function sendRequest(): array
+    {
+        return Http::withHeaders([
+            'Authorization' => 'Bearer ' . $this->getToken(),
+            'Content-Type' => 'application/json',
+            ])
+            ->throw()
+            ->withoutVerifying()
+            ->post($this->url, $this->inputParameters)
+            ->json();
+    }
+
+    /**
+     * @throws Exception
+     */
+    public function getToken(): string
+    {
+        $data =  $this->authorizationService->run();
+        return $data['access_token'];
+    }
+}

backend/app/Services/FIB/DTO/FIBPaymentCreateDTO.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Services\FIB\DTO;
+
+class FIBPaymentCreateDTO
+{
+    public string $paymentId;
+    public string $readableCode;
+    public string $qrCode;
+    public string $validUntil;
+    public string $personalAppLink;
+    public string $businessAppLink;
+    public string $corporateAppLink;
+
+    public function __construct(array $data)
+    {
+        $this->paymentId = $data['paymentId'];
+        $this->readableCode = $data['readableCode'];
+        $this->qrCode = $data['qrCode'];
+        $this->validUntil = $data['validUntil'];
+        $this->personalAppLink = $data['personalAppLink'];
+        $this->businessAppLink = $data['businessAppLink'];
+        $this->corporateAppLink = $data['corporateAppLink'];
+    }
+
+    public static function fromResponse($data): FIBPaymentCreateDTO
+    {
+        return new self([
+            'paymentId' => $data->paymentId,
+            'readableCode' => $data->readableCode,
+            'qrCode' => $data->qrCode,
+            'validUntil' => $data->validUntil,
+            'personalAppLink' => $data->personalAppLink,
+            'businessAppLink' => $data->businessAppLink,
+            'corporateAppLink' => $data->corporateAppLink,
+        ]);
+    }
+}

backend/app/Services/FIB/FIBClient.php

@@ -0,0 +1,86 @@
+<?php
+
+namespace App\Services\FIB;
+
+use Illuminate\Support\Facades\Http;
+
+class FIBClient
+{
+
+    public $auth_service;
+    public $create_payment_service;
+
+    public function __construct()
+    {
+    }
+
+    public function client()
+    {
+        return Http::acceptJson()
+            ->contentType('application/json')
+            ->withToken($this->getAccessToken())
+            ->timeout(30);
+    }
+
+    public function getAccessToken()
+    {
+        try {
+            if ($this->isNotProduction()) {
+                return json_decode(
+                    file_get_contents(storage_path('app/mock/fib/token.json'))
+                );
+            }
+            $response = Http::withOptions([
+                'proxy' => 'http://host.docker.internal:10808',
+            ])->asForm()->post('https://fib-stage.fib.iq/auth/realms/fib-online-shop/protocol/openid-connect/token', [
+                'grant_type' => 'client_credentials',
+                'client_id' => 'ipay-test-payment',
+                'client_secret' => '8dae3180-f39c-448e-8b45-a01c8f4c8c15',
+            ]);
+
+            if ($response->failed()) {
+                throw new \Exception(
+                    'Unable to authenticate with FIB: ' .
+                    $response->body()
+                );
+            }
+
+            $data = $response->json();
+
+            if (!isset($data['access_token'])) {
+                throw new \Exception('FIB token missing in response');
+            }
+
+            return $data['access_token'];
+        } catch (\Exception $exception) {
+            return $exception->getMessage();
+        }
+    }
+
+    public function createPaymentService()
+    {
+        if ($this->isNotProduction()) {
+            return json_decode(
+                file_get_contents(storage_path('app/mock/fib/payment_create_success.json'))
+            );
+        }
+        $response = $this->client()->post("https://fib-stage.fib.iq/protected/v1/payments");
+        if ($response->failed()) {
+            throw new \Exception(
+                'Unable to authenticate with FIB: ' .
+                $response->body()
+            );
+        }
+
+        $data = $response->json();
+        if (!isset($data['paymentId'])) {
+            throw new \Exception('FIB paymentId missing in response');
+        }
+        return $data;
+    }
+
+    public function isNotProduction()
+    {
+        return env('APP_ENV') === 'local';
+    }
+}

backend/app/Services/FIB/RefundService.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace App\Services\FIB;
+
+use Exception;
+use Illuminate\Http\Client\ConnectionException;
+use Illuminate\Support\Facades\Http;
+use Illuminate\Support\Facades\Log;
+
+class RefundService
+{
+    protected string $url;
+    protected string $channelName;
+    protected AuthorizationService $authorizationService;
+
+    public function __construct(AuthorizationService $authorizationService)
+    {
+        $this->url = config('fib.refund.url');
+        $this->channelName = 'fib_refund';
+        $this->authorizationService = $authorizationService;
+    }
+
+    /**
+     * @throws Exception
+     */
+    public function run(): array
+    {
+        try {
+            return $this->sendRequest();
+        }
+        catch (Exception $e) {
+            Log::channel($this->channelName)
+                ->error(get_class($this),
+                    [
+                        'message' => $e->getMessage(),
+                    ]
+                );
+
+            throw $e;
+        }
+    }
+
+    /**
+     * @throws ConnectionException
+     * @throws Exception
+     */
+    public function sendRequest(): array
+    {
+        return Http::withHeaders([
+            'Authorization' => 'Bearer ' . $this->getToken(),
+            'Content-Type' => 'application/json',
+            ])
+            ->throw()
+            ->withoutVerifying()
+            ->post($this->url)
+            ->json();
+    }
+
+    /**
+     * @throws Exception
+     */
+    public function getToken(): string
+    {
+        $data =  $this->authorizationService->run();
+        return $data['access_token'];
+    }
+}

backend/app/Services/Payments/DTO/PaymentCreateDTO.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace App\Services\Payments\DTO;
+
+use Illuminate\Http\Request;
+
+class PaymentCreateDTO
+{
+
+    public string $username;
+    public int $user_id;
+    public string $track_id;
+    public string $amount;
+    public string $currency;
+    public string $callback_url;
+    public string $ip;
+    public int $user_gateway_id;
+
+
+    public function __construct(array $data)
+    {
+        $this->username = $data['username'];
+        $this->user_id = $data['user_id'];
+        $this->track_id = $data['track_id'];
+        $this->amount = $data['amount'];
+        $this->currency = $data['currency'];
+        $this->callback_url = $data['callback_url'];
+        $this->ip = $data['ip'];
+        $this->user_gateway_id = $data['user_gateway_id'];
+
+    }
+
+    public static function fromRequest(Request $request): PaymentCreateDTO
+    {
+        return new self([
+            'username' => $request->username,
+            'user_id' => '2',
+            'track_id' => uuid_create(),
+            'amount' => $request->amount,
+            'currency' => $request->currency,
+            'callback_url' => $request->callback_url,
+            'ip' => $request->getClientIp(),
+            'user_gateway_id' => $request->user_gateway_id,
+        ]);
+    }
+}

backend/app/Services/Payments/FibAdapter.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace App\Services\Payments;
+
+use App\Models\Payment;
+use App\Services\FIB\CreatePaymentService;
+use App\Services\FIB\FIBClient;
+
+class FibAdapter
+{
+    public function __construct(
+        private CreatePaymentService $create_payment_service,
+        private FIBClient            $fib_client
+    )
+    {
+    }
+
+    public function createPayment(array $data)
+    {
+        Payment::query()->create([
+            'user_id' => auth()->id(),
+            'username' => $data['username'],
+            'track_id' => $data['track_id'],
+            'amount' => $data['amount'],
+            'currency' => $data['currency'],
+            'callback_url' => $data['callback_url'],
+            'expires_at' => $data['expires_at'],
+            'status_id' => $data['status_id'],
+            'status_name' => $data['status_name'],
+            'ip' => $data['ip'],
+            'user_gateway_id' => $data['user_gateway_id'],
+            'created_at' => $data['created_at'],
+            'updated_at' => $data['updated_at'],
+        ]);
+        $this->fib_client->client();
+    }
+}

backend/app/Services/Payments/PaymentService.php

@@ -0,0 +1,79 @@
+<?php
+
+namespace App\Services\Payments;
+
+use App\Enums\PaymentStatusEnum;
+use App\Models\FibTransaction;
+use App\Models\Payment;
+use App\Models\Transaction;
+use App\Services\FIB\CreatePaymentService;
+use App\Services\FIB\DTO\FIBPaymentCreateDTO;
+use App\Services\Payments\DTO\PaymentCreateDTO;
+use Exception;
+use Illuminate\Support\Facades\DB;
+use Throwable;
+
+class PaymentService
+{
+    protected CreatePaymentService $create_payment_service;
+
+    public function __construct(CreatePaymentService $create_payment_service)
+    {
+        $this->create_payment_service = $create_payment_service;
+    }
+
+    /**
+     * @throws Exception
+     * @throws Throwable
+     */
+    public function createPayment(PaymentCreateDTO $dto)
+    {
+        return DB::transaction(function () use ($dto) {
+
+            $payment = Payment::query()->create([
+                'user_id' => $dto->user_id,
+                'username' => $dto->username,
+                'track_id' => $dto->track_id,
+                'amount' => $dto->amount,
+                'currency' => $dto->currency,
+                'callback_url' => $dto->callback_url,
+                'status_id' => PaymentStatusEnum::Unpaid->value,
+                'status_name' => PaymentStatusEnum::Unpaid->name,
+                'ip' => $dto->ip,
+                'user_gateway_id' => $dto->user_gateway_id,
+            ]);
+
+            $response = $this->create_payment_service->run();
+            $fib_response_dto = FIBPaymentCreateDTO::fromResponse($response);
+
+            $transaction = Transaction::query()->create([
+                'user_id' => $payment->user_id,
+                'amount' => $payment->amount,
+                'currency' => $payment->currency,
+                'callback_url' => $payment->callback_url,
+    //                'description' => '',
+    //                'expires_in' => '',
+                'payment_id' => $payment->id,
+                'payment_track_id' => $payment->track_id,
+                'user_gateway_id' => $payment->user_gateway_id,
+    //                'status' => '',
+            ]);
+
+            FibTransaction::query()->create([
+                'transaction_id' => $transaction->id,
+                'qrcode' => $fib_response_dto->qrCode,
+                'readable_code' => $fib_response_dto->readableCode,
+                'personalAppLink' => $fib_response_dto->personalAppLink,
+                'businessAppLink' => $fib_response_dto->businessAppLink,
+                'corporateAppLink' => $fib_response_dto->corporateAppLink,
+                'paymentId' => $fib_response_dto->paymentId,
+                'paymentMethod' => 'fib',
+                'validUntil' => $fib_response_dto->validUntil,
+                'status_id' => PaymentStatusEnum::Unpaid->value,
+                'status_name' => PaymentStatusEnum::Unpaid->name,
+            ]);
+
+            return $payment;
+        });
+    }
+}

backend/app/Traits/ApiResponse.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Traits;
+
+use Illuminate\Http\JsonResponse;
+
+trait ApiResponse
+{
+    public function successResponse(mixed $data = null, string $message = null, int $statusCode = 200): JsonResponse
+    {
+        if (!is_null($data)) {
+            return response()->json([
+                'data' => $data
+            ], $statusCode);
+        }
+
+        $message = $message ?? __('messages.successful');
+
+        return response()->json([
+            'message' => $message
+        ], $statusCode);
+    }
+
+    public function errorResponse(string $message, string $type = 'logical_exception', int $statusCode = 422): JsonResponse
+    {
+        return response()->json([
+            'type' => $type,
+            'message' => $message
+        ], $statusCode);
+    }
+}

backend/app/User/Controllers/AuthController.php

@@ -0,0 +1,64 @@
+<?php
+
+namespace App\User\Controllers;
+
+use App\Http\Controllers\Controller;
+use App\Models\User;
+use App\Traits\ApiResponse;
+use App\User\Requests\Auth\LoginRequest;
+use App\User\Requests\Auth\RegisterRequest;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\Hash;
+
+class AuthController extends Controller
+{
+    use ApiResponse;
+
+    public function register(RegisterRequest $request): JsonResponse
+    {
+        $user = User::query()->create([
+            'username' => $request->username,
+            'email' => $request->email,
+            'password' => Hash::make($request->password),
+        ]);
+
+        Auth::guard('web')->login($user);
+
+        $request->session()->regenerate();
+
+        return $this->successResponse();
+    }
+
+    public function login(LoginRequest $request): JsonResponse
+    {
+        $credentials = ['password' => $request->password,];
+
+        if (filter_var($request->login, FILTER_VALIDATE_EMAIL)) {
+            $credentials['email'] = $request->login;
+        } else {
+            $credentials['username'] = $request->login;
+        }
+
+        if (Auth::attempt($credentials))
+        {
+            $request->session()->regenerate();
+
+            return $this->successResponse();
+        }
+
+        return $this->errorResponse(__('messages.incorrect_or_username_password'));
+    }
+
+    public function logout(Request $request): JsonResponse
+    {
+        Auth::guard('web')->logout();
+
+        $request->session()->invalidate();
+
+        $request->session()->regenerateToken();
+
+        return $this->successResponse();
+    }
+}

backend/app/User/Controllers/CityController.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\User\Controllers;
+
+use App\Http\Controllers\Controller;
+use App\Models\City;
+use App\Models\Province;
+use App\Traits\ApiResponse;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class CityController extends Controller
+{
+    use ApiResponse;
+
+    public function list(Request $request): JsonResponse
+    {
+        $cities = City::query()
+            ->where('province_id', '=', $request->query('province_id'))
+            ->get(['id', 'name']);
+
+        return $this->successResponse($cities);
+    }
+}

backend/app/User/Controllers/DocumentationController.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace App\User\Controllers;
+
+use App\Facades\File\FileFacade;
+use App\Http\Controllers\Controller;
+use App\Traits\ApiResponse;
+use App\User\Requests\Documentation\EditRequest;
+use App\User\Requests\Documentation\UploadRequest;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+
+class DocumentationController extends Controller
+{
+    use ApiResponse;
+
+    public function upload(UploadRequest $request): jsonResponse
+    {
+        $user = Auth::guard('web')->user();
+
+        foreach ($request->documents as $document) {
+            $user->documents()->create([
+                'title' => $document['title'],
+                'url' => FileFacade::save($document['file'], "/{$user->id}/documents", $document['title']),
+            ]);
+        }
+
+        return $this->successResponse();
+    }
+
+    public function edit(EditRequest $request): JsonResponse
+    {
+        $user = Auth::guard('web')->user();
+
+        foreach ($request->documents as $document) {
+            $user->documents()->sync();
+        }
+
+        return $this->successResponse();
+    }
+}

backend/app/User/Controllers/GatewayManagementController.php

@@ -0,0 +1,97 @@
+<?php
+
+namespace App\User\Controllers;
+
+use App\Enums\BusinessTypeEnum;
+use App\Facades\DataTable\DataTableFacade;
+use App\Facades\File\FileFacade;
+use App\Http\Controllers\Controller;
+use App\Models\UserGateway;
+use App\Traits\ApiResponse;
+use App\User\Requests\Gateway\StoreRequest;
+use App\User\Requests\Gateway\UpdateRequest;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\DB;
+use Throwable;
+
+class GatewayManagementController extends Controller
+{
+    use ApiResponse;
+
+    public function index(Request $request)
+    {
+        return DataTableFacade::run(
+            UserGateway::query()->where('user_id', '=', Auth::guard('web')->user()->id),
+            $request,
+            allowedFilters: ['*'],
+            allowedSortings: ['*'],
+            allowedSelects: ['id', 'name', 'domain', 'tax_id', 'bank_name', 'account_holder', 'iban', 'business_type_id', 'business_type_name'],
+        );
+    }
+
+    /**
+     * @throws Throwable
+     */
+    public function store(StoreRequest $request): JsonResponse
+    {
+        $user = Auth::guard('web')->user();
+
+        $logo = $request->has('logo') ? FileFacade::save($request->file('logo'), "{$user->id}") : null;
+
+        DB::transaction(function () use ($user, $logo, $request) {
+            UserGateway::query()->create([
+                'user_id' => $user->id,
+                'username' => $user->username,
+                'name' => $request->name,
+                'domain' => $request->domain,
+                'tax_id' => $request->tax_id,
+                'bank_name' => $request->bank_name,
+                'account_holder' => $request->account_holder,
+                'iban' => $request->iban,
+                'business_type_id' => $request->business_type_id,
+                'business_type_name' => BusinessTypeEnum::name($request->business_type_id),
+                'logo' => $logo,
+            ]);
+
+            $user->update(['authority_level' => 1]);
+        });
+
+
+        return $this->successResponse();
+    }
+
+    public function show(UserGateway $gateway): JsonResponse
+    {
+        return $this->successResponse($gateway);
+    }
+
+    public function update(UpdateRequest $request, UserGateway $gateway): JsonResponse
+    {
+        $logo = null;
+        $user = Auth::guard('web')->user();
+
+        if ($request->has('logo'))
+        {
+            FileFacade::delete($gateway->logo, true);
+            $logo = FileFacade::save(request()->file('logo'), "{$user->id}");
+        }
+
+        $gateway->update([
+            'name' => $request->name,
+            'domain' => $request->domain,
+            'business_type_id' => $request->business_type_id,
+            'business_type_name' => BusinessTypeEnum::name($request->business_type_id),
+            'logo' => $logo,
+        ]);
+
+        return $this->successResponse();
+    }
+
+    public function destroy(UserGateway $gateway): JsonResponse
+    {
+        $gateway->delete();
+        return $this->successResponse();
+    }
+}

backend/app/User/Controllers/Payment/PaymentController.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace App\User\Controllers\Payment;
+
+use App\Http\Controllers\Controller;
+use App\Services\Payments\DTO\PaymentCreateDTO;
+use App\Services\Payments\PaymentService;
+use App\Traits\ApiResponse;
+use App\User\Requests\Payment\FIB\StoreRequest;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+
+class PaymentController extends Controller
+{
+    use ApiResponse;
+
+    public $payment_service;
+
+    public function __construct(PaymentService $payment_service)
+    {
+        $this->payment_service = $payment_service;
+    }
+
+    public function createPayment(StoreRequest $request): JsonResponse
+    {
+        try {
+            $dto = PaymentCreateDTO::fromRequest($request);
+            $result = $this->payment_service->createPayment($dto);
+            return $this->successResponse($result);
+        } catch (\Exception $exception) {
+            throw $exception;
+        }
+    }
+}

backend/app/User/Controllers/ProfileController.php

@@ -0,0 +1,80 @@
+<?php
+
+namespace App\User\Controllers;
+
+use App\Facades\File\FileFacade;
+use App\Http\Controllers\Controller;
+use App\Models\City;
+use App\Models\Province;
+use App\Traits\ApiResponse;
+use App\User\Requests\Profile\ChangePasswordRequest;
+use App\User\Requests\Profile\EditRequest;
+use App\User\Resources\UserResource;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Hash;
+use Throwable;
+
+class ProfileController extends Controller
+{
+    use ApiResponse;
+
+    public function info(): JsonResponse
+    {
+        return $this->successResponse(new UserResource(Auth::user()));
+    }
+
+    /**
+     * @throws Throwable
+     */
+    public function edit(EditRequest $request): JsonResponse
+    {
+        $user = Auth::user();
+        $province = Province::query()->find($request->province_id);
+        $city = City::query()->find($request->city_id);
+
+        DB::transaction(function () use ($user, $province, $city, $request) {
+            if ($user->kyc_status == 0)
+            {
+                $user->documents()->create([
+                    'title' => 'id_card',
+                    'url' => FileFacade::save($request->file('id_card'), "{$user->id}/"),
+                ]);
+            }
+
+            $user->update([
+                'first_name' => $request->first_name,
+                'last_name' => $request->last_name,
+                'national_id' => $user->kyc_status == 0 ? $request->national_id : $user->national_id,
+                'address' => $request->address,
+                'postal_code' => $request->postal_code,
+                'phone_number' => $request->phone_number,
+                'province_id' => $province->id,
+                'province_name' => $province->name,
+                'city_id' => $city->id,
+                'city_name' => $city->name,
+                'birth_date' => $request->birth_date,
+                'email' => $request->email,
+                'kyc_status' => 1,
+            ]);
+        });
+
+        return $this->successResponse();
+    }
+
+    public function changePassword(ChangePasswordRequest $request): JsonResponse
+    {
+        $user = Auth::user();
+
+        if (! Hash::check($request->current_password, $user->password)) {
+            return $this->errorResponse(__('messages.incorrect_current_password'));
+        }
+
+        $user->update([
+            'password' => Hash::make($request->new_password),
+        ]);
+
+        return $this->successResponse();
+    }
+}

backend/app/User/Controllers/ProvinceController.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace App\User\Controllers;
+
+use App\Http\Controllers\Controller;
+use App\Models\Province;
+use App\Traits\ApiResponse;
+use Illuminate\Http\JsonResponse;
+
+class ProvinceController extends Controller
+{
+    use ApiResponse;
+    public function list(): JsonResponse
+    {
+        return $this->successResponse(Province::all(['id', 'name']));
+    }
+}

backend/app/User/Events/LoginEmailEvent.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\User\Events;
+
+use App\Models\User;
+use Illuminate\Broadcasting\Channel;
+use Illuminate\Broadcasting\InteractsWithSockets;
+use Illuminate\Broadcasting\PrivateChannel;
+use Illuminate\Foundation\Events\Dispatchable;
+use Illuminate\Queue\SerializesModels;
+
+class LoginEmailEvent
+{
+    use Dispatchable, InteractsWithSockets, SerializesModels;
+
+    /**
+     * Create a new event instance.
+     */
+    public function __construct(public User $user)
+    {
+        //
+    }
+}

backend/app/User/Listeners/SendEmailListener.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\User\Listeners;
+
+use App\Mail\LoginNotificationMail;
+use App\User\Events\LoginEmailEvent;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Support\Facades\Mail;
+
+class SendEmailListener implements ShouldQueue{
+    public string $queue = 'emails';
+    /**
+     * Create the event listener.
+     */
+    public function __construct()
+    {
+        //
+    }
+
+    /**
+     * Handle the event.
+     */
+    public function handle(LoginEmailEvent $event): void
+    {
+        $user = $event->user;
+
+        Mail::to($user->email)->send(
+            new LoginNotificationMail($user)
+        );
+    }
+}

backend/app/User/Requests/Auth/LoginRequest.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace App\User\Requests\Auth;
+
+use Illuminate\Contracts\Validation\ValidationRule;
+use Illuminate\Foundation\Http\FormRequest;
+
+class LoginRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, ValidationRule|array|string>
+     */
+    public function rules(): array
+    {
+        return [
+            'login' => 'required|string',
+            'password' => 'required|string',
+        ];
+    }
+}

backend/app/User/Requests/Auth/RegisterRequest.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\User\Requests\Auth;
+
+use Illuminate\Contracts\Validation\ValidationRule;
+use Illuminate\Foundation\Http\FormRequest;
+
+class RegisterRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, ValidationRule|array|string>
+     */
+    public function rules(): array
+    {
+        return [
+            'username' => 'required|unique:users,username',
+            'email' => 'required|email|unique:users,email',
+            'password' => 'required|string|regex:/^(?=.*[a-zA-Z])(?=.*\d).+$/|min:6|confirmed',
+        ];
+    }
+}