add level to users table

Reviewed-on: #7

.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

@@ -30,7 +30,6 @@ ENV COMPOSER_ALLOW_SUPERUSER=1
 # Default command
 CMD composer install ;\
     composer dump-autoload --optimize --classmap-authoritative ;\
-    php artisan key:generate ;\
     php artisan migrate ;\
     php artisan db:seed ;\
     php-fpm

backend/app/Admin/Controllers/AuthController.php

@@ -0,0 +1,60 @@
+<?php
+
+namespace App\Admin\Controllers;
+
+use App\Http\Controllers\Controller;
+use App\Traits\ApiResponse;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+
+class AuthController extends Controller
+{
+    use ApiResponse;
+
+    public function register(Request $request): JsonResponse
+    {
+//        Expert::query()->create();
+
+        $request->session()->regenerate();
+
+        return $this->successResponse();
+    }
+
+    public function login(Request $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();
+
+            $user = Auth::user();
+
+            return $this->successResponse([
+                'id' => $user->id,
+                'username' => $user->username,
+                'email' => $user->email,
+            ]);
+        }
+
+        return $this->errorResponse(__('messages.incorrect_or_username_password'));
+    }
+
+    public function logout(Request $request): JsonResponse
+    {
+        Auth::logout();
+
+        $request->session()->invalidate();
+
+        $request->session()->regenerateToken();
+
+        return $this->successResponse();
+    }
+}

backend/app/Admin/Controllers/DocumentationController.php

@@ -0,0 +1,53 @@
+<?php
+
+namespace App\Admin\Controllers;
+
+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([
+
+        ]);
+
+        return $this->successResponse();
+    }
+
+    public function reject(User $user): JsonResponse
+    {
+        $user->update([
+
+        ]);
+
+        return $this->successResponse();
+    }
+}

backend/app/Admin/Controllers/ProfileController.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace App\Admin\Controllers;
+
+use App\Admin\Resources\ExpertResource;
+use App\Http\Controllers\Controller;
+use App\Traits\ApiResponse;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Support\Facades\Auth;
+
+class ProfileController extends Controller
+{
+    use ApiResponse;
+
+    public function info(): JsonResponse
+    {
+        return $this->successResponse(new ExpertResource(Auth::user()));
+    }
+}

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,15 @@
+<?php
+
+namespace App\Models;
+
+use Database\Factories\ExpertFactory;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+
+class Expert extends Model
+{
+    /** @use HasFactory<ExpertFactory> */
+    use HasFactory;
+
+    protected $guarded = ['id'];
+}

backend/app/Models/Province.php

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

backend/app/Models/User.php

@@ -8,6 +8,7 @@ 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;
@@ -19,4 +20,9 @@ class User extends Authenticatable
     /** @use HasFactory<UserFactory> */
     use HasFactory, Notifiable, HasApiTokens;
     protected $guarded = ['id'];
+
+    public function documents(): MorphToMany
+    {
+        return $this->morphToMany(Document::class, 'documentable');
+    }
 }

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

@@ -1,13 +1,12 @@
 <?php
 
-namespace App\User\Controller\Auth;
+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 App\User\Resources\UserResource;
 use Illuminate\Http\JsonResponse;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
@@ -46,7 +45,11 @@ class AuthController extends Controller
 
             $user = Auth::user();
 
-            return $this->successResponse(new UserResource($user));
+            return $this->successResponse([
+                'id' => $user->id,
+                'username' => $user->username,
+                'email' => $user->email,
+            ]);
         }
 
         return $this->errorResponse(__('messages.incorrect_or_username_password'));

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

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\User\Controller;
+namespace App\User\Controllers;
 
 use App\Http\Controllers\Controller;
 use App\Traits\ApiResponse;
@@ -30,10 +30,10 @@ class ProfileController extends Controller
             'national_id' => $request->national_id,
             'address' => $request->address,
             'postal_code' => $request->postal_code,
-            'account_number' => $request->account_number,
             'phone_number' => $request->phone_number,
             'province_id' => $request->province_id,
             'city_id' => $request->city_id,
+            'status' => 1
         ]);
 
         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

@@ -2,6 +2,7 @@
 
 namespace App\User\Requests\Auth;
 
+use Illuminate\Contracts\Validation\ValidationRule;
 use Illuminate\Foundation\Http\FormRequest;
 
 class LoginRequest extends FormRequest
