fix code3

Reviewed-on: #13

.gitignore

@@ -1,2 +1,3 @@
 .idea
 .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

@@ -1,28 +1,35 @@
-FROM docker.arvancloud.ir/dunglas/frankenphp:1.11.2-php8.5-trixie
+FROM php:8.5.3-fpm-alpine3.23
 
-RUN apt-get update \
+# Install common PHP extension dependencies
-    && apt-get install -y --no-install-recommends libpq-dev \
+RUN apk update && apk add --no-cache \
+    bash \
+    curl \
+    libpng \
+    libpng-dev \
+    libjpeg-turbo-dev \
+    freetype-dev \
+    libwebp-dev \
+    libxml2-dev \
     unzip \
-    zip \
+    libzip-dev \
-    && install-php-extensions pdo_pgsql pgsql \
+    libpq-dev \
-    && apt-get clean \
+    && docker-php-ext-configure gd --with-freetype --with-jpeg --with-webp \
-    && rm -rf /var/lib/apt/lists/*
+    && docker-php-ext-install pdo_pgsql gd zip
 
+# Set the working directory
 WORKDIR /var/www/payment
 
-#ENV SERVER_NAME=your-domain-name.example.com
-
-# Copy Laravel application
 COPY . .
 
-# Give permissions to storage and bootstrap/cache
+RUN chmod -R 775 /var/www/payment/storage /var/www/payment/bootstrap/cache
-RUN chmod -R 777 storage bootstrap/cache
 
 # Install Composer
-COPY --from=docker.arvancloud.ir/composer:latest /usr/bin/composer /usr/bin/composer
+COPY --from=composer:latest /usr/bin/composer /usr/bin/composer
+ENV COMPOSER_ALLOW_SUPERUSER=1
 
+# Default command
 CMD composer install ;\
-    php artisan key:generate;\
+    composer dump-autoload --optimize --classmap-authoritative ;\
     php artisan migrate ;\
     php artisan db:seed ;\
-    frankenphp php-server -r public/
+    php-fpm

backend/Dockerfile.production

@@ -14,19 +14,28 @@ COPY . .
 
 RUN composer dump-autoload --optimize --classmap-authoritative
 
-FROM docker.arvancloud.ir/dunglas/frankenphp:1.11.2-php8.5-trixie AS application
+FROM php:8.5.3-fpm-alpine3.23 AS application
 
-RUN apt-get update \
+RUN apk update && apk add --no-cache \
-    && apt-get install -y --no-install-recommends libpq-dev unzip zip \
+    bash \
-    && install-php-extensions pdo_pgsql pgsql \
+    curl \
-    && apt-get clean \
+    libpng \
-    && rm -rf /var/lib/apt/lists/*
+    libpng-dev \
+    libjpeg-turbo-dev \
+    freetype-dev \
+    libwebp-dev \
+    libxml2-dev \
+    unzip \
+    libzip-dev \
+    libpq-dev \
+    && docker-php-ext-configure gd --with-freetype --with-jpeg --with-webp \
+    && docker-php-ext-install pdo_pgsql gd zip
 
 WORKDIR /var/www/payment
 
 COPY --from=builder /app /var/www/payment
 
 RUN chown -R www-data:www-data /var/www/payment \
-    && chmod -R 775 storage bootstrap/cache
+    && chmod -R 665 storage bootstrap/cache
 
-CMD ["frankenphp", "php-server", "-r", "public/"]
+CMD ["php-fpm"]

backend/app/Admin/Controllers/AuthController.php

@@ -0,0 +1,62 @@
+<?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 register(RegisterRequest $request): JsonResponse
+    {
+        Expert::query()->create([
+            'username' => $request->username,
+            'email' => $request->email,
+            'password' => Hash::make($request->password),
+        ]);
+
+        $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('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,113 @@
+<?php
+
+namespace App\Admin\Controllers;
+
+use App\Admin\Requests\ExpertManagement\StoreRequest;
+use App\Admin\Requests\ExpertManagement\UpdateRequest;
+use App\Admin\Resources\ExpertManagementResource;
+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,37 @@
+<?php
+
+namespace App\Admin\Controllers;
+
+use App\Admin\Requests\Profile\ChangePasswordRequest;
+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 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/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/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/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,22 @@
+<?php
+
+namespace App\Models;
+
+use Database\Factories\ExpertFactory;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Spatie\Permission\Traits\HasRoles;
+
+/**
+ * @method roles()
+ * @method permissions()
+ */
+class Expert extends Model
+{
+    /** @use HasFactory<ExpertFactory> */
+    use HasFactory;
+    use HasRoles;
+
+    protected $guarded = ['id'];
+    protected string $guard_name = 'web';
+}

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/User.php

@@ -4,29 +4,24 @@ 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 Laravel\Passport\HasApiTokens;
 
-#[Fillable(['name', 'email', 'password'])]
+#[Guarded(['id'])]
-#[Hidden(['password', 'remember_token'])]
+#[Hidden(['password'])]
 class User extends Authenticatable
 {
     /** @use HasFactory<UserFactory> */
-    use HasFactory, Notifiable;
+    use HasFactory, Notifiable, HasApiTokens;
+    protected $guarded = ['id'];
 
-    /**
+    public function documents(): MorphToMany
-     * Get the attributes that should be cast.
-     *
-     * @return array<string, string>
-     */
-    protected function casts(): array
     {
-        return [
+        return $this->morphToMany(Document::class, 'documentable');
-            'email_verified_at' => 'datetime',
-            'password' => 'hashed',
-        ];
     }
 }

backend/app/Providers/AppServiceProvider.php

@@ -3,6 +3,8 @@
 namespace App\Providers;
 
 use Illuminate\Support\ServiceProvider;
+use Laravel\Passport\Passport;
+use Carbon\CarbonInterval;
 
 class AppServiceProvider extends ServiceProvider
 {
@@ -19,6 +21,7 @@ class AppServiceProvider extends ServiceProvider
      */
     public function boot(): void
     {
-        //
+        Passport::enablePasswordGrant();
+        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/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/Dashboard/ConfirmController.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace App\User\Controllers\Dashboard;
+
+use App\Http\Controllers\Controller;
+use Illuminate\Http\Request;
+
+class ConfirmController extends Controller
+{
+    public function index()
+    {
+        //
+    }
+}

backend/app/User/Controllers/Dashboard/DocumentationController.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\User\Controller\Dashboard;
+
+use App\Http\Controllers\Controller;
+use App\Traits\ApiResponse;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class DocumentationController extends Controller
+{
+    use ApiResponse;
+
+    public function store(StoreRequest $request): jsonResponse
+    {
+        //
+    }
+
+    public function update(UpdateRequest $request): JsonResponse
+    {
+        //
+    }
+
+}

backend/app/User/Controllers/ProfileController.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace App\User\Controllers;
+
+use App\Http\Controllers\Controller;
+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\Hash;
+
+class ProfileController extends Controller
+{
+    use ApiResponse;
+
+    public function info(): JsonResponse
+    {
+        return $this->successResponse(new UserResource(Auth::user()));
+    }
+
+    public function edit(EditRequest $request): JsonResponse
+    {
+        $user = Auth::user();
+
+        $user->update([
+            'first_name' => $request->first_name,
+            'last_name' => $request->last_name,
+            'national_id' => $request->national_id,
+            'address' => $request->address,
+            'postal_code' => $request->postal_code,
+            'phone_number' => $request->phone_number,
+            'province_id' => $request->province_id,
+            'city_id' => $request->city_id,
+            '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/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',
+        ];
+    }
+}

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

@@ -0,0 +1,30 @@
+<?php
+
+namespace App\User\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:6',
+            'new_password' => 'required|string|regex:/^(?=.*[a-zA-Z])(?=.*\d).+$/|min:6',
+        ];
+    }
+}

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

@@ -0,0 +1,36 @@
+<?php
+
+namespace App\User\Requests\Profile;
+
+use Illuminate\Contracts\Validation\ValidationRule;
+use Illuminate\Foundation\Http\FormRequest;
+
+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 [
+            'first_name' => 'required|string',
+            'last_name' => 'required|string',
+            'national_id' => 'required',
+            'address' => 'required',
+            'postal_code' => 'required',
+            'phone_number' => 'required',
+            'province_id' => 'required',
+            'city_id' => 'required',
+        ];
+    }
+}