@@ -17,7 +18,7 @@ class LoginRequest extends FormRequest
     /**
      * Get the validation rules that apply to the request.
      *
-     * @return array<string, mixed>
+     * @return array<string, ValidationRule|array|string>
      */
     public function rules(): array
     {

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

@@ -2,6 +2,7 @@
 
 namespace App\User\Requests\Auth;
 
+use Illuminate\Contracts\Validation\ValidationRule;
 use Illuminate\Foundation\Http\FormRequest;
 
 class RegisterRequest extends FormRequest
@@ -17,14 +18,14 @@ class RegisterRequest extends FormRequest
     /**
      * Get the validation rules that apply to the request.
      *
-     * @return array<string, mixed>
+     * @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:',
+            'password' => 'required|string|regex:/^(?=.*[a-zA-Z])(?=.*\d).+$/|min:6|confirmed',
         ];
     }
 }

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

@@ -28,8 +28,7 @@ class EditRequest extends FormRequest
             'national_id' => 'required',
             'address' => 'required',
             'postal_code' => 'required',
-            'account_number' => 'required',
+            'phone_number' => 'required',
-            'phone_number' => 'required|regex:/^964\d{9}$/|numeric|digits:11',
             'province_id' => 'required',
             'city_id' => 'required',
         ];

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

@@ -17,10 +17,6 @@ class AuthorizationService
     {
         $this->url = config('fib.authorization.url');
         $this->channelName = '';
-    }
-
-    public function setInputParameters(): void
-    {
         $this->inputParameters = [
             'client_id' => config('fib.authorization.client_id'),
             'client_secret' => config('fib.authorization.client_secret'),
@@ -53,7 +49,7 @@ class AuthorizationService
      */
     public function sendRequest(): array
     {
-        return Http::withHeaders(['Content-Type' => 'application/json'])
+        return Http::asForm()
             ->throw()
             ->withoutVerifying()
             ->post($this->url, $this->inputParameters)

backend/bootstrap/app.php

@@ -10,10 +10,19 @@ return Application::configure(basePath: dirname(__DIR__))
         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()->validateCsrfTokens(['*']);
+        $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/config/auth.php

@@ -46,6 +46,10 @@ return [
             'driver' => 'passport',
             'provider' => 'users',
         ],
+        'expert' => [
+            'driver' => 'session',
+            'provider' => 'experts',
+        ]
     ],
 
     /*
@@ -70,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/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/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

@@ -18,17 +18,18 @@ return new class extends Migration
             $table->string('last_name')->nullable();
             $table->string('email')->unique();
             $table->string('password');
-            $table->tinyInteger('status')->default(0);
+            $table->tinyInteger('kyc_status')->default(0);
             $table->string('national_id')->nullable();
             $table->string('address')->nullable();
             $table->string('postal_code')->nullable();
-            $table->string('account_number')->nullable();
+            $table->string('tax_id')->nullable();
             $table->string('phone_number')->nullable();
-            $table->string('province_id')->nullable();
+            $table->date('birth_date')->nullable();
+            $table->foreignId('province_id')->nullable()->constrained('provinces');
             $table->string('province_name')->nullable();
-            $table->string('city_id')->nullable();
+            $table->foreignId('city_id')->nullable()->constrained('cities');
             $table->string('city_name')->nullable();
-
+            $table->tinyInteger('authority_level')->default(0);
             $table->timestamps();
         });
 

backend/database/migrations/2026_05_12_053258_create_documents_table.php

@@ -0,0 +1,30 @@
+<?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('documents', function (Blueprint $table) {
+            $table->id();
+            $table->morphs('documentable');
+            $table->string('title');
+            $table->string('url');
+            $table->timestamps();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('documents');
+    }
+};

backend/database/migrations/2026_05_12_074230_create_experts_table.php

@@ -0,0 +1,38 @@
+<?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('experts', function (Blueprint $table) {
+            $table->id();
+            $table->string('username');
+            $table->string('first_name')->nullable();
+            $table->string('last_name')->nullable();
+            $table->string('email')->unique();
+            $table->string('password');
+            $table->string('national_id')->nullable();
+            $table->string('phone_number')->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->timestamps();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('experts');
+    }
+};

backend/database/seeders/CitySeeder.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Database\Seeders;
+
+use Illuminate\Database\Console\Seeds\WithoutModelEvents;
+use Illuminate\Database\Seeder;
+
+class CitySeeder extends Seeder
+{
+    /**
+     * Run the database seeds.
+     */
+    public function run(): void
+    {
+        //
+    }
+}

backend/database/seeders/DocumentSeeder.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Database\Seeders;
+
+use Illuminate\Database\Console\Seeds\WithoutModelEvents;
+use Illuminate\Database\Seeder;
+
+class DocumentSeeder extends Seeder
+{
+    /**
+     * Run the database seeds.
+     */
+    public function run(): void
+    {
+        //
+    }
+}

backend/database/seeders/ExpertSeeder.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Database\Seeders;
+
+use Illuminate\Database\Console\Seeds\WithoutModelEvents;
+use Illuminate\Database\Seeder;
+
+class ExpertSeeder extends Seeder
+{
+    /**
+     * Run the database seeds.
+     */
+    public function run(): void
+    {
+        //
+    }
+}

backend/database/seeders/ProvinceSeeder.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Database\Seeders;
+
+use Illuminate\Database\Console\Seeds\WithoutModelEvents;
+use Illuminate\Database\Seeder;
+
+class ProvinceSeeder extends Seeder
+{
+    /**
+     * Run the database seeds.
+     */
+    public function run(): void
+    {
+        //
+    }
+}

backend/resources/lang/ar/notifications.php