backend/app/User/Resources/UserResource.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\User\Resources;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class UserResource 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/User/Services/FIB/AuthorizationService.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace App\User\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 = '';
+        $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()
+            ->withoutVerifying()
+            ->post($this->url, $this->inputParameters)
+            ->json();
+    }
+}

backend/app/User/Services/FIB/CancelPaymentService.php

@@ -0,0 +1,62 @@
+<?php
+
+namespace App\User\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 string $accessToken;
+    protected array $headers;
+
+    public function __construct()
+    {
+        $this->url = config('fib.cancelPayment.url');
+        $this->channelName = '';
+    }
+
+    public function setHeaders(): void
+    {
+        $this->headers = [
+            'Authorization' => 'Bearer ' . $this->accessToken,
+            'Content-Type' => 'application/json',
+        ];
+    }
+
+    /**
+     * @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::withHeaders($this->headers)
+            ->throw()
+            ->withoutVerifying()
+            ->post($this->url)
+            ->json();
+    }
+}

backend/app/User/Services/FIB/CheckPaymentStatusService.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace App\User\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;
+
+    public function __construct()
+    {
+        $this->url = config('fib.checkPaymentStatus.url');
+        $this->channelName = '';
+    }
+
+    /**
+     * @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::throw()
+            ->withoutVerifying()
+            ->post($this->url)
+            ->json();
+    }
+}

backend/app/User/Services/FIB/CreatePaymentService.php

@@ -0,0 +1,73 @@
+<?php
+
+namespace App\User\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 string $accessToken;
+    protected array $headers;
+    protected array $inputParameters;
+
+    public function __construct()
+    {
+        $this->url = config('fib.createPayment.url');
+        $this->channelName = '';
+    }
+
+    public function setAccessToken(string $accessToken): void
+    {
+        $this->accessToken = $accessToken;
+    }
+
+    public function setHeaders(): void
+    {
+        $this->headers = [
+            'Authorization' => 'Bearer ' . $this->accessToken,
+            'Content-Type' => 'application/json',
+        ];
+    }
+
+    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
+     */
+    public function sendRequest(): array
+    {
+        return Http::withHeaders($this->headers)
+            ->throw()
+            ->withoutVerifying()
+            ->post($this->url, $this->inputParameters)
+            ->json();
+    }
+}

backend/app/User/Services/FIB/RefundService.php

@@ -0,0 +1,62 @@
+<?php
+
+namespace App\User\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 string $accessToken;
+    protected array $headers;
+
+    public function __construct()
+    {
+        $this->url = config('fib.refund.url');
+        $this->channelName = '';
+    }
+
+    public function setHeaders(): void
+    {
+        $this->headers = [
+            'Authorization' => 'Bearer ' . $this->accessToken,
+            'Content-Type' => 'application/json',
+        ];
+    }
+
+    /**
+     * @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::withHeaders($this->headers)
+            ->throw()
+            ->withoutVerifying()
+            ->post($this->url)
+            ->json();
+    }
+}

backend/bootstrap/app.php

@@ -7,12 +7,22 @@ use Illuminate\Foundation\Configuration\Middleware;
 return Application::configure(basePath: dirname(__DIR__))
     ->withRouting(
         web: __DIR__.'/../routes/web.php',
+        api: __DIR__.'/../routes/api.php',
         commands: __DIR__.'/../routes/console.php',
         health: '/up',
+        then: function () {
+            Route::middleware('web')
+                ->prefix('expert')
+                ->name('expert.')
+                ->group(base_path('routes/expert.php'));
+        },
     )
     ->withMiddleware(function (Middleware $middleware): void {
-        //
+        $middleware->web()->preventRequestForgery(['*']);
     })
     ->withExceptions(function (Exceptions $exceptions): void {
         //
-    })->create();
+    })
+    ->withEvents(discover: [
+        __DIR__.'/../app/User/Listeners',
+    ])->create();

backend/bootstrap/providers.php

@@ -1,7 +1,7 @@
 <?php
 
-use App\Providers\AppServiceProvider;
-
 return [
-    AppServiceProvider::class,
+    App\Providers\AppServiceProvider::class,
+    App\Providers\DataTableServiceProvider::class,
+    App\Providers\FileServiceProvider::class,
 ];

backend/composer.json

@@ -11,7 +11,9 @@
     "require": {
         "php": "^8.3",
         "laravel/framework": "^13.0",
-        "laravel/tinker": "^3.0"
+        "laravel/passport": "^13.0",
+        "laravel/tinker": "^3.0",
+        "spatie/laravel-permission": "^7.4"
     },
     "require-dev": {
         "fakerphp/faker": "^1.23",

backend/config/auth.php

@@ -42,6 +42,14 @@ return [
             'driver' => 'session',
             'provider' => 'users',
         ],
+        'api' => [
+            'driver' => 'passport',
+            'provider' => 'users',
+        ],
+        'expert' => [
+            'driver' => 'session',
+            'provider' => 'experts',
+        ]
     ],
 
     /*
@@ -66,6 +74,10 @@ return [
             'driver' => 'eloquent',
             'model' => env('AUTH_MODEL', User::class),
         ],
+        'experts' => [
+            'driver' => 'eloquent',
+            'model' => env('AUTH_MODEL', Expert::class),
+        ],
 
         // 'users' => [
         //     'driver' => 'database',

backend/config/cors.php

@@ -0,0 +1,34 @@
+<?php
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Cross-Origin Resource Sharing (CORS) Configuration
+    |--------------------------------------------------------------------------
+    |
+    | Here you may configure your settings for cross-origin resource sharing
+    | or "CORS". This determines what cross-origin operations may execute
+    | in web browsers. You are free to adjust these settings as needed.
+    |
+    | To learn more: https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS
+    |
+    */
+
+    'paths' => ['*'],
+
+    'allowed_methods' => ['*'],
+
+    'allowed_origins' => ['*'],
+
+    'allowed_origins_patterns' => [],
+
+    'allowed_headers' => ['*'],
+
+    'exposed_headers' => [],
+
+    'max_age' => 0,
+
+    'supports_credentials' => true,
+
+];

backend/config/fib.php

@@ -0,0 +1,25 @@
+<?php
+
+return [
+    'authorization' => [
+        'url' => env('FIB_AUTHORIZATION_URL'),
+        'client_id' => env('FIB_CLIENT_ID'),
+        'client_secret' => env('FIB_CLIENT_SECRET'),
+    ],
+
+    'createPayment' => [
+        'url' => env('FIB_CREATE_PAYMENT_URL'),
+    ],
+
+    'checkPaymentStatus' => [
+        'url' => env('FIB_CHECK_PAYMENT_STATUS_URL'),
+    ],
+
+    'cancelPayment' => [
+        'url' => env('FIB_CANCEL_PAYMENT_URL'),
+    ],
+
+    'refund' => [
+        'url' => env('FIB_REFUND_URL'),
+    ],
+];

backend/config/passport.php

@@ -0,0 +1,48 @@
+<?php
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Passport Guard
+    |--------------------------------------------------------------------------
+    |
+    | Here you may specify which authentication guard Passport will use when
+    | authenticating users. This value should correspond with one of your
+    | guards that is already present in your "auth" configuration file.
+    |
+    */
+
+    'guard' => 'web',
+
+    'middleware' => [],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Encryption Keys
+    |--------------------------------------------------------------------------
+    |
+    | Passport uses encryption keys while generating secure access tokens for
+    | your application. By default, the keys are stored as local files but
+    | can be set via environment variables when that is more convenient.
+    |
+    */
+
+    'private_key' => env('PASSPORT_PRIVATE_KEY'),
+
+    'public_key' => env('PASSPORT_PUBLIC_KEY'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Passport Database Connection
+    |--------------------------------------------------------------------------
+    |
+    | By default, Passport's models will utilize your application's default
+    | database connection. If you wish to use a different connection you
+    | may specify the configured name of the database connection here.
+    |
+    */
+
+    'connection' => env('PASSPORT_CONNECTION'),
+
+];

backend/config/permission.php