@@ -0,0 +1,45 @@
+<?php
+
+return [
+    'exception_message' => 'رسالة استثناء: :message',
+    'exception_trace' => 'تتبع الإستثناء: :trace',
+    'exception_message_title' => 'رسالة استثناء',
+    'exception_trace_title' => 'تتبع الإستثناء',
+
+    'backup_failed_subject' => 'أخفق النسخ الاحتياطي لل :application_name',
+    'backup_failed_body' => 'مهم: حدث خطأ أثناء النسخ الاحتياطي :application_name',
+
+    'backup_successful_subject' => 'نسخ احتياطي جديد ناجح ل :application_name',
+    'backup_successful_subject_title' => 'نجاح النسخ الاحتياطي الجديد!',
+    'backup_successful_body' => 'أخبار عظيمة، نسخة احتياطية جديدة ل :application_name تم إنشاؤها بنجاح على القرص المسمى :disk_name.',
+
+    'cleanup_failed_subject' => 'فشل تنظيف النسخ الاحتياطي للتطبيق :application_name .',
+    'cleanup_failed_body' => 'حدث خطأ أثناء تنظيف النسخ الاحتياطية ل :application_name',
+
+    'cleanup_successful_subject' => 'تنظيف النسخ الاحتياطية ل :application_name تمت بنجاح',
+    'cleanup_successful_subject_title' => 'تنظيف النسخ الاحتياطية تم بنجاح!',
+    'cleanup_successful_body' => 'تنظيف النسخ الاحتياطية ل :application_name على القرص المسمى :disk_name تم بنجاح.',
+
+    'healthy_backup_found_subject' => 'النسخ الاحتياطية ل :application_name على القرص :disk_name صحية',
+    'healthy_backup_found_subject_title' => 'النسخ الاحتياطية ل :application_name صحية',
+    'healthy_backup_found_body' => 'تعتبر النسخ الاحتياطية ل :application_name صحية. عمل جيد!',
+
+    'unhealthy_backup_found_subject' => 'مهم: النسخ الاحتياطية ل :application_name غير صحية',
+    'unhealthy_backup_found_subject_title' => 'مهم: النسخ الاحتياطية ل :application_name غير صحية. :problem',
+    'unhealthy_backup_found_body' => 'النسخ الاحتياطية ل :application_name على القرص :disk_name غير صحية.',
+    'unhealthy_backup_found_not_reachable' => 'لا يمكن الوصول إلى وجهة النسخ الاحتياطي. :error',
+    'unhealthy_backup_found_empty' => 'لا توجد نسخ احتياطية لهذا التطبيق على الإطلاق.',
+    'unhealthy_backup_found_old' => 'تم إنشاء أحدث النسخ الاحتياطية في :date وتعتبر قديمة جدا.',
+    'unhealthy_backup_found_unknown' => 'عذرا، لا يمكن تحديد سبب دقيق.',
+    'unhealthy_backup_found_full' => 'النسخ الاحتياطية تستخدم الكثير من التخزين. الاستخدام الحالي هو :disk_usage وهو أعلى من الحد المسموح به من :disk_limit.',
+
+    'no_backups_info' => 'لم يتم عمل نسخ احتياطية حتى الآن',
+    'application_name' => 'اسم التطبيق',
+    'backup_name' => 'اسم النسخ الاحتياطي',
+    'disk' => 'القرص',
+    'newest_backup_size' => 'أحدث حجم للنسخ الاحتياطي',
+    'number_of_backups' => 'عدد النسخ الاحتياطية',
+    'total_storage_used' => 'إجمالي مساحة التخزين المستخدمة',
+    'newest_backup_date' => 'أحدث تاريخ النسخ الاحتياطي',
+    'oldest_backup_date' => 'أقدم تاريخ نسخ احتياطي',
+];

backend/resources/lang/en/auth.php

@@ -0,0 +1,20 @@
+<?php
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Authentication Language Lines
+    |--------------------------------------------------------------------------
+    |
+    | The following language lines are used during authentication for various
+    | messages that we need to display to the user. You are free to modify
+    | these language lines according to your application's requirements.
+    |
+    */
+
+    'failed' => 'These credentials do not match our records.',
+    'password' => 'The provided password is incorrect.',
+    'throttle' => 'Too many login attempts. Please try again in :seconds seconds.',
+
+];

backend/resources/lang/en/messages.php

@@ -0,0 +1,11 @@
+<?php
+
+return [
+    'successful' => 'The operation was successful.',
+    'invalid_credential' => 'Provided credential is invalid.',
+    'incorrect_current_password' => 'Current password is incorrect.',
+    'new_password_email_sent' => 'Your new password sent to your email',
+    'file_upload_failed' => 'The file can not be uploaded.',
+    'otp' => 'your otp token is : ',
+    'incorrect_otp' => 'Incorrect OTP code.',
+];

backend/resources/lang/en/pagination.php

@@ -0,0 +1,19 @@
+<?php
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Pagination Language Lines
+    |--------------------------------------------------------------------------
+    |
+    | The following language lines are used by the paginator library to build
+    | the simple pagination links. You are free to change them to anything
+    | you want to customize your views to better match your application.
+    |
+    */
+
+    'previous' => '&laquo; Previous',
+    'next' => 'Next &raquo;',
+
+];

backend/resources/lang/en/passwords.php

@@ -0,0 +1,22 @@
+<?php
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Password Reset Language Lines
+    |--------------------------------------------------------------------------
+    |
+    | The following language lines are the default lines which match reasons
+    | that are given by the password broker for a password update attempt
+    | has failed, such as for an invalid token or invalid new password.
+    |
+    */
+
+    'reset' => 'Your password has been reset.',
+    'sent' => 'We have emailed your password reset link.',
+    'throttled' => 'Please wait before retrying.',
+    'token' => 'This password reset token is invalid.',
+    'user' => "We can't find a user with that email address.",
+
+];

backend/resources/lang/en/validation.php