@@ -0,0 +1,219 @@
+<?php
+
+use Spatie\Permission\DefaultTeamResolver;
+use Spatie\Permission\Models\Permission;
+use Spatie\Permission\Models\Role;
+
+return [
+
+    'models' => [
+
+        /*
+         * When using the "HasPermissions" trait from this package, we need to know which
+         * Eloquent model should be used to retrieve your permissions. Of course, it
+         * is often just the "Permission" model but you may use whatever you like.
+         *
+         * The model you want to use as a Permission model needs to implement the
+         * `Spatie\Permission\Contracts\Permission` contract.
+         */
+
+        'permission' => Permission::class,
+
+        /*
+         * When using the "HasRoles" trait from this package, we need to know which
+         * Eloquent model should be used to retrieve your roles. Of course, it
+         * is often just the "Role" model but you may use whatever you like.
+         *
+         * The model you want to use as a Role model needs to implement the
+         * `Spatie\Permission\Contracts\Role` contract.
+         */
+
+        'role' => Role::class,
+
+        /*
+         * When using the "Teams" feature from this package, we need to know which
+         * Eloquent model should be used to retrieve your teams. Of course, it
+         * is often just the "Team" model but you may use whatever you like.
+         */
+        'team' => null,
+
+        /*
+         * When using the "HasModels" trait and passing raw IDs to syncModels,
+         * attachModels, or detachModels, this model class will be used to
+         * resolve those IDs. If null, defaults to the guard's model.
+         */
+        'default_model' => null,
+    ],
+
+    'table_names' => [
+
+        /*
+         * When using the "HasRoles" trait from this package, we need to know which
+         * table should be used to retrieve your roles. We have chosen a basic
+         * default value but you may easily change it to any table you like.
+         */
+
+        'roles' => 'roles',
+
+        /*
+         * When using the "HasPermissions" trait from this package, we need to know which
+         * table should be used to retrieve your permissions. We have chosen a basic
+         * default value but you may easily change it to any table you like.
+         */
+
+        'permissions' => 'permissions',
+
+        /*
+         * When using the "HasPermissions" trait from this package, we need to know which
+         * table should be used to retrieve your models permissions. We have chosen a
+         * basic default value but you may easily change it to any table you like.
+         */
+
+        'model_has_permissions' => 'model_has_permissions',
+
+        /*
+         * When using the "HasRoles" trait from this package, we need to know which
+         * table should be used to retrieve your models roles. We have chosen a
+         * basic default value but you may easily change it to any table you like.
+         */
+
+        'model_has_roles' => 'model_has_roles',
+
+        /*
+         * When using the "HasRoles" trait from this package, we need to know which
+         * table should be used to retrieve your roles permissions. We have chosen a
+         * basic default value but you may easily change it to any table you like.
+         */
+
+        'role_has_permissions' => 'role_has_permissions',
+    ],
+
+    'column_names' => [
+        /*
+         * Change this if you want to name the related pivots other than defaults
+         */
+        'role_pivot_key' => null, // default 'role_id',
+        'permission_pivot_key' => null, // default 'permission_id',
+
+        /*
+         * Change this if you want to name the related model primary key other than
+         * `model_id`.
+         *
+         * For example, this would be nice if your primary keys are all UUIDs. In
+         * that case, name this `model_uuid`.
+         */
+
+        'model_morph_key' => 'model_id',
+
+        /*
+         * Change this if you want to use the teams feature and your related model's
+         * foreign key is other than `team_id`.
+         */
+
+        'team_foreign_key' => 'team_id',
+    ],
+
+    /*
+     * When set to true, the method for checking permissions will be registered on the gate.
+     * Set this to false if you want to implement custom logic for checking permissions.
+     */
+
+    'register_permission_check_method' => true,
+
+    /*
+     * When set to true, Laravel\Octane\Events\OperationTerminated event listener will be registered
+     * this will refresh permissions on every TickTerminated, TaskTerminated and RequestTerminated
+     * NOTE: This should not be needed in most cases, but an Octane/Vapor combination benefited from it.
+     */
+    'register_octane_reset_listener' => false,
+
+    /*
+     * Events will fire when a role or permission is assigned/unassigned:
+     * \Spatie\Permission\Events\RoleAttachedEvent
+     * \Spatie\Permission\Events\RoleDetachedEvent
+     * \Spatie\Permission\Events\PermissionAttachedEvent
+     * \Spatie\Permission\Events\PermissionDetachedEvent
+     *
+     * To enable, set to true, and then create listeners to watch these events.
+     */
+    'events_enabled' => false,
+
+    /*
+     * Teams Feature.
+     * When set to true the package implements teams using the 'team_foreign_key'.
+     * If you want the migrations to register the 'team_foreign_key', you must
+     * set this to true before doing the migration.
+     * If you already did the migration then you must make a new migration to also
+     * add 'team_foreign_key' to 'roles', 'model_has_roles', and 'model_has_permissions'
+     * (view the latest version of this package's migration file)
+     */
+
+    'teams' => false,
+
+    /*
+     * The class to use to resolve the permissions team id
+     */
+    'team_resolver' => DefaultTeamResolver::class,
+
+    /*
+     * Passport Client Credentials Grant
+     * When set to true the package will use Passports Client to check permissions
+     */
+
+    'use_passport_client_credentials' => false,
+
+    /*
+     * When set to true, the required permission names are added to exception messages.
+     * This could be considered an information leak in some contexts, so the default
+     * setting is false here for optimum safety.
+     */
+
+    'display_permission_in_exception' => false,
+
+    /*
+     * When set to true, the required role names are added to exception messages.
+     * This could be considered an information leak in some contexts, so the default
+     * setting is false here for optimum safety.
+     */
+
+    'display_role_in_exception' => false,
+
+    /*
+     * By default wildcard permission lookups are disabled.
+     * See documentation to understand supported syntax.
+     */
+
+    'enable_wildcard_permission' => false,
+
+    /*
+     * The class to use for interpreting wildcard permissions.
+     * If you need to modify delimiters, override the class and specify its name here.
+     */
+    // 'wildcard_permission' => Spatie\Permission\WildcardPermission::class,
+
+    /* Cache-specific settings */
+
+    'cache' => [
+
+        /*
+         * By default all permissions are cached for 24 hours to speed up performance.
+         * When permissions or roles are updated the cache is flushed automatically.
+         */
+
+        'expiration_time' => DateInterval::createFromDateString('24 hours'),
+
+        /*
+         * The cache key used to store all permissions.
+         */
+
+        'key' => 'spatie.permission.cache',
+
+        /*
+         * You may optionally indicate a specific cache driver to use for permission and
+         * role caching using any of the `store` drivers listed in the cache.php config
+         * file. Using 'default' here means to use the `default` set in cache.php.
+         */
+
+        'store' => 'default',
+    ],
+];

backend/database/factories/CityFactory.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Database\Factories;
+
+use App\Models\City;
+use Illuminate\Database\Eloquent\Factories\Factory;
+
+/**
+ * @extends Factory<City>
+ */
+class CityFactory extends Factory
+{
+    /**
+     * Define the model's default state.
+     *
+     * @return array<string, mixed>
+     */
+    public function definition(): array
+    {
+        return [
+            //
+        ];
+    }
+}

backend/database/factories/DocumentFactory.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Database\Factories;
+
+use App\Models\Document;
+use Illuminate\Database\Eloquent\Factories\Factory;
+
+/**
+ * @extends Factory<Document>
+ */
+class DocumentFactory extends Factory
+{
+    /**
+     * Define the model's default state.
+     *
+     * @return array<string, mixed>
+     */
+    public function definition(): array
+    {
+        return [
+            //
+        ];
+    }
+}

backend/database/factories/ExpertFactory.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Database\Factories;
+
+use App\Models\Expert;
+use Illuminate\Database\Eloquent\Factories\Factory;
+
+/**
+ * @extends Factory<Expert>
+ */
+class ExpertFactory extends Factory
+{
+    /**
+     * Define the model's default state.
+     *
+     * @return array<string, mixed>
+     */
+    public function definition(): array
+    {
+        return [
+            //
+        ];
+    }
+}

backend/database/factories/ProvinceFactory.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Database\Factories;
+
+use App\Models\Province;
+use Illuminate\Database\Eloquent\Factories\Factory;
+
+/**
+ * @extends Factory<Province>
+ */
+class ProvinceFactory extends Factory
+{
+    /**
+     * Define the model's default state.
+     *
+     * @return array<string, mixed>
+     */
+    public function definition(): array
+    {
+        return [
+            //
+        ];
+    }
+}

backend/database/factories/UserFactory.php