@@ -0,0 +1,186 @@
+<?php
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Validation Language Lines
+    |--------------------------------------------------------------------------
+    |
+    | The following language lines contain the default error messages used by
+    | the validator class. Some of these rules have multiple versions such
+    | as the size rules. Feel free to tweak each of these messages here.
+    |
+    */
+
+    'accepted' => 'The :attribute field must be accepted.',
+    'accepted_if' => 'The :attribute field must be accepted when :other is :value.',
+    'active_url' => 'The :attribute field must be a valid URL.',
+    'after' => 'The :attribute field must be a date after :date.',
+    'after_or_equal' => 'The :attribute field must be a date after or equal to :date.',
+    'alpha' => 'The :attribute field must only contain letters.',
+    'alpha_dash' => 'The :attribute field must only contain letters, numbers, dashes, and underscores.',
+    'alpha_num' => 'The :attribute field must only contain letters and numbers.',
+    'array' => 'The :attribute field must be an array.',
+    'ascii' => 'The :attribute field must only contain single-byte alphanumeric characters and symbols.',
+    'before' => 'The :attribute field must be a date before :date.',
+    'before_or_equal' => 'The :attribute field must be a date before or equal to :date.',
+    'between' => [
+        'array' => 'The :attribute field must have between :min and :max items.',
+        'file' => 'The :attribute field must be between :min and :max kilobytes.',
+        'numeric' => 'The :attribute field must be between :min and :max.',
+        'string' => 'The :attribute field must be between :min and :max characters.',
+    ],
+    'boolean' => 'The :attribute field must be true or false.',
+    'confirmed' => 'The :attribute field confirmation does not match.',
+    'current_password' => 'The password is incorrect.',
+    'date' => 'The :attribute field must be a valid date.',
+    'date_equals' => 'The :attribute field must be a date equal to :date.',
+    'date_format' => 'The :attribute field must match the format :format.',
+    'decimal' => 'The :attribute field must have :decimal decimal places.',
+    'declined' => 'The :attribute field must be declined.',
+    'declined_if' => 'The :attribute field must be declined when :other is :value.',
+    'different' => 'The :attribute field and :other must be different.',
+    'digits' => 'The :attribute field must be :digits digits.',
+    'digits_between' => 'The :attribute field must be between :min and :max digits.',
+    'dimensions' => 'The :attribute field has invalid image dimensions.',
+    'distinct' => 'The :attribute field has a duplicate value.',
+    'doesnt_end_with' => 'The :attribute field must not end with one of the following: :values.',
+    'doesnt_start_with' => 'The :attribute field must not start with one of the following: :values.',
+    'email' => 'The :attribute field must be a valid email address.',
+    'ends_with' => 'The :attribute field must end with one of the following: :values.',
+    'enum' => 'The selected :attribute is invalid.',
+    'exists' => 'The selected :attribute is invalid.',
+    'file' => 'The :attribute field must be a file.',
+    'filled' => 'The :attribute field must have a value.',
+    'gt' => [
+        'array' => 'The :attribute field must have more than :value items.',
+        'file' => 'The :attribute field must be greater than :value kilobytes.',
+        'numeric' => 'The :attribute field must be greater than :value.',
+        'string' => 'The :attribute field must be greater than :value characters.',
+    ],
+    'gte' => [
+        'array' => 'The :attribute field must have :value items or more.',
+        'file' => 'The :attribute field must be greater than or equal to :value kilobytes.',
+        'numeric' => 'The :attribute field must be greater than or equal to :value.',
+        'string' => 'The :attribute field must be greater than or equal to :value characters.',
+    ],
+    'image' => 'The :attribute field must be an image.',
+    'in' => 'The selected :attribute is invalid.',
+    'in_array' => 'The :attribute field must exist in :other.',
+    'integer' => 'The :attribute field must be an integer.',
+    'ip' => 'The :attribute field must be a valid IP address.',
+    'ipv4' => 'The :attribute field must be a valid IPv4 address.',
+    'ipv6' => 'The :attribute field must be a valid IPv6 address.',
+    'json' => 'The :attribute field must be a valid JSON string.',
+    'lowercase' => 'The :attribute field must be lowercase.',
+    'lt' => [
+        'array' => 'The :attribute field must have less than :value items.',
+        'file' => 'The :attribute field must be less than :value kilobytes.',
+        'numeric' => 'The :attribute field must be less than :value.',
+        'string' => 'The :attribute field must be less than :value characters.',
+    ],
+    'lte' => [
+        'array' => 'The :attribute field must not have more than :value items.',
+        'file' => 'The :attribute field must be less than or equal to :value kilobytes.',
+        'numeric' => 'The :attribute field must be less than or equal to :value.',
+        'string' => 'The :attribute field must be less than or equal to :value characters.',
+    ],
+    'mac_address' => 'The :attribute field must be a valid MAC address.',
+    'max' => [
+        'array' => 'The :attribute field must not have more than :max items.',
+        'file' => 'The :attribute field must not be greater than :max kilobytes.',
+        'numeric' => 'The :attribute field must not be greater than :max.',
+        'string' => 'The :attribute field must not be greater than :max characters.',
+    ],
+    'max_digits' => 'The :attribute field must not have more than :max digits.',
+    'mimes' => 'The :attribute field must be a file of type: :values.',
+    'mimetypes' => 'The :attribute field must be a file of type: :values.',
+    'min' => [
+        'array' => 'The :attribute field must have at least :min items.',
+        'file' => 'The :attribute field must be at least :min kilobytes.',
+        'numeric' => 'The :attribute field must be at least :min.',
+        'string' => 'The :attribute field must be at least :min characters.',
+    ],
+    'min_digits' => 'The :attribute field must have at least :min digits.',
+    'missing' => 'The :attribute field must be missing.',
+    'missing_if' => 'The :attribute field must be missing when :other is :value.',
+    'missing_unless' => 'The :attribute field must be missing unless :other is :value.',
+    'missing_with' => 'The :attribute field must be missing when :values is present.',
+    'missing_with_all' => 'The :attribute field must be missing when :values are present.',
+    'multiple_of' => 'The :attribute field must be a multiple of :value.',
+    'not_in' => 'The selected :attribute is invalid.',
+    'not_regex' => 'The :attribute field format is invalid.',
+    'numeric' => 'The :attribute field must be a number.',
+    'password' => [
+        'letters' => 'The :attribute field must contain at least one letter.',
+        'mixed' => 'The :attribute field must contain at least one uppercase and one lowercase letter.',
+        'numbers' => 'The :attribute field must contain at least one number.',
+        'symbols' => 'The :attribute field must contain at least one symbol.',
+        'uncompromised' => 'The given :attribute has appeared in a data leak. Please choose a different :attribute.',
+    ],
+    'present' => 'The :attribute field must be present.',
+    'prohibited' => 'The :attribute field is prohibited.',
+    'prohibited_if' => 'The :attribute field is prohibited when :other is :value.',
+    'prohibited_unless' => 'The :attribute field is prohibited unless :other is in :values.',
+    'prohibits' => 'The :attribute field prohibits :other from being present.',
+    'regex' => 'The :attribute field format is invalid.',
+    'required' => 'The :attribute field is required.',
+    'required_array_keys' => 'The :attribute field must contain entries for: :values.',
+    'required_if' => 'The :attribute field is required when :other is :value.',
+    'required_if_accepted' => 'The :attribute field is required when :other is accepted.',
+    'required_unless' => 'The :attribute field is required unless :other is in :values.',
+    'required_with' => 'The :attribute field is required when :values is present.',
+    'required_with_all' => 'The :attribute field is required when :values are present.',
+    'required_without' => 'The :attribute field is required when :values is not present.',
+    'required_without_all' => 'The :attribute field is required when none of :values are present.',
+    'same' => 'The :attribute field must match :other.',
+    'size' => [
+        'array' => 'The :attribute field must contain :size items.',
+        'file' => 'The :attribute field must be :size kilobytes.',
+        'numeric' => 'The :attribute field must be :size.',
+        'string' => 'The :attribute field must be :size characters.',
+    ],
+    'starts_with' => 'The :attribute field must start with one of the following: :values.',
+    'string' => 'The :attribute field must be a string.',
+    'timezone' => 'The :attribute field must be a valid timezone.',
+    'unique' => 'The :attribute has already been taken.',
+    'uploaded' => 'The :attribute failed to upload.',
+    'uppercase' => 'The :attribute field must be uppercase.',
+    'url' => 'The :attribute field must be a valid URL.',
+    'ulid' => 'The :attribute field must be a valid ULID.',
+    'uuid' => 'The :attribute field must be a valid UUID.',
+
+    /*
+    |--------------------------------------------------------------------------
+    | Custom Validation Language Lines
+    |--------------------------------------------------------------------------
+    |
+    | Here you may specify custom validation messages for attributes using the
+    | convention "attribute.rule" to name the lines. This makes it quick to
+    | specify a specific custom language line for a given attribute rule.
+    |
+    */
+
+    'custom' => [
+        'attribute-name' => [
+            'rule-name' => 'custom-message',
+        ],
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Custom Validation Attributes
+    |--------------------------------------------------------------------------
+    |
+    | The following language lines are used to swap our attribute placeholder
+    | with something more reader friendly such as "E-Mail Address" instead
+    | of "email". This simply helps us make our message more expressive.
+    |
+    */
+
+    'attributes' => [
+        'phone_number' => 'phone number',
+    ],
+
+];

backend/resources/lang/fa/auth.php

@@ -0,0 +1,20 @@
+<?php
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Authentication Language Lines
+    |--------------------------------------------------------------------------
+    |
+    | The following language lines are used during authentication for various
+    | messages that we need to display to the user. You are free to modify
+    | these language lines according to your application's requirements.
+    |
+    */
+
+    'failed' => 'اطلاعات وارد شده صحیح نمی باشد',
+    'password' => 'رمزعبور صحیح نیست',
+    'throttle' => 'درخواست بیش از حد مجاز! لطفا بعد از :seconds ثانیه دوباره امتحان کنید',
+
+];

backend/resources/lang/fa/messages.php

@@ -0,0 +1,11 @@
+<?php
+
+return [
+    'successful' => 'عملیات با موفقیت انجام شد.',
+    'invalid_credential' => 'نام کاربری یا رمز عبور اشتباه است',
+    'incorrect_current_password' => 'رمز عبور فعلی اشتباه است',
+    'new_password_email_sent' => 'رمز عبور جدید به ایمیل شما ارسال شد.',
+    'file_upload_failed' => 'بارگذاری فایل با خطا مواجه شد.',
+    'otp' => 'کد ورود شما : ',
+    'incorrect_otp' => 'کد تایید اشتباه است .',
+];