@@ -25,7 +25,7 @@ class UserFactory extends Factory
     public function definition(): array
     {
         return [
-            'name' => fake()->name(),
+            'username' => fake()->name(),
             'email' => fake()->unique()->safeEmail(),
             'email_verified_at' => now(),
             'password' => static::$password ??= Hash::make('password'),

backend/database/migrations/0001_01_00_000000_create_provinces_table.php

@@ -0,0 +1,28 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('provinces', function (Blueprint $table) {
+            $table->id();
+            $table->string('name');
+            $table->timestamps();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('provinces');
+    }
+};

backend/database/migrations/0001_01_00_000001_create_cities_table.php

@@ -0,0 +1,29 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('cities', function (Blueprint $table) {
+            $table->id();
+            $table->string('name');
+            $table->foreignId('province_id')->constrained('provinces');
+            $table->timestamps();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('cities');
+    }
+};

backend/database/migrations/0001_01_01_000000_create_users_table.php

@@ -13,20 +13,26 @@ return new class extends Migration
     {
         Schema::create('users', function (Blueprint $table) {
             $table->id();
-            $table->string('name');
+            $table->string('username');
+            $table->string('first_name')->nullable();
+            $table->string('last_name')->nullable();
             $table->string('email')->unique();
-            $table->timestamp('email_verified_at')->nullable();
             $table->string('password');
-            $table->rememberToken();
+            $table->tinyInteger('kyc_status')->default(0);
+            $table->string('national_id')->nullable();
+            $table->string('address')->nullable();
+            $table->string('postal_code')->nullable();
+            $table->string('tax_id')->nullable();
+            $table->string('phone_number')->nullable();
+            $table->date('birth_date')->nullable();
+            $table->foreignId('province_id')->nullable()->constrained('provinces');
+            $table->string('province_name')->nullable();
+            $table->foreignId('city_id')->nullable()->constrained('cities');
+            $table->string('city_name')->nullable();
+            $table->tinyInteger('authority_level')->default(0);
             $table->timestamps();
         });
 
-        Schema::create('password_reset_tokens', function (Blueprint $table) {
-            $table->string('email')->primary();
-            $table->string('token');
-            $table->timestamp('created_at')->nullable();
-        });
-
         Schema::create('sessions', function (Blueprint $table) {
             $table->string('id')->primary();
             $table->foreignId('user_id')->nullable()->index();
@@ -43,7 +49,6 @@ return new class extends Migration
     public function down(): void
     {
         Schema::dropIfExists('users');
-        Schema::dropIfExists('password_reset_tokens');
         Schema::dropIfExists('sessions');
     }
 };

backend/database/migrations/2026_04_27_122415_create_oauth_auth_codes_table.php

@@ -0,0 +1,39 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('oauth_auth_codes', function (Blueprint $table) {
+            $table->char('id', 80)->primary();
+            $table->foreignId('user_id')->index();
+            $table->foreignUuid('client_id');
+            $table->text('scopes')->nullable();
+            $table->boolean('revoked');
+            $table->dateTime('expires_at')->nullable();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('oauth_auth_codes');
+    }
+
+    /**
+     * Get the migration connection name.
+     */
+    public function getConnection(): ?string
+    {
+        return $this->connection ?? config('passport.connection');
+    }
+};

backend/database/migrations/2026_04_27_122416_create_oauth_access_tokens_table.php

@@ -0,0 +1,41 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('oauth_access_tokens', function (Blueprint $table) {
+            $table->char('id', 80)->primary();
+            $table->foreignId('user_id')->nullable()->index();
+            $table->foreignUuid('client_id');
+            $table->string('name')->nullable();
+            $table->text('scopes')->nullable();
+            $table->boolean('revoked');
+            $table->timestamps();
+            $table->dateTime('expires_at')->nullable();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('oauth_access_tokens');
+    }
+
+    /**
+     * Get the migration connection name.
+     */
+    public function getConnection(): ?string
+    {
+        return $this->connection ?? config('passport.connection');
+    }
+};

backend/database/migrations/2026_04_27_122417_create_oauth_refresh_tokens_table.php

@@ -0,0 +1,37 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('oauth_refresh_tokens', function (Blueprint $table) {
+            $table->char('id', 80)->primary();
+            $table->char('access_token_id', 80)->index();
+            $table->boolean('revoked');
+            $table->dateTime('expires_at')->nullable();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('oauth_refresh_tokens');
+    }
+
+    /**
+     * Get the migration connection name.
+     */
+    public function getConnection(): ?string
+    {
+        return $this->connection ?? config('passport.connection');
+    }
+};