backend/resources/lang/fa/pagination.php

@@ -0,0 +1,19 @@
+<?php
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Pagination Language Lines
+    |--------------------------------------------------------------------------
+    |
+    | The following language lines are used by the paginator library to build
+    | the simple pagination links. You are free to change them to anything
+    | you want to customize your views to better match your application.
+    |
+    */
+
+    'previous' => '&laquo; قبلی',
+    'next' => 'بعدی &raquo;',
+
+];

backend/resources/lang/fa/passwords.php

@@ -0,0 +1,22 @@
+<?php
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Password Reset Language Lines
+    |--------------------------------------------------------------------------
+    |
+    | The following language lines are the default lines which match reasons
+    | that are given by the password broker for a password update attempt
+    | has failed, such as for an invalid token or invalid new password.
+    |
+    */
+
+    'reset' => 'رمز عبور شما با موفقیت بازیابی شد',
+    'sent' => 'ایمیلی جهت بازیابی رمزعبور برای شما ارسال شد',
+    'throttled' => 'لطفا اندکی صبر کنید و دوباره امتحان کنید',
+    'token' => 'مشخصه بازیابی رمزعبور شما صحیح نمی باشد',
+    'user' => "کاربری با این اطلاعات وجود ندارد",
+
+];

backend/resources/lang/fa/validation.php

@@ -0,0 +1,192 @@
+<?php
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Validation Language Lines
+    |--------------------------------------------------------------------------
+    |
+    | The following language lines contain the default error messages used by
+    | the validator class. Some of these rules have multiple versions such
+    | as the size rules. Feel free to tweak each of these messages here.
+    |
+    */
+
+    'accepted' => 'گزینه :attribute باید تایید شود',
+    'accepted_if' => 'زمانی که گزینه :other برابر :value است :attribute باید تایید شود',
+    'active_url' => 'گزینه :attribute یک آدرس سایت معتبر نیست',
+    'after' => 'گزینه :attribute باید تاریخی بعد از :date باشد',
+    'after_or_equal' => 'گزینه :attribute باید تاریخی مساوی یا بعد از :date باشد',
+    'alpha' => 'گزینه :attribute باید تنها شامل حروف باشد',
+    'alpha_dash' => 'گزینه :attribute باید تنها شامل حروف، اعداد، خط تیره و زیر خط باشد',
+    'alpha_num' => 'گزینه :attribute باید تنها شامل حروف و اعداد باشد',
+    'array' => 'گزینه :attribute باید آرایه باشد',
+    'ascii' => 'گزینه :attribute تنها میتواند شامل تک حرف، عدد یا نماد ها باشد. .',
+    'before' => 'گزینه :attribute باید تاریخی قبل از :date باشد',
+    'before_or_equal' => 'گزینه :attribute باید تاریخی مساوی یا قبل از :date باشد',
+    'between' => [
+        'array' => 'گزینه :attribute باید بین :min و :max آیتم باشد',
+        'file' => 'گزینه :attribute باید بین :min و :max کیلوبایت باشد',
+        'numeric' => 'گزینه :attribute باید بین :min و :max باشد',
+        'string' => 'گزینه :attribute باید بین :min و :max کاراکتر باشد',
+    ],
+    'boolean' => 'گزینه :attribute تنها می تواند صحیح یا غلط باشد',
+    'confirmed' => 'تایید مجدد گزینه :attribute صحیح نمی باشد',
+    'current_password' => 'رمزعبور صحیح نمی باشد',
+    'date' => 'گزینه :attribute یک تاریخ صحیح نمی باشد',
+    'date_equals' => 'گزینه :attribute باید تاریخی مساوی با :date باشد',
+    'date_format' => 'گزینه :attribute با فرمت :format همخوانی ندارد',
+    'decimal' => 'گزینه :attribute باید :decimal رقم اعشار داشته باشد.',
+    'declined' => 'گزینه :attribute باید رد شود',
+    'declined_if' => 'گزینه :attribute زمانی که :other برابر :value است باید رد شود',
+    'different' => 'گزینه :attribute و :other باید متفاوت باشند',
+    'digits' => 'گزینه :attribute باید :digits عدد باشد',
+    'digits_between' => 'گزینه :attribute باید بین :min و :max عدد باشد',
+    'dimensions' => 'ابعاد تصویر گزینه :attribute مجاز نمی باشد',
+    'distinct' => 'گزینه :attribute دارای افزونگی داده می باشد',
+    'doesnt_end_with' => 'گزینه :attribute نباید با این مقادیر به پایان برسد: :values.',
+    'doesnt_start_with' => 'گزینه :attribute نباید با این مقادیر شروع شود: :values.',
+    'email' => 'گزینه :attribute باید یک آدرس ایمیل صحیح باشد',
+    'ends_with' => 'گزینه :attribute باید با یکی از این مقادیر پایان یابد، :values',
+    'enum' => 'گزینه :attribute صحیح نمی باشد',
+    'exists' => 'گزینه انتخاب شده :attribute صحیح نمی باشد',
+    'file' => 'گزینه :attribute باید یک فایل باشد',
+    'filled' => 'گزینه :attribute نمی تواند خالی باشد',
+    'gt' => [
+        'array' => 'گزینه :attribute باید بیشتر از :value آیتم باشد',
+        'file' => 'گزینه :attribute باید بزرگتر از :value کیلوبایت باشد',
+        'numeric' => 'گزینه :attribute باید بزرگتر از :value باشد',
+        'string' => 'گزینه :attribute باید بزرگتر از :value کاراکتر باشد',
+    ],
+    'gte' => [
+        'array' => 'گزینه :attribute باید :value آیتم یا بیشتر داشته باشد',
+        'file' => 'گزینه :attribute باید بزرگتر یا مساوی :value کیلوبایت باشد',
+        'numeric' => 'گزینه :attribute باید بزرگتر یا مساوی :value باشد',
+        'string' => 'گزینه :attribute باید بزرگتر یا مساوی :value کاراکتر باشد',
+    ],
+    'image' => 'گزینه :attribute باید از نوع تصویر باشد',
+    'in' => 'گزینه انتخابی :attribute صحیح نمی باشد',
+    'in_array' => 'گزینه :attribute در :other وجود ندارد',
+    'integer' => 'گزینه :attribute باید از نوع عددی باشد',
+    'ip' => 'گزینه :attribute باید آی پی آدرس باشد',
+    'ipv4' => 'گزینه :attribute باید آی پی آدرس ورژن 4 باشد',
+    'ipv6' => 'گزینه :attribute باید آی پی آدرس ورژن 6 باشد',
+    'json' => 'گزینه :attribute باید از نوع رشته جیسون باشد',
+    'lowercase' => 'گزینه :attribute باید با حروف کوچک باشد.',
+    'lt' => [
+        'array' => 'گزینه :attribute باید کمتر از :value آیتم داشته باشد',
+        'file' => 'گزینه :attribute باید کمتر از :value کیلوبایت باشد',
+        'numeric' => 'گزینه :attribute باید کمتر از :value باشد',
+        'string' => 'گزینه :attribute باید کمتر از :value کاراکتر باشد',
+    ],
+    'lte' => [
+        'array' => 'گزینه :attribute نباید کمتر از :value آیتم داشته باشد',
+        'file' => 'گزینه :attribute باید مساوی یا کمتر از :value کیلوبایت باشد',
+        'numeric' => 'گزینه :attribute باید مساوی یا کمتر از :value باشد',
+        'string' => 'گزینه :attribute باید مساوی یا کمتر از :value کاراکتر باشد',
+    ],
+    'mac_address' => 'گزینه :attribute باید یک مک آدرس معتبر باشد',
+    'max' => [
+        'array' => 'گزینه :attribute نباید بیشتر از :max آیتم داشته باشد',
+        'file' => 'گزینه :attribute نباید بزرگتر از :max کیلوبایت باشد',
+        'numeric' => 'گزینه :attribute نباید بزرگتر از :max باشد',
+        'string' => 'گزینه :attribute نباید بزرگتر از :max کاراکتر باشد',
+    ],
+    'max_digits' => 'گزینه :attribute نباید بیشتر از :max رقم باشد',
+    'mimes' => 'گزینه :attribute باید دارای یکی از این فرمت ها باشد: :values',
+    'mimetypes' =>  'گزینه :attribute باید دارای یکی از این فرمت ها باشد: :values',
+    'min' => [
+        'array' => 'گزینه :attribute باید حداقل :min آیتم داشته باشد',
+        'file' => 'گزینه :attribute باید حداقل :min کیلوبایت باشد',
+        'numeric' => 'گزینه :attribute باید حداقل :min باشد',
+        'string' => 'گزینه :attribute باید حداقل :min کاراکتر باشد',
+    ],
+    'min_digits' => 'گزینه :attribute باید حداقل :min رقم باشد',
+    'missing' => 'گزینه :attribute نباید تعریف شود.',
+    'missing_if' => 'گزینه :attribute زمانی که مقدار :other برابر :value می باشد، نباید تعریف شود',
+    'missing_unless' => 'گزینه :attribute نباید تعریف شود مگر اینکه گزینه :other برابر :value باشد',
+    'missing_with' => 'گزینه :attribute زمانی که مقدار :values تعریف شده است دیگر نباید تعریف شود.',
+    'missing_with_all' => 'گزینه :attribute زمانی که :values مقدار دارد دیگر نباید تعریف شود.',
+    'multiple_of' => 'گزینه :attribute باید حاصل ضرب :value باشد',
+    'not_in' => 'گزینه انتخابی :attribute صحیح نمی باشد',
+    'not_regex' => 'فرمت گزینه :attribute صحیح نمی باشد',
+    'numeric' => 'گزینه :attribute باید از نوع عددی باشد',
+    'password' => [
+        'letters' => 'گزینه :attribute باید حداقل شامل یک حرف باشد',
+        'mixed' => 'گزینه :attribute باید شامل حداقل یک حرف بزرگ و یک حرف کوچک باشد',
+        'numbers' => 'گزینه :attribute باید شامل حداقل یک عدد باشد',
+        'symbols' => 'گزینه :attribute باید شامل حداقل یک کارکتر خاص باشد',
+        'uncompromised' => 'محتوای وارده شده در :attribute ایمن نمی باشد. لطفا گزینه :attribute را اصلاح فرمایید',
+    ],
+    'present' => 'گزینه :attribute باید از نوع درصد باشد',
+    'prohibited' => 'گزینه :attribute مجاز نمی باشد',
+    'prohibited_if' => 'گزینه :attribute زمانی که :other برابر :value باشد مجاز نمی باشد',
+    'prohibited_unless' => 'گزینه :attribute مجاز نیست مگر :other برابر :values باشد',
+    'prohibits' => 'گزینه :attribute باعث ممنوعیت :other می باشد',
+    'regex' => 'فرمت گزینه :attribute صحیح نمی باشد',
+    'required' => 'تکمیل گزینه :attribute الزامی است',
+    'required_array_keys' => 'گزینه :attribute باید شامل مقادیر: :values باشد',
+    'required_if' => 'تکمیل گزینه :attribute زمانی که :other دارای مقدار :value است الزامی می باشد',
+    'required_if_accepted' => 'تکمیل گزینه :attribute زمانی که :other انتخاب شده الزامی است',
+    'required_unless' => 'تکمیل گزینه :attribute الزامی می باشد مگر :other دارای مقدار :values باشد',
+    'required_with' => 'تکمیل گزینه :attribute زمانی که مقدار :values درصد است الزامی است',
+    'required_with_all' => 'تکمیل گزینه :attribute زمانی که مقادیر :values درصد است الزامی می باشد',
+    'required_without' => 'تکمیل گزینه :attribute زمانی که مقدار :values درصد نیست الزامی است',
+    'required_without_all' => 'تکمیل گزینه :attribute زمانی که هیچ کدام از مقادیر :values درصد نیست الزامی است',
+    'same' => 'گزینه های :attribute و :other باید یکی باشند',
+    'size' => [
+        'array' => 'گزینه :attribute باید شامل :size آیتم باشد',
+        'file' => 'گزینه :attribute باید :size کیلوبایت باشد',
+        'numeric' => 'گزینه :attribute باید :size باشد',
+        'string' => 'گزینه :attribute باید :size  کاراکتر باشد',
+    ],
+    'starts_with' => 'گزینه :attribute باید با یکی از این مقادیر شروع شود، :values',
+    'string' => 'گزینه :attribute باید تنها شامل حروف باشد',
+    'timezone' => 'گزینه :attribute باید از نوع منطقه زمانی صحیح باشد',
+    'unique' => 'این :attribute از قبل ثبت شده است',
+    'uploaded' => 'بارگذاری گزینه :attribute شکست خورد',
+    'uppercase' => 'گزینه :attribute باید با حروف بزرگ باشد',
+    'url' => 'فرمت :attribute اشتباه است',
+    'ulid' => 'گزینه :attribute باید یک ULID صحیح باشد.',
+    'uuid' => 'گزینه :attribute باید یک UUID صحیح باشد',
+
+    /*
+    |--------------------------------------------------------------------------
+    | Custom Validation Language Lines
+    |--------------------------------------------------------------------------
+    |
+    | Here you may specify custom validation messages for attributes using the
+    | convention "attribute.rule" to name the lines. This makes it quick to
+    | specify a specific custom language line for a given attribute rule.
+    |
+    */
+
+    'custom' => [
+        'attribute-name' => [
+            'rule-name' => 'custom-message',
+        ],
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Custom Validation Attributes
+    |--------------------------------------------------------------------------
+    |
+    | The following language lines are used to swap our attribute placeholder
+    | with something more reader friendly such as "E-Mail Address" instead
+    | of "email". This simply helps us make our message more expressive.
+    |
+    */
+
+    'attributes' => [
+        'name' => 'نام',
+        'username' => 'نام کاربری',
+        'email' => 'ایمیل',
+        'first_name' => 'نام',
+        'last_name' => 'نام خانوادگی',
+        'password' => 'رمز عبور',
+        'password_confirmation' => 'تاییدیه رمز عبور',
+    ],
+
+];

backend/resources/views/emails/login-notification.blade.php

@@ -0,0 +1,24 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>Login Notification</title>
+</head>
+<body>
+<h2>Hello {{ $user->username }}</h2>
+
+<p>You have successfully logged in to your account.</p>
+
+<p>
+    Email: {{ $user->email }}
+</p>
+
+<p>
+    If this login was not done by you, please contact support immediately.
+</p>
+
+<br>
+
+<p>Thank you.</p>
+</body>
+</html>

backend/routes/api.php

@@ -1,10 +1,8 @@
 <?php
 
-use App\User\Controller\Auth\AuthController;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Route;
 
 Route::get('/user', function (Request $request) {
     return $request->user();
 })->middleware('auth:api');
-

backend/routes/expert.php

@@ -0,0 +1,14 @@
+<?php
+
+use App\Admin\Controllers\DocumentationController;
+
+Route::prefix('documents')
+    ->name('documents.')
+    ->middleware('auth')
+    ->controller(DocumentationController::class)
+    ->group(function () {
+        Route::get('/', 'index')->name('index');
+        Route::post('confirm', 'confirm')->name('confirm');
+        Route::post('reject', 'reject')->name('reject');
+        Route::get('files/{user}', 'files')->name('files');
+    });

backend/routes/web.php

@@ -1,7 +1,7 @@
 <?php
 
-use App\User\Controller\Auth\AuthController;
+use App\User\Controllers\AuthController;
-use App\User\Controller\ProfileController;
+use App\User\Controllers\ProfileController;
 use Illuminate\Support\Facades\Route;
 
 Route::prefix('auth')