init form laravel-base-project branch laravel-10-upgrade

.editorconfig

@@ -0,0 +1,21 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 4
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.md]
+trim_trailing_whitespace = false
+
+[*.{yml,yaml}]
+indent_size = 2
+
+[docker-compose.yml]
+indent_size = 4
+
+[*.vue]
+indent_size = 2

.env

@@ -0,0 +1,58 @@
+APP_NAME=Laravel
+APP_ENV=local
+APP_KEY=base64:rnPQG7pzyDqpzrZfaHO/SKZxJ0JIeyEM+18k2vu1Nh0=
+APP_DEBUG=true
+APP_URL=http://localhost
+
+LOG_CHANNEL=stack
+LOG_DEPRECATIONS_CHANNEL=null
+LOG_LEVEL=debug
+
+DB_CONNECTION=mysql
+DB_HOST=dev-mariadb
+DB_PORT=3306
+DB_DATABASE=local-op-insta
+DB_USERNAME=root
+DB_PASSWORD=secret
+
+BROADCAST_DRIVER=log
+CACHE_DRIVER=file
+FILESYSTEM_DISK=local
+QUEUE_CONNECTION=sync
+SESSION_DRIVER=file
+SESSION_LIFETIME=120
+
+MEMCACHED_HOST=127.0.0.1
+
+REDIS_HOST=127.0.0.1
+REDIS_PASSWORD=null
+REDIS_PORT=6379
+
+MAIL_MAILER=smtp
+MAIL_HOST=mailpit
+MAIL_PORT=1025
+MAIL_USERNAME=null
+MAIL_PASSWORD=null
+MAIL_ENCRYPTION=null
+MAIL_FROM_ADDRESS="hello@example.com"
+MAIL_FROM_NAME="${APP_NAME}"
+
+AWS_ACCESS_KEY_ID=
+AWS_SECRET_ACCESS_KEY=
+AWS_DEFAULT_REGION=us-east-1
+AWS_BUCKET=
+AWS_USE_PATH_STYLE_ENDPOINT=false
+
+PUSHER_APP_ID=
+PUSHER_APP_KEY=
+PUSHER_APP_SECRET=
+PUSHER_HOST=
+PUSHER_PORT=443
+PUSHER_SCHEME=https
+PUSHER_APP_CLUSTER=mt1
+
+VITE_PUSHER_APP_KEY="${PUSHER_APP_KEY}"
+VITE_PUSHER_HOST="${PUSHER_HOST}"
+VITE_PUSHER_PORT="${PUSHER_PORT}"
+VITE_PUSHER_SCHEME="${PUSHER_SCHEME}"
+VITE_PUSHER_APP_CLUSTER="${PUSHER_APP_CLUSTER}"

.env.example

@@ -0,0 +1,58 @@
+APP_NAME=Laravel
+APP_ENV=local
+APP_KEY=
+APP_DEBUG=true
+APP_URL=http://localhost
+
+LOG_CHANNEL=stack
+LOG_DEPRECATIONS_CHANNEL=null
+LOG_LEVEL=debug
+
+DB_CONNECTION=mysql
+DB_HOST=127.0.0.1
+DB_PORT=3306
+DB_DATABASE=laravel
+DB_USERNAME=root
+DB_PASSWORD=
+
+BROADCAST_DRIVER=log
+CACHE_DRIVER=file
+FILESYSTEM_DISK=local
+QUEUE_CONNECTION=sync
+SESSION_DRIVER=file
+SESSION_LIFETIME=120
+
+MEMCACHED_HOST=127.0.0.1
+
+REDIS_HOST=127.0.0.1
+REDIS_PASSWORD=null
+REDIS_PORT=6379
+
+MAIL_MAILER=smtp
+MAIL_HOST=mailpit
+MAIL_PORT=1025
+MAIL_USERNAME=null
+MAIL_PASSWORD=null
+MAIL_ENCRYPTION=null
+MAIL_FROM_ADDRESS="hello@example.com"
+MAIL_FROM_NAME="${APP_NAME}"
+
+AWS_ACCESS_KEY_ID=
+AWS_SECRET_ACCESS_KEY=
+AWS_DEFAULT_REGION=us-east-1
+AWS_BUCKET=
+AWS_USE_PATH_STYLE_ENDPOINT=false
+
+PUSHER_APP_ID=
+PUSHER_APP_KEY=
+PUSHER_APP_SECRET=
+PUSHER_HOST=
+PUSHER_PORT=443
+PUSHER_SCHEME=https
+PUSHER_APP_CLUSTER=mt1
+
+VITE_PUSHER_APP_KEY="${PUSHER_APP_KEY}"
+VITE_PUSHER_HOST="${PUSHER_HOST}"
+VITE_PUSHER_PORT="${PUSHER_PORT}"
+VITE_PUSHER_SCHEME="${PUSHER_SCHEME}"
+VITE_PUSHER_APP_CLUSTER="${PUSHER_APP_CLUSTER}"

.eslintrc.json

@@ -0,0 +1,55 @@
+{
+    "env": {
+        "browser": true,
+        "es2021": true
+    },
+    "extends": [
+        "eslint:recommended",
+        "plugin:vue/vue3-strongly-recommended",
+        "@vue/eslint-config-typescript"
+    ],
+    "overrides": [
+        {
+        "files": ["*.ts", "*.vue"],
+        "rules": {
+            "no-undef": "off"
+        }
+        },
+        {
+        "files": ["*.vue"],
+        "rules": {
+            "indent": "off"
+        }
+        }
+    ],
+    "parser": "vue-eslint-parser",
+    "parserOptions": {
+        "parser": "@typescript-eslint/parser",
+        "ecmaVersion": "latest",
+        "sourceType": "module"
+    },
+    "plugins": ["vue", "@typescript-eslint"],
+    "ignorePatterns": ["webpack.mix.js", "**/vendor/*.js", "**/vendor/**/*.js"],
+    "rules": {
+        "indent": ["error", 4, { "SwitchCase": 1 }],
+        "linebreak-style": ["error", "unix"],
+        "quotes": ["error", "double"],
+        "semi": ["error", "always"],
+        "vue/script-indent": ["error", 2, { "baseIndent": 0, "switchCase": 1 }],
+        "vue/one-component-per-file": "off"
+    },
+    "settings": {
+        "import/resolver": {
+            "node": {
+                "extensions": [".js", ".vue", ".ts", ".d.ts"]
+            },
+            "alias": {
+                "extensions": [".vue", ".js", ".ts", ".scss", ".d.ts"],
+                "map": [
+                    ["~", "./resources/assets"],
+                    ["@", "./node_modules"]
+                ]
+            }
+        }
+    }
+}

.gitattributes

@@ -0,0 +1,11 @@
+* text=auto eol=lf
+
+*.blade.php diff=html
+*.css diff=css
+*.html diff=html
+*.md diff=markdown
+*.php diff=php
+
+/.github export-ignore
+CHANGELOG.md export-ignore
+.styleci.yml export-ignore

.gitignore

@@ -0,0 +1,23 @@
+.env
+.env.backup
+.env.production
+.phpunit.result.cache
+.stylelintcache
+/.fleet
+/.idea
+/.phpunit.cache
+/.vscode
+/node_modules
+/public/build
+/public/cache
+/public/hot
+/public/sitemap.xml
+/public/storage
+/storage/*.key
+/vendor
+auth.json
+docker-compose.override.yml
+Homestead.json
+Homestead.yaml
+npm-debug.log
+yarn-error.log

.gitlab-ci.yml

@@ -0,0 +1,24 @@
+include:
+  - project: 'ldc-web/shared-ci'
+    ref: 'main'
+    file: 'lint/lint.yml'
+  - project: 'ldc-web/shared-ci'
+    ref: 'main'
+    file: 'security/security.yml'
+  - project: 'ldc-web/shared-ci'
+    ref: 'main'
+    file: 'build/build.yml'
+  - project: 'ldc-web/shared-ci'
+    ref: 'main'
+    file: 'test/test.yml'
+  - project: 'ldc-web/shared-ci'
+    ref: 'main'
+    file: 'deploy/deploy.yml'
+
+
+stages:
+    - lint
+    - security
+    - build
+    - test
+    - deploy

.gitlab/issue_templates/bug.md

@@ -0,0 +1,11 @@
+## Comportement constaté
+
+
+## Comportement attendu
+
+
+## Solution envisagée
+
+
+## Étapes pour la reproduction du bug
+* 

.gitlab/issue_templates/feature.md

@@ -0,0 +1,7 @@
+## Présentation du besoin
+
+
+## Implémentation
+
+
+## Maquettes, documentations...

.stylelintrc.json

@@ -0,0 +1,43 @@
+{
+    "extends": [
+        "stylelint-config-standard-scss",
+        "stylelint-config-sass-guidelines",
+        "stylelint-config-idiomatic-order"
+    ],
+    "plugins": ["stylelint-scss"],
+    "files": ["**/*.css", "**/*.scss"],
+    "ignoreFiles": [
+        "**/vendor/*.css",
+        "**/vendor/**/*.css",
+        "**/vendor/*.scss",
+        "**/vendor/**/*.scss",
+        "**/vendor/*.sass",
+        "**/vendor/**/*.sass",
+        "**/vendor/*.less",
+        "**/vendor/**/*.less"
+    ],
+    "customSyntax": "postcss-scss",
+    "rules": {
+        "indentation": 4,
+        "string-quotes": "double",
+        "selector-max-id": null,
+        "color-no-invalid-hex": true,
+        "order/properties-alphabetical-order": null,
+        "max-nesting-depth": 5,
+        "selector-max-compound-selectors": 5,
+        "declaration-colon-space-after": "always-single-line",
+        "function-parentheses-space-inside": "never-single-line",
+        "declaration-colon-newline-after": null,
+        "value-list-comma-newline-after": null,
+        "scss/double-slash-comment-empty-line-before": [
+            "always",
+            {
+                "ignore": [
+                    "between-comments",
+                    "stylelint-commands",
+                    "inside-block"
+                ]
+            }
+        ]
+    }
+}

.vscode/extensions.json

@@ -0,0 +1,21 @@
+{
+    "recommendations": [
+        "esbenp.prettier-vscode",
+        "rvest.vs-code-prettier-eslint",
+        "onecentlin.laravel-extension-pack",
+        "johnpapa.vscode-peacock",
+        "xdebug.php-debug",
+        "neilbrayfield.php-docblocker",
+        "bmewburn.vscode-intelephense-client",
+        "valeryanm.vscode-phpsab",
+        "shevaua.phpcs",
+        "syler.sass-indented",
+        "sibiraj-s.vscode-scss-formatter",
+        "mrmlnc.vscode-scss",
+        "stylelint.vscode-stylelint",
+        "vue.vscode-typescript-vue-plugin",
+        "wscats.vue",
+        "vue.volar",
+        "misterj.vue-volar-extention-pack"
+    ]
+}

.vscode/settings.json

@@ -0,0 +1,26 @@
+{
+    "workbench.colorCustomizations": {
+        "activityBar.activeBackground": "#e4f100",
+        "activityBar.activeBorder": "#1a1d02",
+        "activityBar.background": "#e4f100",
+        "activityBar.foreground": "#15202b",
+        "activityBar.inactiveForeground": "#15202b99",
+        "activityBarBadge.background": "#00b5bf",
+        "activityBarBadge.foreground": "#15202b",
+        "sash.hoverBorder": "#e4f100",
+        "statusBar.background": "#b4be00",
+        "statusBar.foreground": "#15202b",
+        "statusBarItem.hoverBackground": "#848b00",
+        "statusBarItem.remoteBackground": "#b4be00",
+        "statusBarItem.remoteForeground": "#15202b",
+        "titleBar.activeBackground": "#b4be00",
+        "titleBar.activeForeground": "#15202b",
+        "titleBar.inactiveBackground": "#b4be0099",
+        "titleBar.inactiveForeground": "#15202b99",
+        "commandCenter.border": "#15202b99"
+    },
+    "peacock.remoteColor": "#B4BE00",
+    "intelephense.environment.phpVersion": "8.2.0",
+    "intelephense.completion.fullyQualifyGlobalConstantsAndFunctions": true,
+    "intelephense.phpdoc.useFullyQualifiedNames": true
+}

README.md

@@ -0,0 +1 @@
+# VOLENA

app/Console/Commands/CreateAdmin.php

@@ -0,0 +1,177 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Models\User;
+use Illuminate\Console\Command;
+use Illuminate\Support\Facades\Validator;
+use Illuminate\Validation\ValidationException;
+
+class CreateAdmin extends Command
+{
+    /**
+     * The name and signature of the console command.
+     *
+     * @var string
+     */
+    protected $signature = 'user:create';
+
+    /**
+     * The console command description.
+     *
+     * @var string
+     */
+    protected $description = 'Create a backend admin user';
+
+    /**
+     * The firstname of the new user.
+     *
+     * @var string
+     */
+    protected $firstname;
+
+    /**
+     * The lastname of the new user.
+     *
+     * @var string
+     */
+    protected $lastname;
+
+    /**
+     * The email of the new user.
+     *
+     * @var string
+     */
+    protected $email;
+
+    /**
+     * The password of the new user.
+     *
+     * @var string
+     */
+    protected $password;
+
+
+    /**
+     * Execute the console command.
+     *
+     * @return integer
+     */
+    public function handle(): int
+    {
+        $this->firstname = null;
+        $this->addFirstname();
+
+        $this->lastname = null;
+        $this->addLastname();
+
+        $this->email = null;
+        $this->addEmail();
+
+        $this->password = null;
+        $this->addPassword();
+
+        $user = new User([
+            'firstname' => $this->firstname,
+            'lastname' => $this->lastname,
+            'email' => $this->email,
+            'password' => $this->password,
+        ]);
+        $user->saveOrFail();
+
+        $this->info('User created 👌');
+
+        return 0;
+    }
+
+    /**
+     * Add a firstname to the user.
+     *
+     * @return void
+     */
+    private function addFirstname(): void
+    {
+        while (is_null($this->firstname)) {
+            try {
+                $tmp       = $this->ask('Type the wanted user firstname', 'Admin');
+                $validator = Validator::make(['firstname' => $tmp], [
+                    'firstname' => 'required|min:3|max:255'
+                ]);
+                $validator->validate();
+                $this->firstname = $tmp;
+            } catch (ValidationException $e) {
+                $this->error(sprintf(
+                    'Please provide a valid firstname %s',
+                    \implode(',', collect($e->errors())->flatten()->all())
+                ));
+                continue;
+            } //end try
+        }; //end while
+    }
+
+    /**
+     * Add a lastname to the user.
+     *
+     * @return void
+     */
+    private function addLastname(): void
+    {
+        while (is_null($this->lastname)) {
+            try {
+                $tmp       = $this->ask('Type the wanted user lastname', 'Saïtama');
+                $validator = Validator::make(['lastname' => $tmp], [
+                    'lastname' => 'required|min:3|max:255'
+                ]);
+                $validator->validate();
+                $this->lastname = $tmp;
+            } catch (ValidationException $e) {
+                $this->error(sprintf(
+                    'Please provide a valid lastname %s',
+                    \implode(',', collect($e->errors())->flatten()->all())
+                ));
+                continue;
+            } //end try
+        }; //end while
+    }
+
+    /**
+     * Add an email to the user.
+     *
+     * @return void
+     */
+    private function addEmail(): void
+    {
+        while (is_null($this->email)) {
+            try {
+                $tmp       = $this->ask('Type the wanted user email', 'equipe.web@ldc.fr');
+                $validator = Validator::make(['email' => $tmp], [
+                    'email' => 'required|unique:users,email|email:rfc,dns'
+                ]);
+                $validator->validate();
+                $this->email = $tmp;
+            } catch (ValidationException $e) {
+                $this->error(sprintf(
+                    'Please provide a valid email %s',
+                    \implode(',', collect($e->errors())->flatten()->all())
+                ));
+                continue;
+            } //end try
+        }; //end while
+    }
+
+    /**
+     * Add a password to the user.
+     *
+     * @return void
+     */
+    private function addPassword(): void
+    {
+        while (
+            ($this->password = $this->secret(
+                (!\is_null($this->password) ? 'Failed to confirm, ' : '') . 'Type the wanted user password'
+            )) !== $this->secret('Confirm the password')
+        ) {
+            continue;
+        }; //end while
+    }
+}

app/Console/Kernel.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Console;
+
+use Illuminate\Console\Scheduling\Schedule;
+use Illuminate\Foundation\Console\Kernel as ConsoleKernel;
+
+class Kernel extends ConsoleKernel
+{
+    /**
+     * Define the application's command schedule.
+     *
+     * @param  \Illuminate\Console\Scheduling\Schedule $schedule
+     * @return void
+     */
+    protected function schedule(Schedule $schedule)
+    {
+    }
+
+    /**
+     * Register the commands for the application.
+     *
+     * @return void
+     */
+    protected function commands()
+    {
+        $this->load(__DIR__ . '/Commands');
+
+        require base_path('routes/console.php');
+    }
+}

app/Enums/InputType.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace App\Enums;
+
+use App\Traits\Enums\BaseEnum;
+
+enum InputType: int
+{
+    use BaseEnum;
+
+    case boolean       = 1;
+    case dropdownArray = 2;
+    case email         = 3;
+    case image         = 4;
+    case imageArray    = 5;
+    case labelArray    = 6;
+    case miniblocArray = 7;
+    case number        = 8;
+    case selectEnum    = 9;
+    case password      = 10;
+    case string        = 11;
+    case text          = 12;
+    case url           = 13;
+    case videoVimeo    = 14;
+    case videoYoutube  = 15;
+}

app/Exceptions/Handler.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace App\Exceptions;
+
+use Illuminate\Foundation\Exceptions\Handler as ExceptionHandler;
+use Throwable;
+
+class Handler extends ExceptionHandler
+{
+    /**
+     * A list of exception types with their corresponding custom log levels.
+     *
+     * @var array<class-string<\Throwable>, \Psr\Log\LogLevel::*>
+     */
+    protected $levels = [];
+
+    /**
+     * A list of the exception types that are not reported.
+     *
+     * @var array<int, class-string<\Throwable>>
+     */
+    protected $dontReport = [];
+
+    /**
+     * A list of the inputs that are never flashed to the session on validation exceptions.
+     *
+     * @var array<int, string>
+     */
+    protected $dontFlash = [
+        'current_password',
+        'password',
+        'password_confirmation',
+    ];
+
+    /**
+     * Register the exception handling callbacks for the application.
+     *
+     * @return void
+     */
+    public function register()
+    {
+        $this->reportable(function (Throwable $e) {
+        });
+    }
+}

app/Http/Controllers/Bo/Auth/LoginController.php

@@ -0,0 +1,54 @@
+<?php
+
+namespace App\Http\Controllers\Bo\Auth;
+
+use App\Http\Controllers\Controller;
+use Illuminate\Contracts\Auth\StatefulGuard;
+use Illuminate\Contracts\View\View;
+use Illuminate\Foundation\Auth\AuthenticatesUsers;
+use Illuminate\Support\Facades\Auth;
+
+class LoginController extends Controller
+{
+    use AuthenticatesUsers;
+
+    /**
+     * Create a new controller instance.
+     *
+     * @return void
+     */
+    public function __construct()
+    {
+        $this->middleware('guest:backend')->except('logout');
+    }
+
+    /**
+     * Get the guard to be used during authentication.
+     *
+     * @return \Illuminate\Contracts\Auth\StatefulGuard
+     */
+    protected function guard(): StatefulGuard
+    {
+        return Auth::guard('backend');
+    }
+
+    /**
+     * Show the application's login form.
+     *
+     * @return \Illuminate\Contracts\View\View
+     */
+    public function showLoginForm(): View
+    {
+        return view('bo.auth.login');
+    }
+
+    /**
+     * Where to redirect users after login.
+     *
+     * @return string
+     */
+    protected function redirectTo(): string
+    {
+        return response()->redirectToIntended()->getTargetUrl();
+    }
+}

app/Http/Controllers/Bo/Auth/ResetPasswordController.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace App\Http\Controllers\Bo\Auth;
+
+use App\Http\Controllers\Controller;
+use Illuminate\Contracts\Auth\StatefulGuard;
+use Illuminate\Foundation\Auth\ResetsPasswords;
+use Illuminate\Support\Facades\Auth;
+
+class ResetPasswordController extends Controller
+{
+    use ResetsPasswords;
+
+    /**
+     * Get the guard to be used during authentication.
+     *
+     * @return \Illuminate\Contracts\Auth\StatefulGuard
+     */
+    protected function guard(): StatefulGuard
+    {
+        return Auth::guard('backend');
+    }
+
+    /**
+     * Where to redirect users after login.
+     *
+     * @return string
+     */
+    protected function redirectTo(): string
+    {
+        return \route('bo.login');
+    }
+}

app/Http/Controllers/Bo/DashboardController.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace App\Http\Controllers\Bo;
+
+use App\Http\Controllers\Controller;
+use Illuminate\Contracts\View\View;
+
+class DashboardController extends Controller
+{
+    /**
+     * Dashboard Page
+     *
+     * @return \Illuminate\Contracts\View\View
+     */
+    public function index(): View
+    {
+        return view('bo.pages.dashboard');
+    }
+}

app/Http/Controllers/Controller.php

@@ -0,0 +1,123 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
+use Illuminate\Foundation\Validation\ValidatesRequests;
+use Illuminate\Routing\Controller as BaseController;
+use Illuminate\Support\Facades\Schema;
+use Illuminate\Support\Facades\Session;
+
+class Controller extends BaseController
+{
+    use AuthorizesRequests;
+    use ValidatesRequests;
+
+    /**
+     * Build Search query on specified fields
+     * splitting search into words or using whole sentence
+     *
+     * @param \Illuminate\Database\Eloquent\Builder $query       The eloquent query builder.
+     * @param string                                $search      The query string.
+     * @param callable                              $searchQuery The query string.
+     * @param string                                ...$fields   Either a simple array or a string
+     *                                                           in case of a string the two fields
+     *                                                           would be concatenate to make the search.
+     * @return \Illuminate\Database\Eloquent\Builder
+     */
+    protected function searchQuery(
+        Builder $query,
+        string $search,
+        callable $searchQuery = null,
+        string ...$fields
+    ): Builder {
+        if (count($fields)) {
+            // Search using words.
+            $words = explode(' ', $search);
+            $query->where(function ($query) use ($searchQuery, $words, $search, $fields) {
+                foreach ($words as $word) {
+                    if (!strlen($word)) {
+                        continue;
+                    }
+                    $this->searchOnFields($query, $word, $fields);
+                } //end foreach
+                // Search whole using whole sentence.
+                $this->searchOnFields($query, $search, $fields);
+                if ($searchQuery) {
+                    $searchQuery($query);
+                }
+            });
+        } //end if
+        return $query;
+    }
+
+    /**
+     * Build query search on all fields
+     *
+     * @param \Illuminate\Database\Eloquent\Builder $query
+     * @param string                                $search
+     * @param array                                 $fields
+     * @return \Illuminate\Database\Eloquent\Builder
+     */
+    private function searchOnFields(Builder $query, string $search, array $fields): Builder
+    {
+        $table = $query->getModel()->getTable();
+        foreach ($fields as $f) {
+            $f = str_replace('?', '\?', $f);
+            if (is_array($f)) {
+                $query->orWhereRaw(
+                    sprintf("UPPER(CONCAT(%s)) LIKE UPPER(?)", collect($f)->map(function ($q) use ($table) {
+                        return "`$table`.`$q`";
+                    })->implode(', \' \', ')),
+                    ['%' . filter_var($search, FILTER_SANITIZE_STRING) . '%']
+                );
+            } else {
+                $query->orWhereRaw(
+                    "UPPER(`$table`.`$f`) LIKE UPPER(?)",
+                    ['%' . filter_var($search, FILTER_SANITIZE_STRING) . '%']
+                );
+            }
+        }
+        return $query;
+    }
+
+    /**
+     * Sort columns with a query
+     *
+     * @param \Illuminate\Database\Eloquent\Builder $query
+     * @param array                                 $ignore
+     * @return \Illuminate\Database\Eloquent\Builder
+     */
+    protected function sortQuery(Builder $query, array $ignore = []): Builder
+    {
+        $rName = request()->route()->getName();
+        $table = $query->getModel()->getTable();
+        if (request()->sort_col) {
+            Session::put("$rName.sort_col", request()->sort_col);
+            Session::put("$rName.sorted", true);
+        }
+        if (request()->sort_way) {
+            Session::put("$rName.sort_way", request()->sort_way);
+            Session::put("$rName.sorted", true);
+        }
+        if (request()->rst) {
+            Session::remove("$rName.sorted");
+            Session::remove("$rName.sort_col");
+            Session::remove("$rName.sort_way");
+        }
+        if (request()->sort_col and request()->sort_way and Schema::hasColumn($table, request()->sort_col)) {
+            if (
+                !isset($ignore) or
+                (isset($ignore) and !in_array(request()->sort_col, $ignore))
+            ) {
+                $query = $query->orderBy(\sprintf("$table.%s", request()->sort_col), request()->sort_way);
+            }
+        } elseif (Schema::hasColumn($table, 'order')) {
+            $query = $query->orderBy('order', 'ASC');
+            Session::put("$rName.sort_col", 'order');
+            Session::put("$rName.sort_way", 'asc');
+        }
+        return $query;
+    }
+}

app/Http/Controllers/Fo/HomeController.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace App\Http\Controllers\Fo;
+
+use App\Http\Controllers\Controller;
+use Illuminate\Contracts\View\View;
+
+class HomeController extends Controller
+{
+    /**
+     * Display a listing of the resource.
+     *
+     * @return \Illuminate\Contracts\View\View
+     */
+    public function index(): View
+    {
+        return view('fo.pages.home');
+    }
+}

app/Http/Kernel.php

@@ -0,0 +1,69 @@
+<?php
+
+namespace App\Http;
+
+use Illuminate\Foundation\Http\Kernel as HttpKernel;
+
+class Kernel extends HttpKernel
+{
+    /**
+     * The application's global HTTP middleware stack.
+     *
+     * These middleware are run during every request to your application.
+     *
+     * @var array<int, class-string|string>
+     */
+    protected $middleware = [
+        \App\Http\Middleware\TrustHosts::class,
+        \App\Http\Middleware\TrustProxies::class,
+        \Illuminate\Http\Middleware\HandleCors::class,
+        \App\Http\Middleware\PreventRequestsDuringMaintenance::class,
+        \Illuminate\Foundation\Http\Middleware\ValidatePostSize::class,
+        \App\Http\Middleware\TrimStrings::class,
+        \Illuminate\Foundation\Http\Middleware\ConvertEmptyStringsToNull::class,
+    ];
+
+    /**
+     * The application's route middleware groups.
+     *
+     * @var array<string, array<int, class-string|string>>
+     */
+    protected $middlewareGroups = [
+        'web' => [
+            'htmlsanitize',
+            \App\Http\Middleware\EncryptCookies::class,
+            \Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class,
+            \Illuminate\Session\Middleware\StartSession::class,
+            \Illuminate\View\Middleware\ShareErrorsFromSession::class,
+            \App\Http\Middleware\VerifyCsrfToken::class,
+            \Illuminate\Routing\Middleware\SubstituteBindings::class,
+            \App\Http\Middleware\SecureHeaders::class
+        ],
+
+        'api' => [
+            \Illuminate\Routing\Middleware\ThrottleRequests::class . ':api',
+            \Illuminate\Routing\Middleware\SubstituteBindings::class,
+        ],
+    ];
+
+    /**
+     * The application's route middleware.
+     *
+     * These middleware may be assigned to groups or used individually.
+     *
+     * @var array<string, class-string|string>
+     */
+    protected $middlewareAliases = [
+        'auth' => \App\Http\Middleware\Authenticate::class,
+        'auth.basic' => \Illuminate\Auth\Middleware\AuthenticateWithBasicAuth::class,
+        'auth.session' => \Illuminate\Session\Middleware\AuthenticateSession::class,
+        'cache.headers' => \Illuminate\Http\Middleware\SetCacheHeaders::class,
+        'can' => \Illuminate\Auth\Middleware\Authorize::class,
+        'guest' => \App\Http\Middleware\RedirectIfAuthenticated::class,
+        'password.confirm' => \Illuminate\Auth\Middleware\RequirePassword::class,
+        'signed' => \App\Http\Middleware\ValidateSignature::class,
+        'throttle' => \Illuminate\Routing\Middleware\ThrottleRequests::class,
+        'verified' => \Illuminate\Auth\Middleware\EnsureEmailIsVerified::class,
+        'htmlsanitize' => \App\Http\Middleware\HtmlSanitizer::class,
+    ];
+}

app/Http/Middleware/Authenticate.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace App\Http\Middleware;
+
+use Illuminate\Auth\Middleware\Authenticate as Middleware;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Session;
+
+class Authenticate extends Middleware
+{
+    /**
+     * Get the path the user should be redirected to when they are not authenticated.
+     *
+     * @param  \Illuminate\Http\Request $request
+     * @return string|null
+     */
+    protected function redirectTo(Request $request): ?string
+    {
+        $logins = [
+            'backend' => route('bo.login')
+        ];
+        if (!$request->expectsJson()) {
+            // * Notify must login
+            Session::flash('warning', trans('Veuillez vous connecter pour continuer'));
+
+            foreach ($request->route()->gatherMiddleware() as $middleware) {
+                if (\is_string($middleware) and strpos($middleware, 'auth:') !== false) {
+                    $route = $logins[str_replace('auth:', '', $middleware)] ?? null;
+                    if ($route) {
+                        return $route;
+                    }
+                }
+            }
+            return route('login');
+        }
+        abort(401);
+
+        return null;
+    }
+}

app/Http/Middleware/EncryptCookies.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Http\Middleware;
+
+use Illuminate\Cookie\Middleware\EncryptCookies as Middleware;
+
+class EncryptCookies extends Middleware
+{
+    /**
+     * The names of the cookies that should not be encrypted.
+     *
+     * @var array<int, string>
+     */
+    protected $except = [];
+}

app/Http/Middleware/HtmlSanitizer.php

@@ -0,0 +1,61 @@
+<?php
+
+namespace App\Http\Middleware;
+
+use App\Lib\Helpers\ToolboxHelper;
+use Illuminate\Http\Request;
+use Symfony\Component\HttpFoundation\Response;
+
+class HtmlSanitizer
+{
+    /**
+     * Handle an incoming request.
+     *
+     * @param  \Illuminate\Http\Request $request
+     * @param  \Closure                 $next
+     * @param  string|array             ...$params
+     * @return \Symfony\Component\HttpFoundation\Response
+     */
+    public function handle(Request $request, \Closure $next, string|array ...$params): Response
+    {
+        $inputs = $request->all();
+        /** @var callable|null */
+        $cleanInput = null;
+        $cleanInput = function (
+            null|string|array &$input,
+            string $name,
+            ?string $rootName = null
+        ) use (
+            $params,
+            &$cleanInput
+        ): void {
+            // * Nested element array
+            if (is_array($input)) {
+                array_walk_recursive($input, $cleanInput, $name);
+            }
+            if (!is_string($input)) {
+                return;
+            }
+            if (in_array($name, $params) or in_array($rootName ?? $name, $params)) {
+                // ? Is a json input ?
+                if ($isJson = \json_decode($input, true) and is_array($isJson)) {
+                    // ! Decode each json field recursive.
+                    \array_walk_recursive($isJson, function (string|array &$item) {
+                        if (\is_string($item)) {
+                            $item = clean($item);
+                            $item = ToolboxHelper::stripCkEditorSchemesOnMediaInputs($item);
+                        }
+                    });
+                } else {
+                    $input = clean($input);
+                    $input = ToolboxHelper::stripCkEditorSchemesOnMediaInputs($input);
+                }
+            } else {
+                $input = strip_tags($input);
+            }
+        };
+        \array_walk($inputs, $cleanInput);
+        $request->merge($inputs);
+        return $next($request);
+    }
+}

app/Http/Middleware/PreventRequestsDuringMaintenance.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Http\Middleware;
+
+use Illuminate\Foundation\Http\Middleware\PreventRequestsDuringMaintenance as Middleware;
+
+class PreventRequestsDuringMaintenance extends Middleware
+{
+    /**
+     * The URIs that should be reachable while maintenance mode is enabled.
+     *
+     * @var array<int, string>
+     */
+    protected $except = [];
+}

app/Http/Middleware/RedirectIfAuthenticated.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace App\Http\Middleware;
+
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+use Symfony\Component\HttpFoundation\Response;
+
+class RedirectIfAuthenticated
+{
+    /**
+     * Handle an incoming request.
+     *
+     * @param  \Illuminate\Http\Request                                                         $request
+     * @param  \Closure(\Illuminate\Http\Request): (\Symfony\Component\HttpFoundation\Response) $next
+     * @param  string|null                                                                      ...$guards
+     * @return \Symfony\Component\HttpFoundation\Response
+     * @throws \RuntimeException If guard is unhandled.
+     * @phpcs:disable Squiz.Commenting.FunctionComment.IncorrectTypeHint
+     */
+    public function handle(Request $request, \Closure $next, ...$guards): Response
+    {
+        // phpcs:enable phpcs:disable
+        $guards = empty($guards) ? [null] : $guards;
+
+        foreach ($guards as $guard) {
+            if (Auth::guard($guard)->check()) {
+                switch ($guard) {
+                    case 'frontend':
+                        return \redirect()->route('home');
+                    case 'backend':
+                        if (!$request->routeIs('bo.*')) {
+                            continue;
+                        }
+                        return \redirect()->route('bo.dashboard');
+                    default:
+                        throw new \RuntimeException("Unhandled guard `{$guard}` .");
+                }
+            }
+        }
+
+        return $next($request);
+    }
+}

app/Http/Middleware/SecureHeaders.php

@@ -0,0 +1,103 @@
+<?php
+
+namespace App\Http\Middleware;
+
+use Closure;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Route;
+use Illuminate\Support\Facades\View;
+use Illuminate\Support\Facades\Vite;
+use Symfony\Component\HttpFoundation\Response;
+
+class SecureHeaders
+{
+    /**
+     * Enumerate headers which you do not want in your application's responses.
+     * Great starting point would be to go check out @Scott_Helme's:
+     * https://securityheaders.com/
+     *
+     * @var array
+     */
+    private $unwantedHeaderList = [
+        'X-Powered-By',
+        'Server',
+    ];
+
+    /**
+     * Handle an incoming request.
+     *
+     * @param  \Illuminate\Http\Request                                                         $request
+     * @param  \Closure(\Illuminate\Http\Request): (\Symfony\Component\HttpFoundation\Response) $next
+     * @return \Symfony\Component\HttpFoundation\Response
+     * @phpcs:disable Squiz.Commenting.FunctionComment.IncorrectTypeHint
+     */
+    public function handle(Request $request, Closure $next): Response
+    {
+        // phpcs:enable
+        View::share('nonce', $nonce = Vite::useCspNonce());
+        // * For VueJS dev tool to execute
+        $jsDev     = config('app.debug') ? "'unsafe-eval' 'unsafe-inline'" : "'nonce-{$nonce}' 'strict-dynamic'";
+        $scheme    = config('app.env') === 'local' ? 'http' : 'https';
+        $reportUri = Route::has('cspReportUri') ?
+        \sprintf(' report-uri %s ;', \parse_url(route('cspReportUri'), \PHP_URL_PATH)) : '';
+        $this->removeUnwantedHeaders($this->unwantedHeaderList);
+        $response = $next($request);
+        $response->headers->set('Referrer-Policy', 'no-referrer-when-downgrade');
+        $response->headers->set('X-Content-Type-Options', 'nosniff');
+        $response->headers->set('X-XSS-Protection', '1; mode=block');
+        $response->headers->set('X-Frame-Options', 'SAMEORIGIN');
+        $response->headers->set('Strict-Transport-Security', 'max-age=31536000; includeSubDomains;');
+        $cspPolicies = [
+            "default-src 'none';",
+            "manifest-src 'self';",
+            // * CKEDITOR Specific https://ckeditor.com/docs/ckeditor5/latest/installation/advanced/csp.html
+            "connect-src 'self' blob:;",
+            "img-src * data: blob:;",
+            'frame-src ' . implode(' ', [
+                'https://www.google.com/recaptcha/',
+                'https://recaptcha.google.com/recaptcha/',
+                'https://www.google.com/maps/'
+            ]) . ';',
+            "font-src 'self' data: https://fonts.gstatic.com;",
+            // ! Using CKEditor will must have unsafe-inline style
+            // phpcs:ignore Generic.Files.LineLength.TooLong
+            "style-src 'self' 'unsafe-inline' " . \implode(' ', [
+                'https://cdnjs.cloudflare.com',
+                // * File Manager
+                'https://fonts.googleapis.com',
+                'https://cdn.jsdelivr.net',
+                'https://use.fontawesome.com',
+                'https://fonts.googleapis.com'
+            ]) . ';',
+            // ! If you dont use ckeditor use this
+            // "style-src 'self' 'nonce-$nonce';",
+            // phpcs:ignore Generic.Files.LineLength.TooLong
+            "script-src 'self' {$jsDev} " . \implode(' ', [
+                'https:  blob:',
+                'https://www.googletagmanager.com',
+                'https://cdnjs.cloudflare.com',
+                "$scheme://www.google-analytics.com",
+            ]) . ';'
+        ];
+
+        $response->headers->set(
+            'Content-Security-Policy',
+            implode(' ', $cspPolicies) . $reportUri
+        );
+        $response->headers->set('Feature-Policy', 'fullscreen \'self\';');
+        return $response;
+    }
+
+    /**
+     * Remove unwanted headers
+     *
+     * @param array $headerList
+     * @return void
+     */
+    private function removeUnwantedHeaders(array $headerList)
+    {
+        foreach ($headerList as $header) {
+            header_remove($header);
+        }
+    }
+}

app/Http/Middleware/TrimStrings.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace App\Http\Middleware;
+
+use Illuminate\Foundation\Http\Middleware\TrimStrings as Middleware;
+
+class TrimStrings extends Middleware
+{
+    /**
+     * The names of the attributes that should not be trimmed.
+     *
+     * @var array<int, string>
+     */
+    protected $except = [
+        'current_password',
+        'password',
+        'password_confirmation',
+    ];
+}

app/Http/Middleware/TrustHosts.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Http\Middleware;
+
+use Illuminate\Http\Middleware\TrustHosts as Middleware;
+
+class TrustHosts extends Middleware
+{
+    /**
+     * Get the host patterns that should be trusted.
+     *
+     * @return array<int, string|null>
+     */
+    public function hosts()
+    {
+        return [
+            $this->allSubdomainsOfApplicationUrl(),
+        ];
+    }
+}

app/Http/Middleware/TrustProxies.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Http\Middleware;
+
+use Illuminate\Http\Middleware\TrustProxies as Middleware;
+use Illuminate\Http\Request;
+
+class TrustProxies extends Middleware
+{
+    /**
+     * The trusted proxies for this application.
+     *
+     * @var array<int, string>|string|null
+     */
+    protected $proxies;
+
+    /**
+     * The headers that should be used to detect proxies.
+     *
+     * @var integer
+     */
+    protected $headers =
+        Request::HEADER_X_FORWARDED_FOR |
+        Request::HEADER_X_FORWARDED_HOST |
+        Request::HEADER_X_FORWARDED_PORT |
+        Request::HEADER_X_FORWARDED_PROTO |
+        Request::HEADER_X_FORWARDED_AWS_ELB;
+}

app/Http/Middleware/ValidateSignature.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Http\Middleware;
+
+use Illuminate\Routing\Middleware\ValidateSignature as Middleware;
+
+class ValidateSignature extends Middleware
+{
+    /**
+     * The names of the query string parameters that should be ignored.
+     *
+     * @var array<int, string>
+     */
+    protected $except = [];
+}

app/Http/Middleware/VerifyCsrfToken.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Http\Middleware;
+
+use Illuminate\Foundation\Http\Middleware\VerifyCsrfToken as Middleware;
+
+class VerifyCsrfToken extends Middleware
+{
+    /**
+     * The URIs that should be excluded from CSRF verification.
+     *
+     * @var array<int, string>
+     */
+    protected $except = [
+        '/csp-report'
+    ];
+}

app/Http/Requests/Bo/UpdateMiniCrudRequest.php

@@ -0,0 +1,157 @@
+<?php
+
+namespace App\Http\Requests\Bo;
+
+use App\Enums\InputType;
+use App\Lib\Helpers\ToolboxHelper;
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Validation\ValidationException;
+
+abstract class UpdateMiniCrudRequest extends FormRequest
+{
+    /**
+     * The model parameter name
+     *
+     * @var string
+     */
+    protected $modelName = null;
+
+    /**
+     * Determine if the user is authorized to make this request.
+     *
+     * @return boolean
+     */
+    public function authorize()
+    {
+        return auth('backend')->check();
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array
+     * @phpcs:disable Generic.Metrics.CyclomaticComplexity.TooHigh
+     * @phpcs:disable Generic.Metrics.NestingLevel.TooHigh
+     */
+    public function rules()
+    {
+        // phpcs:enable
+        $rules = [];
+        foreach ($this->{$this->modelName}->data as $iptName => $input) {
+            $input = \json_decode(\json_encode($input), true);
+            switch ($input['inputType']) {
+                case InputType::number->value:
+                    $rules = array_merge($rules, [
+                        "data.$iptName.value" => $this->compileValidate('required|numeric', $input)
+                    ]);
+                    break;
+                case InputType::string->value:
+                    $rules = array_merge($rules, [
+                        "data.$iptName.value" => $this->compileValidate('required|string|min:3', $input)
+                    ]);
+                    break;
+                case InputType::text->value:
+                    $mergeRules = $this->compileValidate('required|string|min:15', $input);
+                    $mergeRules = collect(\explode('|', $mergeRules))
+                        ->map(function ($rule) {
+                            if (\strpos($rule, 'max:') !== false) {
+                                $max = \intval(str_replace('max:', '', $rule));
+                                return function ($attribute, $value, $fail) use ($max) {
+                                    if (\strlen(\strip_tags($value)) > $max) {
+                                        $fail("$attribute ne doit pas excéder $max caractères");
+                                    }
+                                };
+                            }
+                            return $rule;
+                        });
+                    $rules      = array_merge($rules, [
+                        "data.$iptName.text" => $mergeRules
+                    ]);
+                    break;
+                case InputType::image->value:
+                    $ipt   = $this->data[$iptName];
+                    $max   = isset($ipt['dimensionsMax']);
+                    $dim   = \is_string($input['dimensions']) ? collect(explode(
+                        ',',
+                        (isset($ipt['dimensionsMax']) and is_string($ipt['dimensionsMax'])) ?
+                            $ipt['dimensionsMax'] : $input['dimensions']
+                    ))->mapWithKeys(function ($v) {
+                        $v = explode(' ', $v);
+                        return [$v[0] => $v[1]];
+                    }) : $input['dimensions'];
+                    $rules = array_merge($rules, [
+                        "data.$iptName.value" => $this->compileValidate(
+                            implode('|', [
+                                'required',
+                                'image',
+                                'mimes:png,jpg,jpeg',
+                                sprintf(
+                                    'dimensions:%s=%d,%s=%d',
+                                    $max ? 'max_height' : 'height',
+                                    $dim['height'],
+                                    $max ? 'max_width' : 'width',
+                                    $dim['width']
+                                )
+                            ]),
+                            $input
+                        ),
+                        "data.$iptName.alt" => $this->compileValidate('required|string|min:5', $input),
+                        "data.$iptName.title" => $this->compileValidate('required|string|min:5', $input)
+                    ]);
+                    break;
+                case InputType::url->value:
+                    $rules = array_merge($rules, [
+                        "data.$iptName.value" => [
+                            'required', 'url',
+                            // @phpcs:ignore Generic.CodeAnalysis.UnusedFunctionParameter.FoundInExtendedClassBeforeLastUsed
+                            function ($attribute, $value, $fail) {
+                                try {
+                                    ToolboxHelper::assertNoInternalUrls($attribute, $value);
+                                    ToolboxHelper::assertNoInternalBoUrls($attribute, $value);
+                                } catch (ValidationException $e) {
+                                    $fail(collect($e->errors())->first()[0]);
+                                }
+                            }
+                        ]
+                    ]);
+                    break;
+                case InputType::boolean->value:
+                    $all    = $this->all();
+                    $nested = ToolboxHelper::dotStringToNestedArray(
+                        "data.$iptName.value",
+                        $this->input("data.$iptName.value") ? true : false
+                    );
+                    $all    = array_merge_recursive_distinct($all, $nested);
+                    $this->merge($all);
+                    $rules = array_merge($rules, [
+                        "data.$iptName.value" => 'boolean'
+                    ]);
+                    break;
+            } //end switch
+        } //end foreach
+        return $rules;
+    }
+
+    /**
+     * Undocumented function
+     *
+     * @param string $inputTypeValidate
+     * @param array  $input
+     * @return string
+     */
+    public function compileValidate(string $inputTypeValidate, array $input): string
+    {
+        if (!isset($input['validate']) or !\is_string($input['validate'])) {
+            return $inputTypeValidate;
+        }
+        /** @var array */
+        $inputValidate = explode('|', $input['validate']);
+        $out           = explode('|', $inputTypeValidate);
+        foreach ($inputValidate as $validate) {
+            if (!\in_array($validate, $out)) {
+                $out[] = $validate;
+            }
+        }
+        return \implode('|', $out);
+    }
+}

app/Lib/Helpers/CollectionHelper.php

@@ -0,0 +1,64 @@
+<?php
+
+namespace App\Lib;
+
+use Illuminate\Container\Container;
+use Illuminate\Pagination\LengthAwarePaginator;
+use Illuminate\Pagination\Paginator;
+use Illuminate\Support\Collection;
+
+class CollectionHelper
+{
+    /**
+     * Paginate a collection
+     *
+     * @param \Illuminate\Support\Collection $results
+     * @param integer                        $pageSize
+     * @return \Illuminate\Pagination\LengthAwarePaginator
+     */
+    public static function paginate(Collection $results, int $pageSize): LengthAwarePaginator
+    {
+        $page = Paginator::resolveCurrentPage('page');
+
+        return self::paginateManually($results, $pageSize, $page);
+    }
+
+    /**
+     * Paginate a collection
+     *
+     * @param \Illuminate\Support\Collection $results
+     * @param integer                        $pageSize
+     * @param integer                        $page
+     * @return \Illuminate\Pagination\LengthAwarePaginator
+     */
+    public static function paginateManually(Collection $results, int $pageSize, int $page = 1): LengthAwarePaginator
+    {
+        $total = $results->count();
+
+        return self::paginator($results->forPage($page, $pageSize), $total, $pageSize, $page, [
+            'path' => Paginator::resolveCurrentPath(),
+            'pageName' => 'page',
+        ]);
+    }
+
+    /**
+     * Create a new length-aware paginator instance.
+     *
+     * @param  \Illuminate\Support\Collection $items
+     * @param  integer                        $total
+     * @param  integer                        $perPage
+     * @param  integer                        $currentPage
+     * @param  array                          $options
+     * @return \Illuminate\Pagination\LengthAwarePaginator
+     */
+    protected static function paginator(Collection $items, int $total, int $perPage, int $currentPage, array $options)
+    {
+        return Container::getInstance()->makeWith(LengthAwarePaginator::class, [
+            'items' => $items,
+            'total' => $total,
+            'perPage' => $perPage,
+            'currentPage' => $currentPage,
+            'options' => $options
+        ]);
+    }
+}

app/Lib/Helpers/ExceptionsHelper.php

@@ -0,0 +1,190 @@
+<?php
+
+namespace App\Lib\Helpers;
+
+class ExceptionsHelper
+{
+    /**
+     * Handle sentry event
+     *
+     * @param \Sentry\Event $event
+     * @return null|\Sentry\Event
+     */
+    public static function sentryEventHandler(\Sentry\Event $event): ?\Sentry\Event
+    {
+        // Remove unwanted reports.
+        $event->setModules([]);
+        $event->setOsContext(null);
+
+        /** @var \Sentry\ExceptionDataBag[] */
+        $exceptionBag = [];
+        foreach ($event->getExceptions() as $exceptionDataBag) {
+            $exceptionBag[] = self::getAnonymizedSentryException($exceptionDataBag);
+        }
+        $event->setExceptions($exceptionBag);
+        return $event;
+    }
+
+    /**
+     * Anonimize Sentry Exception bag
+     *
+     * @param \Sentry\ExceptionDataBag $exceptionDataBag
+     * @return \Sentry\ExceptionDataBag
+     */
+    private static function getAnonymizedSentryException(
+        \Sentry\ExceptionDataBag $exceptionDataBag
+    ): \Sentry\ExceptionDataBag {
+        $exceptionDataBag->setValue(self::getAnonymizedMessage($exceptionDataBag->getValue()));
+        if ($stackTrace = $exceptionDataBag->getStacktrace()) {
+            $exceptionDataBag->setStacktrace(self::getAnonymizedSentryStackTrace($stackTrace));
+        }
+        return $exceptionDataBag;
+    }
+
+    /**
+     * Anonymise sentry stacktrace
+     *
+     * @param \Sentry\Stacktrace $stackTrace
+     * @return \Sentry\Stacktrace
+     */
+    private static function getAnonymizedSentryStackTrace(\Sentry\Stacktrace $stackTrace): \Sentry\Stacktrace
+    {
+        /** @var \Sentry\Frame[] */
+        $frames = \array_reverse($stackTrace->getFrames(), true);
+        $i      = \count($frames) - 1;
+        // * Remove all but keep first (index.php).
+        while ($i-- > 0) {
+            $stackTrace->removeFrame(count($stackTrace->getFrames()) - 1);
+        }
+        foreach ($frames as $index => $frame) {
+            $frame->setPostContext([]);
+            $frame->setPreContext([]);
+            $frame->setContextLine('');
+            $frame->setVars(self::getAnonymizedSentryParams($frame->getVars()));
+            $stackTrace->addFrame($frame);
+            if ($index === 0) {
+                $stackTrace->removeFrame(count($stackTrace->getFrames()) - 1);
+            }
+        }
+        return $stackTrace;
+    }
+
+    /**
+     * Get anonymized sentry params
+     *
+     * @param mixed[] $params
+     * @return string[]
+     */
+    private static function getAnonymizedSentryParams(array $params): array
+    {
+        foreach ($params as &$param) {
+            $type = \strtolower(\gettype($param));
+            if (\is_string($param)) {
+                $type = \explode(' ', \trim(strtolower($param)))[0] ?? null;
+            }
+            switch (true) {
+                case $type === 'lambda':
+                case $type === 'object':
+                    continue 2;
+                case $type === 'array' and \is_array($param):
+                    $param = sprintf('Array(%d)', \count($param));
+                    continue 2;
+                default:
+                    if (\is_numeric($param)) {
+                        $param = \ucfirst($type);
+                        continue 2;
+                    }
+                    if (\is_string($param)) {
+                        $param = sprintf('String(%d)', \strlen($param));
+                        continue 2;
+                    }
+            } //end switch
+        } //end foreach
+        return $params;
+    }
+
+
+    /**
+     * Anonymize at least Sql queries
+     *
+     * @param string $message
+     * @return string
+     */
+    public static function getAnonymizedMessage(string $message): string
+    {
+        $message = \preg_replace('/^(.*)( \(SQL:.*\))$/', '$1', $message) ?? $message;
+        if ($sqlPos = \strpos($message, 'to use near')) {
+            $message = \mb_strcut($message, 0, $sqlPos);
+        }
+        return $message;
+    }
+
+    /**
+     * Anonymize stack trace
+     *
+     * @param \Throwable $e
+     * @return string
+     */
+    public static function getAnonymizedStackTrace(\Throwable $e): string
+    {
+        $projectPath   = \realpath(\sprintf('%s/../', \app_path()));
+        $traceStack    = $e->getTrace();
+        $traceStr      = '';
+        $maxStackStage = 0;
+        foreach ($traceStack as $stackStage => $stack) {
+            $maxStackStage = $stackStage;
+            $traceStr     .= \sprintf(
+                '#%s %s(%d): ',
+                $stackStage,
+                str_replace($projectPath, '', $stack['file'] ?? ''),
+                $stack['line'] ?? ''
+            );
+            if (isset($stack['class'])) {
+                $traceStr .= "{$stack['class']}->{$stack['function']}(";
+                if (isset($stack['args'])) {
+                    $traceStr .= self::handleArgs($stack);
+                }
+                $traceStr .= ")\n";
+            } elseif (isset($stack['function'])) {
+                $traceStr .= "{$stack['function']}(";
+                if (isset($stack['args'])) {
+                    $traceStr .= self::handleArgs($stack);
+                }
+                $traceStr .= ")\n";
+            }
+        } //end foreach
+        $maxStackStage++;
+        $traceStr .= "#$maxStackStage {main}";
+        return $traceStr;
+    }
+
+    /**
+     * Handle Args
+     *
+     * @param array $stack
+     * @return string
+     */
+    public static function handleArgs(array $stack): string
+    {
+        $traceArgs = '';
+        $argsCount = count($stack['args']);
+        for ($i = 0; $i < $argsCount; $i++) {
+            $type = \gettype($stack['args'][$i]);
+            switch ($type) {
+                case 'object':
+                    $traceArgs .= sprintf('Object(%s)', \get_class($stack['args'][$i]));
+                    break;
+                case 'array':
+                    $traceArgs .= sprintf('Array(%d)', \count($stack['args'][$i]));
+                    break;
+                case 'string':
+                    $traceArgs .= sprintf('String(%d)', \strlen($stack['args'][$i]));
+                    break;
+                default:
+                    $traceArgs .= \gettype($stack['args'][$i]);
+            }
+            $traceArgs .= ($i !== ($argsCount - 1) ? ',' : '');
+        }
+        return $traceArgs;
+    }
+}

app/Lib/Helpers/FileStorageHelper.php

@@ -0,0 +1,454 @@
+<?php
+
+namespace App\Lib\Helpers;
+
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Support\Facades\File;
+use Illuminate\Support\Facades\Storage;
+use Illuminate\Support\Str;
+
+/**
+ * This class is used to handle files in LDC Laravel stack
+ *
+ *  * The storage strategy will be using date.
+ * The file name may contain sufix timestamp highresolution time (hrtime or microtime) if is duplicate.
+ * (function() { return time() . ' ' . Str::slug(microtime(true)) . ' ' . hrtime(true); })();
+ *
+ * posts/                                                 - The model table name
+ *   10/                                                  - Year
+ *     04/                                                - Month
+ *       19/                                              - Day
+ *         5f/                                            - First two letters of md5 file
+ *           black-cat-under-red-car.png                  - Slugified file name
+ *           black-cat-under-red-car-286071690833400.png  - Slugified file name that is duplicated
+ *
+ * The final path will be storage/modelfiles/posts/10/04/19/5f/black-cat-under-red-car-286071690833400.png
+ *
+ * ! No limits of file per folder will be handled.
+ *
+ * @author Munsch Jérémy <jeremy.munsch@ldc.fr>
+ */
+class FileStorageHelper
+{
+    /**
+     * Destroy the file associate with the attribute.
+     *
+     * @param \Illuminate\Database\Eloquent\Model $model
+     * @param string                              $attribute
+     * @return void
+     */
+    public static function removeFile(Model $model, string $attribute): void
+    {
+        $path = \ltrim(\urldecode($model->{$attribute}), '/');
+        if (\strpos($path, 'storage') !== 0) {
+            return;
+        }
+        $path = ToolboxHelper::mbReplace('storage/', '', $path);
+        if (Storage::disk('public')->exists($path)) {
+            Storage::disk('public')->delete($path);
+        }
+    }
+
+    /**
+     * Destroy the file associate with the attribute old value (before updated to DB).
+     *
+     * @param \Illuminate\Database\Eloquent\Model $model
+     * @param string                              $attribute
+     * @param boolean                             $onlyIfUpdated
+     * @return void
+     */
+    public static function removeOldFile(Model $model, string $attribute, bool $onlyIfUpdated = true): void
+    {
+        // * Ignore If removal has to be done only if the field has changed and it actually hasnt.
+        if ($onlyIfUpdated and $model->{$attribute} === ToolboxHelper::getOriginal($model, $attribute)) {
+            return;
+        }
+        $originalPath = \ltrim(\urldecode(ToolboxHelper::getOriginal($model, $attribute)), '/');
+        if (\strpos($originalPath, 'storage') !== 0) {
+            return;
+        }
+        $originalPath = ToolboxHelper::mbReplace('storage/', '', $originalPath);
+        if (Storage::disk('public')->exists($originalPath)) {
+            Storage::disk('public')->delete($originalPath);
+        }
+    }
+
+    /**
+     * Store a file using optimized storage strategy
+     *
+     * You can use filename param to overload file name.
+     *
+     * @param \Illuminate\Database\Eloquent\Model               $model    The model that will hold the picture.
+     * @param \Illuminate\Http\UploadedFile|\SplFileInfo|string $file     The file, will just return itself is string.
+     * @param boolean                                           $slugify  Force filename slugification.
+     * @param string|null                                       $filename This string may be used to store the file.
+     * @param boolean                                           $private  To store the file in a private space.
+     * @return string
+     * @throws \RuntimeException If file copy fails.
+     * @phpcs:disable Generic.Metrics.CyclomaticComplexity.TooHigh
+     */
+    public static function storeFile(
+        Model $model,
+        $file,
+        bool $slugify = false,
+        string $filename = null,
+        bool $private = false
+    ): string {
+        // phpcs:enable
+        $tableName = $model->getTable();
+        if (\is_object($file) and $file instanceof \Illuminate\Http\UploadedFile) {
+            /** @var \Illuminate\Http\UploadedFile $file */
+            $filename = $filename ?: $file->getClientOriginalName();
+            $filename = $slugify ? self::slugifyFileName($filename) : $filename;
+            $newPath  = self::prepareMoveFile($tableName, $filename, $private);
+            $newPath  = str_replace(storage_path('app'), '', $newPath);
+
+            if (!$private) {
+                // * Store public file.
+                $file->storePubliclyAs(
+                    pathinfo($newPath, \PATHINFO_DIRNAME),
+                    pathinfo($newPath, \PATHINFO_BASENAME)
+                );
+                return 'storage' . str_replace('/public', '', $newPath);
+            }
+
+            $file->storeAs(
+                pathinfo($newPath, \PATHINFO_DIRNAME),
+                pathinfo($newPath, \PATHINFO_BASENAME)
+            );
+
+            return str_replace('/private/', '', $newPath);
+        }//end if
+        if (\is_object($file) and $file instanceof \SplFileInfo) {
+            /** @var \SplFileInfo $file */
+            $filename = $filename ?: $file->getBaseName();
+            $filename = $slugify ? self::slugifyFileName($filename) : $filename;
+            $newPath  = self::prepareMoveFile($tableName, $filename, $private);
+            if (!File::copy($file->getRealPath(), $newPath)) {
+                throw new \RuntimeException(sprintf(
+                    'Failed to copy file %s to %s',
+                    $file->getRealPath(),
+                    $newPath
+                ));
+            }
+            return $private ?
+                \ltrim(str_replace(\storage_path('app/private'), '/storage/app/private', $newPath), '/') :
+                \ltrim(str_replace(\storage_path('app/public'), '/storage', $newPath), '/');
+        }
+        return strval($file);
+    }
+
+    /**
+     * Store all files from string attribute html
+     * If oldHtmlString is passed, a diff is done with new and old files
+     * to keep only files that are present in the new html string.
+     *
+     * @param \Illuminate\Database\Eloquent\Model $model         The model that will hold the picture.
+     * @param string                              $htmlString    The html string to parse and modify files.
+     * @param string|null                         $oldHtmlString The old html string with alreadyParsed
+     *                                                           files using storeModelFilesFromHtml.
+     * @return string Html with files pathes replaced using storage strategy.
+     */
+    public static function storeModelFilesFromHtml(
+        Model $model,
+        string $htmlString,
+        string $oldHtmlString = null
+    ): string {
+        \collect(self::onlyUploadedFilesWithFileManager(self::findFilesInHtml($htmlString)))
+            ->each(function (string $path) use ($model, &$htmlString) {
+                /** @var \Illuminate\Filesystem\FilesystemAdapter */
+                $disk       = Storage::disk('uploads');
+                $fileInfo   = new \SplFileInfo($disk->path(
+                    ToolboxHelper::mbReplace('/uploads/', '', \urldecode($path))
+                ));
+                $htmlString = ToolboxHelper::mbReplace(
+                    $path,
+                    '/' . self::storeFile($model, $fileInfo, true),
+                    $htmlString
+                );
+            });
+
+        if ($oldHtmlString) {
+            self::removeOldModelFilesFromHtml($htmlString, $oldHtmlString);
+        }
+
+        return $htmlString;
+    }
+
+    /**
+     * Remove all old files from string attribute html that are stored in public that
+     * are nove present anymore on new html string
+     *
+     * @param string $newHtmlString The html string with alreadyParsed files using storeModelFilesFromHtml.
+     * @param string $oldHtmlString The old html string with alreadyParsed files using storeModelFilesFromHtml.
+     * @return void
+     */
+    public static function removeOldModelFilesFromHtml(string $newHtmlString, string $oldHtmlString): void
+    {
+        self::removeOldFiles(self::findFilesInHtml($oldHtmlString), self::findFilesInHtml($newHtmlString));
+    }
+
+    /**
+     * Remove all old files that are stored in public that
+     * are not present anymore on new array files
+     *
+     * @param string[] $oldFiles The old array files.
+     * @param string[] $newFiles The new array files.
+     * @return void
+     */
+    public static function removeOldFiles(array $oldFiles, array $newFiles): void
+    {
+        $oldFiles      = \collect(self::onlyUploadedFilesWithFileStorageHelper($oldFiles));
+        $filesToKeep   = \collect(self::onlyUploadedFilesWithFileStorageHelper($newFiles));
+        $filesToRemove = $oldFiles->diff($filesToKeep);
+        $filesToRemove->each(function (string $publicStorageFilePath) {
+            $path = ToolboxHelper::mbReplace('storage/', '', \ltrim(\urldecode($publicStorageFilePath), '/'));
+            if (Storage::disk('public')->exists($path)) {
+                Storage::disk('public')->delete($path);
+            }
+        });
+    }
+
+    /**
+     * Remove all files from string attribute html that are stored in public
+     *
+     * @param string $htmlString The html string with alreadyParsed files using storeModelFilesFromHtml.
+     * @return void
+     */
+    public static function removeModelFilesOfHtml(string $htmlString): void
+    {
+        $filesToRemove = \collect(self::onlyUploadedFilesWithFileStorageHelper(self::findFilesInHtml($htmlString)));
+        $filesToRemove->each(function (string $publicStorageFilePath) {
+            $path = ToolboxHelper::mbReplace('storage/', '', \ltrim(\urldecode($publicStorageFilePath), '/'));
+            if (Storage::disk('public')->exists($path)) {
+                Storage::disk('public')->delete($path);
+            }
+        });
+    }
+
+    /**
+     * Find all occurence of files in html
+     *
+     * @param string $html
+     * @return array
+     */
+    public static function findFilesInHtml(string $html): array
+    {
+        preg_match_all('/href="(?P<href>.*)"|src="(?P<src>.*)"|url="(?P<url>.*)"/Um', $html, $m, PREG_SET_ORDER, 0);
+        return collect($m)->pluck('href')->filter()
+            ->concat(collect($m)->pluck('url')->filter())
+            ->concat(collect($m)->pluck('src')->filter())
+            ->all();
+    }
+
+    /**
+     * Filter array to get only uploaded files that exists
+     * on disk 'public' (using helper storage strategy)
+     *
+     * @param array $urls
+     * @return array
+     */
+    public static function onlyUploadedFilesWithFileStorageHelper(array $urls): array
+    {
+        return \collect($urls)->unique()
+            // * Filter to get only /uploads and using app url or empty
+            ->filter(function (string $url) {
+                $path = \parse_url($url, \PHP_URL_PATH);
+                return \strpos(\ltrim($path, '/'), 'storage/modelfiles') === 0;
+            })->filter(function (string $url) {
+                $path = \parse_url($url, \PHP_URL_PATH);
+                return Storage::disk('public')
+                    ->exists(ToolboxHelper::mbReplace('storage/', '', \ltrim(\urldecode($path), '/')));
+            })->all();
+    }
+
+    /**
+     * Filter array to get only uploaded files that exists
+     * on disk 'uploads'
+     *
+     * @param array $urls
+     * @return array
+     */
+    private static function onlyUploadedFilesWithFileManager(array $urls): array
+    {
+        return \collect($urls)->unique()
+            // * Filter to get only /uploads and using app url or empty
+            ->filter(function (string $url) {
+                $host = \parse_url($url, \PHP_URL_HOST);
+                $path = \parse_url($url, \PHP_URL_PATH);
+                return ($host === \parse_url(config('app.url'), PHP_URL_HOST) or \is_null($host)) and
+                    \strpos(\ltrim($path, '/'), 'uploads') === 0;
+            })->filter(function (string $url) {
+                $path = \parse_url($url, \PHP_URL_PATH);
+                return Storage::disk('uploads')
+                    ->exists(ToolboxHelper::mbReplace('uploads/', '', \ltrim(\urldecode($path), '/')));
+            })->all();
+    }
+
+    /**
+     * Prepare storage path and return
+     * the file full path
+     *
+     * @param string  $tableName Model table name.
+     * @param string  $filename  The basename for the file.
+     * @param boolean $private   May the file be stored in a private dir.
+     * @return string
+     */
+    private static function prepareMoveFile(string $tableName, string $filename, bool $private = false): string
+    {
+        // * Security filter
+        $filename = \htmlspecialchars($filename);
+        // * Security filter + beautifier
+        $filename = self::sanitizeFileName($filename);
+        // * Slugify filename
+        $ext      = \pathinfo($filename, \PATHINFO_EXTENSION);
+        $filename = Str::slug(\pathinfo($filename, \PATHINFO_FILENAME)) .
+            (\strlen($ext) ? ".{$ext}" : '');
+
+        $folderPath = self::getStoragePath(
+            $private ? 'app/private/modelfiles' : 'app/public/modelfiles',
+            $tableName,
+            $filename,
+            $private
+        );
+        $filename   = self::getFileUniqueName($folderPath, $filename);
+        return "{$folderPath}/{$filename}";
+    }
+
+    /**
+     * Create sub folders to store files using pattern
+     * storage/modelfiles/posts/10/04/19/5f
+     * year/month/day/md5 first 2 letters
+     *
+     * @param string $storage_dir
+     * @param string $table
+     * @param string $filename
+     * @return string
+     */
+    private static function getStoragePath(string $storage_dir, string $table, string $filename): string
+    {
+        $filenameHash = \md5($filename);
+        $pathFolder   = \storage_path(sprintf(
+            '%s/%s/%s/%s/%s/%s',
+            $storage_dir,
+            $table,
+            gmdate('y'),
+            gmdate('m'),
+            gmdate('d'),
+            substr($filenameHash, 0, 2)
+        ));
+        if (!File::exists($pathFolder)) {
+            File::makeDirectory($pathFolder, 0755, true);
+        }
+        return $pathFolder;
+    }
+
+    /**
+     * Get unique filename if the path is already occupied
+     *
+     * @param string $folderPath
+     * @param string $filename
+     * @return string
+     * @throws \RuntimeException If a unique filename cannot be obtained.
+     */
+    private static function getFileUniqueName(string $folderPath, string $filename): string
+    {
+        $attempts    = 0;
+        $maxAttempts = 20;
+        while (File::exists("{$folderPath}/{$filename}")) {
+            if ($attempts++ >= $maxAttempts) {
+                throw new \RuntimeException("Failed to have a unique filename for {$folderPath}/{$filename}");
+            }
+            $filename = pathinfo($filename, \PATHINFO_FILENAME) .
+                \uniqid('-') . '.' .
+                pathinfo($filename, \PATHINFO_EXTENSION);
+        }
+        return $filename;
+    }
+
+    /**
+     * Slugify the filename
+     *
+     * @param string $filename
+     * @return string
+     */
+    public static function slugifyFileName(string $filename): string
+    {
+        return Str::slug(pathinfo($filename, \PATHINFO_FILENAME)) . '.' . pathinfo($filename, \PATHINFO_EXTENSION);
+    }
+
+    /**
+     * Sanitize File name for uploaded files
+     *
+     * @param string  $filename The original uploaded client file name.
+     * @param boolean $beautify Beautify the filename.
+     * @return string The sanitized file name.
+     */
+    public static function sanitizeFileName(string $filename, bool $beautify = true): string
+    {
+        // * Sanitize filename
+        // phpcs:disable Generic.Files.LineLength.TooLong
+        $filename = preg_replace(
+            '~
+            [<>:"/\\\|?*]|           # file system reserved https://en.wikipedia.org/wiki/Filename#Reserved_characters_and_words
+            [\x00-\x1F]|             # control characters http://msdn.microsoft.com/en-us/library/windows/desktop/aa365247%28v=vs.85%29.aspx
+            [\x7F\xA0\xAD]|          # non-printing characters DEL, NO-BREAK SPACE, SOFT HYPHEN
+            [#\[\]@!$&\'()+,;=]|     # URI reserved https://tools.ietf.org/html/rfc3986#section-2.2
+            [{}^\~`]                 # URL unsafe characters https://www.ietf.org/rfc/rfc1738.txt
+            ~x',
+            '-',
+            $filename
+        );
+        // phpcs:enable
+        // * Avoids '.' '..' or '.hiddenFiles' .
+        $filename = Str::of($filename)->ltrim('.-');
+        // * Optional beautification
+        if ($beautify) {
+            $filename = static::beautifyFilename($filename);
+        }
+        // * Maximize filename length to 255 bytes http://serverfault.com/a/9548/44086
+        /** @var string */
+        $extension = pathinfo($filename, \PATHINFO_EXTENSION);
+        /** @var string */
+        $filename = pathinfo($filename, \PATHINFO_FILENAME);
+
+        $encoding = mb_detect_encoding($filename);
+        $encoding = $encoding ? $encoding : null;
+        return \mb_strcut(
+            $filename,
+            0,
+            255 - (!empty($extension) ? strlen($extension) + 1 : 0),
+            $encoding
+        ) . (!empty($extension) ? ".$extension" : '');
+    }
+
+    /**
+     * Beautify a filename
+     *
+     * @param string $filename
+     * @return string
+     */
+    private static function beautifyFilename(string $filename): string
+    {
+        // Reduce consecutive characters.
+        $filename = preg_replace([
+            // * "file   name.zip" becomes 'file-name.zip'
+            '/ +/',
+            // * "file___name.zip" becomes 'file-name.zip'
+            '/_+/',
+            // * "file---name.zip" becomes 'file-name.zip'
+            '/-+/'
+        ], '-', $filename);
+        $filename = preg_replace([
+            // * "file--.--.-.--name.zip" becomes "file.name.zip"
+            '/-*\.-*/',
+            // * "file...name..zip" becomes "file.name.zip"
+            '/\.{2,}/'
+        ], '.', $filename);
+        // Lowercase for windows/unix interoperability http://support.microsoft.com/kb/100625 .
+        $filename = mb_strtolower($filename, mb_detect_encoding($filename));
+        // * ".file-name.-" becomes "file-name"
+        $filename = trim($filename, '.-');
+        return $filename;
+    }
+}

app/Lib/Helpers/ToolboxHelper.php

@@ -0,0 +1,410 @@
+<?php
+
+namespace App\Lib\Helpers;
+
+use Illuminate\Contracts\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\File;
+use Illuminate\Support\Facades\Route;
+use Illuminate\Support\Facades\Storage;
+use Illuminate\Support\Facades\Validator;
+use Illuminate\Validation\Rule;
+use Illuminate\Validation\ValidationException;
+use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
+
+class ToolboxHelper
+{
+    /**
+     * Strip scheme (https) on oembed urls
+     * Only embed allowed are for MP4 self hosted videos right now
+     *
+     * https is force by ckeditor MediaElements which natively supports
+     * only cloud hosted medias (youtube, spotify etc..)
+     *
+     * @param string $input
+     * @return string
+     */
+    public static function stripCkEditorSchemesOnMediaInputs(string $input): string
+    {
+        $input = \preg_replace('/(?<=<oembed url=")(https:\/\/)(?=.*?">)/m', '', $input);
+        return $input;
+    }
+
+    /**
+     * Assert That no Back Office url is present on txt
+     *
+     * @param string $field
+     * @param string $text
+     * @return string
+     * @throws \Illuminate\Validation\ValidationException If url is a bo url.
+     */
+    public static function assertNoInternalBoUrls(string $field, string $text): string
+    {
+        $routes = Route::getRoutes();
+        // * Url replace and email replace.
+        $text = preg_replace_callback(
+            // phpcs:ignore Generic.Files.LineLength.TooLong
+            '/(?P<url>(?:http[s]?:\/\/.)?(?:www\.)?[-a-zA-Z0-9@%._\+~#=]{2,256}\.[a-z]{2,6}\b(?:[-a-zA-Z0-9@:%_\+.~#?&\/\/=]*))/',
+            function ($matches) use ($routes, $field) {
+                $match = collect($matches)->first() ?? '';
+                $url   = $match;
+                try {
+                    $request = Request::create($url);
+                    // If a route is match then it do not throws exception.
+                    if (
+                        \parse_url(config('app.url'), \PHP_URL_HOST) === \parse_url($url, \PHP_URL_HOST) &&
+                        trim($routes->match($request)->getPrefix() ?? '', '/') === 'bo'
+                    ) {
+                        // Removes the matched url.
+                        throw ValidationException::withMessages([
+                            $field => trans(
+                                'crud.libs.toolbox.assertNoInternalBoUrls',
+                                ['attribute' => $field]
+                            )
+                        ]);
+                    }
+                    return $match;
+                } catch (NotFoundHttpException $e) {
+                    return $match;
+                }
+            },
+            $text
+        );
+        return $text;
+    }
+
+    /**
+     * Assert That only external url is present on txt
+     *
+     * @param string $field
+     * @param string $text
+     * @return string
+     * @throws \Illuminate\Validation\ValidationException If url is a bo url.
+     */
+    public static function assertNoInternalUrls(string $field, string $text): string
+    {
+        self::assertNoInternalBoUrls($field, $text);
+        $routes = Route::getRoutes();
+        // * Url replace and email replace.
+        $text = preg_replace_callback(
+            // phpcs:ignore Generic.Files.LineLength.TooLong
+            '/(?P<url>(?:http[s]?:\/\/.)?(?:www\.)?[-a-zA-Z0-9@%._\+~#=]{2,256}\.[a-z]{2,6}\b(?:[-a-zA-Z0-9@:%_\+.~#?&\/\/=]*))/',
+            function ($matches) use ($routes, $field) {
+                $match = collect($matches)->first() ?? '';
+                $url   = $match;
+                try {
+                    $request = Request::create($url);
+                    // If a route is match then it do not throws exception.
+                    if (
+                        \parse_url(config('app.url'), \PHP_URL_HOST) === \parse_url($url, \PHP_URL_HOST) &&
+                        $routes->match($request)
+                    ) {
+                        // Removes the matched url.
+                        throw ValidationException::withMessages([
+                            $field => trans(
+                                'crud.libs.toolbox.assertNoInternalUrls',
+                                ['attribute' => $field, 'appname' => config('app.name')]
+                            )
+                        ]);
+                    }
+                    return $match;
+                } catch (NotFoundHttpException $e) {
+                    return $match;
+                }
+            },
+            $text
+        );
+        return $text;
+    }
+
+    /**
+     * Mutltibyte string replace
+     *
+     * @param array|string $search
+     * @param array|string $replace
+     * @param array|string $subject
+     * @param integer      $count
+     * @return array|string
+     */
+    public static function mbReplace(
+        array|string $search,
+        array|string $replace,
+        array|string $subject,
+        int &$count = 0
+    ): array|string {
+        if (!is_array($search) && is_array($replace)) {
+            return false;
+        }
+        if (is_array($subject)) {
+            // Call mb_replace for each single string in $subject .
+            foreach ($subject as &$string) {
+                $string = &self::mbReplace($search, $replace, $string, $count);
+            }
+        } elseif (is_array($search)) {
+            if (!is_array($replace)) {
+                foreach ($search as &$string) {
+                    $subject = self::mbReplace($string, $replace, $subject, $count);
+                }
+            } else {
+                $n = max(count($search), count($replace));
+                while ($n--) {
+                    $subject = self::mbReplace(current($search), current($replace), $subject, $count);
+                    next($search);
+                    next($replace);
+                }
+            }
+        } else {
+            $parts   = mb_split(preg_quote($search), $subject);
+            $count   = count($parts) - 1;
+            $subject = implode($replace, $parts);
+        } //end if
+        return $subject;
+    }
+
+    /**
+     * Asserts that the field is unique
+     *
+     * @param string                                  $table
+     * @param string                                  $field
+     * @param string|integer|float|boolean|null|array $value
+     * @param integer|null                            $id
+     * @param callable|null                           $query
+     * @return void
+     * @throws \Illuminate\Validation\ValidationException If the field is not unique.
+     */
+    public static function assertFieldIsUnique(
+        string $table,
+        string $field,
+        string|int|float|bool|null|array $value,
+        ?int $id = null,
+        ?callable $query = null
+    ) {
+        if (!$query) {
+            Validator::make([$field => $value], [
+                self::mbReplace('.', '\.', $field) => Rule::unique($table, $field)->ignore($id),
+            ], [
+                self::mbReplace('.', '\.', "{$field}.unique")
+                => trans('crud.libs.toolbox.assertFieldIsUnique', ['attribute' => $field, 'value' => $value])
+            ])->validate();
+            return;
+        }
+        Validator::make([$field => $value], [
+            $field => Rule::unique($table)->where($query)->ignore($id),
+        ], [
+            $field . '.unique' => trans(
+                'crud.libs.toolbox.assertFieldIsUnique',
+                ['attribute' => $field, 'value' => $value]
+            )
+        ])->validate();
+    }
+
+    /**
+     * Get original polyfill with autotranslate behavior
+     *
+     * @param \Illuminate\Database\Eloquent\Model $model
+     * @param string                              $attribute
+     * @return mixed
+     */
+    public static function getOriginal(Model $model, string $attribute): mixed
+    {
+        if (\in_array('Spatie\Translatable\HasTranslations', \class_uses_recursive($model))) {
+            return $model->getTranslation(
+                $attribute,
+                $model->getLocale(),
+                $model->useFallbackLocale()
+            );
+        }
+        return $model->getOriginal($attribute);
+    }
+
+    /**
+     * Dynamic model query
+     *
+     * @param string                                          $defaultLocale
+     * @param \Illuminate\Contracts\Database\Eloquent\Builder $q
+     * @param string                                          $column
+     * @param string                                          $value
+     * @return \Illuminate\Contracts\Database\Eloquent\Builder
+     */
+    public static function queryColumnWithLocales(
+        string $defaultLocale,
+        Builder $q,
+        string $column,
+        string $value
+    ): Builder {
+        $currentLocale = app()->currentLocale();
+        $locales       = collect(config('app.locales'))
+        ->mapWithKeys(fn (string $locale) => [$locale => $locale]);
+        if (!$locales->has($defaultLocale)) {
+            // * Remove default locale.
+            $locales->pull($defaultLocale);
+        }
+        if (!$locales->has($currentLocale)) {
+            // * Remove current locale.
+            $locales->pull($currentLocale);
+        }
+
+        return $q->where(function (Builder $q) use ($defaultLocale, $currentLocale, $locales, $column, $value) {
+            // * Query default locale
+            $q->whereRaw("JSON_EXTRACT({$column}, '$.{$defaultLocale}') = '{$value}'");
+            if ($defaultLocale !== $currentLocale) {
+                // * Query current locale
+                $q->whereRaw("JSON_EXTRACT({$column}, '$.{$currentLocale}') = '{$value}'");
+            }
+            // * Query any other locale
+            $locales->each(fn ($locale) => $q->orWhereRaw(
+                "JSON_EXTRACT({$column}, '$.{$locale}') = '{$value}'"
+            ));
+        });
+    }
+
+    /**
+     * Generates an array from a dot separated string
+     *
+     * @param string $path
+     * @param mixed  $value
+     * @param string $separator
+     * @return array
+     */
+    public static function dotStringToNestedArray(string $path, mixed $value, string $separator = '.'): array
+    {
+        $arr  = $value;
+        $keys = array_reverse(explode($separator, $path));
+
+        foreach ($keys as $key) {
+            $arr = [$key => $arr];
+        }
+        return $arr;
+    }
+
+    /**
+     * Convert deeply an object to array
+     *
+     * @param array|object $input
+     * @return array
+     * @throws \RuntimeException If $input var is a scalar value.
+     */
+    public static function objectToArray($input): array
+    {
+        // Only process if it's an object or array being passed to the function.
+        if (is_object($input) or is_array($input)) {
+            $ret = (array)$input;
+            foreach ($ret as &$item) {
+                // Recursively process EACH element only if not scalar.
+                $item = (is_object($item) or is_array($item)) ?
+                    self::objectToArray($item) : $item;
+            }
+            return $ret;
+        } else {
+            throw new \RuntimeException('Cannot handle $input of type ' . \gettype($input));
+        }
+    }
+
+    /**
+     * Convert deeply an array to object
+     *
+     * @param array|object $input
+     * @return object
+     * @throws \RuntimeException If $input var is a scalar value.
+     */
+    public static function arrayToObject($input): object
+    {
+        // Only process if it's an object or array being passed to the function.
+        if (is_object($input) or is_array($input)) {
+            $ret = (object)$input;
+            foreach ($ret as &$item) {
+                // Recursively process EACH element only if not scalar.
+                $item = (is_object($item) or is_array($item)) ?
+                    self::arrayToObject($item) : $item;
+            }
+            return $ret;
+        } else {
+            throw new \RuntimeException('Cannot handle $input of type ' . \gettype($input));
+        }
+    }
+
+    /**
+     * Validate picture
+     *
+     * @param string      $attribute
+     * @param string|null $value
+     * @param callback    $fail
+     * @param object      $sizes
+     * @return void
+     */
+    public static function validatePicture(string $attribute, string|null $value, callable $fail, object $sizes)
+    {
+        if (!($useStorage = Storage::exists($value)) and !File::exists($value)) {
+            $fail(trans(':attribute n\'existe pas dans le système de fichier', [
+                'attribute' => $attribute
+            ]));
+            return;
+        }
+        /** @var string */
+        $fileFullPath = self::getUploadedFileFullPath($value, $useStorage);
+        if (
+            !\in_array(self::getUploadedFileMimeType($value, $useStorage), [
+                'image/jpeg', 'image/jpg', 'image/png', 'image/gif'
+            ])
+        ) {
+            $fail(trans(':attribute doit être une image de type \'image/jpeg,image/jpg,image/png,image/gif\'', [
+                'attribute' => $attribute
+            ]));
+        }
+        if (!($dimensions = \getimagesize($fileFullPath)) or !isset($dimensions[0]) or !isset($dimensions[1])) {
+            $fail(trans(':attribute impossible de valider les dimensions', [
+                'attribute' => $attribute
+            ]));
+        } else {
+            $width  = intval($dimensions[0]);
+            $height = intval($dimensions[1]);
+
+            $xMessage = trans(
+                ":attribute la largeur doit être comprise entre {$sizes->minWith}px et {$sizes->maxWith}px"
+            );
+            if ($sizes->minWith === $sizes->maxWith) {
+                $xMessage = trans(":attribute la largeur doit être de {$sizes->minWith}px");
+            }
+            $yMessage = trans(
+                ":attribute la hauteur doit être comprise entre {$sizes->minWith}px et {$sizes->maxWith}px"
+            );
+            if ($sizes->minHeight === $sizes->maxHeight) {
+                $yMessage = trans(":attribute la hauteur doit être de {$sizes->minWith}px");
+            }
+
+            if (($width < $sizes->minWith) or ($width > $sizes->maxWith)) {
+                $fail($xMessage);
+            }
+            if (($height < $sizes->minHeight) or ($height > $sizes->maxHeight)) {
+                $fail($yMessage);
+            }
+        } //end if
+    }
+
+    /**
+     * Get the file full path
+     *
+     * @param string  $value
+     * @param boolean $useStorage
+     * @return string
+     */
+    private static function getUploadedFileFullPath(string $value, bool $useStorage): string
+    {
+        /** @var \Illuminate\Filesystem\FilesystemAdapter */
+        $disk = Storage::disk();
+        return !$useStorage ? (realpath($value) ?: $value) : $disk->path($value);
+    }
+
+    /**
+     * Get the file mimetype
+     *
+     * @param string  $value
+     * @param boolean $useStorage
+     * @return string|false
+     */
+    private static function getUploadedFileMimeType(string $value, bool $useStorage)
+    {
+        return !$useStorage ? File::mimeType($value) : Storage::mimeType($value);
+    }
+}

app/Models/User.php

@@ -0,0 +1,65 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Foundation\Auth\User as Authenticatable;
+use Illuminate\Notifications\Notifiable;
+use Illuminate\Support\Facades\Hash;
+
+class User extends Authenticatable
+{
+    use HasFactory;
+    use Notifiable;
+
+    /**
+     * The attributes that are mass assignable.
+     *
+     * @var array<int, string>
+     */
+    protected $fillable = [
+        'firstname',
+        'lastname',
+        'email',
+        'password',
+    ];
+
+    /**
+     * The attributes that should be hidden for serialization.
+     *
+     * @var array<int, string>
+     */
+    protected $hidden = [
+        'password',
+        'remember_token',
+    ];
+
+    /**
+     * The attributes that should be cast.
+     *
+     * @var array<string, string>
+     */
+    protected $casts = [
+        'email_verified_at' => 'datetime',
+    ];
+
+    /**
+     * Perform any actions required after the model boots.
+     *
+     * @return void
+     */
+    protected static function booted()
+    {
+        // * EVENT CLOSURES.
+        static::creating(function (self $model) {
+            if (Hash::needsRehash($model->password)) {
+                $model->password = Hash::make($model->password);
+            }
+        });
+        static::updating(function (self $model) {
+            if (Hash::needsRehash($model->password)) {
+                $model->password = Hash::make($model->password);
+            }
+        });
+    }
+}

app/Providers/AppServiceProvider.php

@@ -0,0 +1,70 @@
+<?php
+
+namespace App\Providers;
+
+use Illuminate\Pagination\Paginator;
+use Illuminate\Support\Carbon;
+use Illuminate\Support\Facades\App;
+use Illuminate\Support\Facades\URL;
+use Illuminate\Support\ServiceProvider;
+
+class AppServiceProvider extends ServiceProvider
+{
+    /**
+     * Register any application services.
+     *
+     * @return void
+     */
+    public function register()
+    {
+    }
+
+    /**
+     * Bootstrap any application services.
+     *
+     * @return void
+     */
+    public function boot()
+    {
+        // * HTTPS FIX
+        URL::forceScheme('https');
+
+        // * HA PROXY FIX
+        App::singleton('clientIp', function () {
+            if (config('app.env') === 'local') {
+                return request()->getClientIp();
+            } else {
+                return request()->server('HTTP_X_FORWARDED_FOR') ??
+                request()->getClientIp();
+            }
+        });
+
+        // * LOCAL FORCE eg: for Carbon
+        setlocale(LC_ALL, \sprintf(
+            '%s_%s.UTF-8',
+            config('app.locale'),
+            \strtoupper(config('app.locale'))
+        ));
+        Carbon::setLocale(config('app.locale'));
+
+        $this->sharetoView();
+    }
+
+    /**
+     * Share Vars to view
+     *
+     * @return void
+     */
+    private function sharetoView()
+    {
+        if (!app()->runningInConsole()) {
+            // * FORCE BOOTSTRAP PAGINATOR (or custom if in front)
+            // Early boot, request wont be filled as expected.
+            if (collect(explode('/', \request()->getPathInfo()))->get(1) === 'bo') {
+                Paginator::useBootstrap();
+            } else {
+                Paginator::useBootstrap();
+            }
+        }
+    }
+}

app/Providers/AuthServiceProvider.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Providers;
+
+use Illuminate\Foundation\Support\Providers\AuthServiceProvider as ServiceProvider;
+
+class AuthServiceProvider extends ServiceProvider
+{
+    /**
+     * The model to policy mappings for the application.
+     *
+     * @var array<class-string, class-string>
+     */
+    protected $policies = [];
+
+    /**
+     * Register any authentication / authorization services.
+     *
+     * @return void
+     */
+    public function boot(): void
+    {
+    }
+}

app/Providers/EventServiceProvider.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace App\Providers;
+
+use Illuminate\Auth\Events\Registered;
+use Illuminate\Auth\Listeners\SendEmailVerificationNotification;
+use Illuminate\Foundation\Support\Providers\EventServiceProvider as ServiceProvider;
+
+class EventServiceProvider extends ServiceProvider
+{
+    /**
+     * The event to listener mappings for the application.
+     *
+     * @var array<class-string, array<int, class-string>>
+     */
+    protected $listen = [
+        Registered::class => [
+            SendEmailVerificationNotification::class,
+        ],
+    ];
+
+    /**
+     * Register any events for your application.
+     *
+     * @return void
+     */
+    public function boot(): void
+    {
+    }
+
+    /**
+     * Determine if events and listeners should be automatically discovered.
+     *
+     * @return boolean
+     */
+    public function shouldDiscoverEvents(): bool
+    {
+        return false;
+    }
+}

app/Providers/RouteServiceProvider.php

@@ -0,0 +1,97 @@
+<?php
+
+namespace App\Providers;
+
+use Illuminate\Cache\RateLimiting\Limit;
+use Illuminate\Foundation\Support\Providers\RouteServiceProvider as ServiceProvider;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\RateLimiter;
+use Illuminate\Support\Facades\Route;
+
+class RouteServiceProvider extends ServiceProvider
+{
+    /**
+     * The path to your application's "home" route.
+     *
+     * Typically, users are redirected here after authentication.
+     *
+     * @var string
+     */
+    public const HOME = '/';
+
+    /**
+     * Define your route model bindings, pattern filters, and other route configuration.
+     *
+     * @return void
+     */
+    public function boot(): void
+    {
+        $this->configureRateLimiting();
+
+        $this->cspReportRoute();
+
+        $this->routes(function () {
+            Route::middleware('web')
+                ->namespace($this->namespace)
+                ->group(base_path('routes/web-bo.php'));
+
+            Route::middleware('web')
+                ->namespace($this->namespace)
+                ->group(base_path('routes/web-fo.php'));
+        });
+    }
+
+    /**
+     * Configure the rate limiters for the application.
+     *
+     * @return void
+     */
+    protected function configureRateLimiting(): void
+    {
+        RateLimiter::for('api', function (Request $request) {
+            return Limit::perMinute(150)->by($request->user()?->id ?: app('clientIp'));
+        });
+        RateLimiter::for('web', function (Request $request) {
+            return Limit::perMinute(150)->by($request->user()?->id ?: app('clientIp'));
+        });
+        RateLimiter::for('credentials', function (Request $request) {
+            return Limit::perMinute(30)->by($request->user()?->id ?: app('clientIp'));
+        });
+    }
+
+    /**
+     * * Register CSP report URI
+     *
+     * Put this function inside RouteServiceProvider,
+     * and call it in RouteServiceProvider::boot
+     *
+     * @return void
+     */
+    private function cspReportRoute()
+    {
+        // * CSP REPORT URI, Please add /csp-report to VerifyCsrfToken $except middleware
+        \Illuminate\Support\Facades\Route::post('/csp-report', function () {
+            $isCspRequest = request()->header('Content-Type') === 'application/csp-report';
+            if (!$isCspRequest or !request()->json('csp-report') or !is_array(request()->json('csp-report'))) {
+                abort(401);
+            }
+            // * Flatten if needed
+            $cspReport = collect(request()->json('csp-report'))
+            ->flatMap(function ($v, $k) {
+                return [$k => is_array($v) ? collect($v)->flatten()->implode(', ') : $v];
+            })->all();
+            // * Filter array keys
+            $cspReport = collect(array_intersect_key($cspReport, [
+                'blocked-uri' => '', 'document-uri' => '', 'original-policy' => '',
+                'referrer' => '', 'violated-directive' => ''
+            ]));
+            \Illuminate\Support\Facades\Log::warning(sprintf(
+                "CSP REPORT for %s : \n %s",
+                $cspReport->get('document-uri'),
+                $cspReport->implode("\n")
+            ));
+        })->middleware('throttle:5,2')
+            ->withoutMiddleware(\App\Http\Middleware\VerifyCsrfToken::class)
+            ->name('cspReportUri');
+    }
+}

app/Providers/TranslationServiceProvider.php

@@ -0,0 +1,78 @@
+<?php
+
+namespace App\Providers;
+
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\File;
+use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\ServiceProvider;
+use Symfony\Component\Finder\SplFileInfo;
+
+class TranslationServiceProvider extends ServiceProvider
+{
+    /**
+     * Bootstrap the application services.
+     *
+     * @return void
+     */
+    public function boot(): void
+    {
+        foreach ($this->collectLocalesStrings() as $locale) {
+            // * Suported locales
+            Cache::rememberForever(sprintf('translations.%s', $locale), function () use ($locale) {
+                $translations = [
+                    'php' => $this->phpTranslations($locale),
+                    'json' => $this->jsonTranslations($locale),
+                ];
+                return $translations;
+            });
+        }
+    }
+
+    /**
+     * Gather provided langs checking from files
+     *
+     * @return \Illuminate\Support\Collection<string, string>
+     */
+    private function collectLocalesStrings(): Collection
+    {
+        return collect(File::allFiles(resource_path('lang/')))->flatMap(function (SplFileInfo $file) {
+            if ($file->getRelativePath() and \strpos($file->getRelativePath(), 'vendor') !== 0) {
+                return [$file->getRelativePath() => ''];
+            }
+        })->keys();
+    }
+
+    /**
+     * Gather all php translations
+     *
+     * @param string $locale
+     * @return array<string, string>
+     */
+    private function phpTranslations(string $locale): array
+    {
+        $path = resource_path("lang/$locale");
+
+        return collect(File::allFiles($path))->flatMap(function ($file) use ($locale) {
+            $translation = $file->getBasename('.php');
+            return [$translation => trans($translation, [], $locale)];
+        })->all();
+    }
+
+    /**
+     * Gather json translations
+     *
+     * @param string $locale
+     * @return array<string, string>
+     */
+    private function jsonTranslations(string $locale): array
+    {
+        $path = resource_path("lang/$locale.json");
+
+        if (is_string($path) && is_readable($path)) {
+            return json_decode(file_get_contents($path), true) ?? [];
+        }
+
+        return [];
+    }
+}

app/Traits/Enums/BaseEnum.php

@@ -0,0 +1,205 @@
+<?php
+
+namespace App\Traits\Enums;
+
+use Illuminate\Support\Str;
+
+/**
+ * @author Jérémy Munsch <jeremy.munsch@ldc.fr>
+ */
+trait BaseEnum
+{
+    // * GENERIC METHODS
+    /**
+     * Get enum value
+     *
+     * @return string|integer
+     */
+    public function value(): string|int
+    {
+        return self::toValues()[$this->name];
+    }
+
+    /**
+     * Get enum label
+     *
+     * @return string
+     */
+    public function label(): string
+    {
+        return self::toLabels()[$this->name];
+    }
+
+    // * STATIC FETCH METHODS
+
+    /**
+     * Get enum labels
+     *
+     * @return array<string>
+     */
+    public static function toLabels(): array
+    {
+        if (empty(self::getCache('labels'))) {
+            $labels = self::getLabelsConstant();
+            self::setCache('labels', \collect(self::cases())
+                ->mapWithKeys(function ($enum) use ($labels) {
+                    if (!\is_null($labels) and !isset($labels[$enum->name])) {
+                        throw new \Error('Missing definition label ' . self::class . " for {$enum->name}");
+                    }
+                    return [$enum->name => \trans(
+                        !\is_null($labels) ? $labels[$enum->name] : Str::ucfirst($enum->name)
+                    )];
+                })->all());
+        }
+        return self::getCache('labels');
+    }
+
+    /**
+     * Get enum values
+     *
+     * @return array<integer|string>
+     */
+    public static function toValues(): array
+    {
+        if (empty(self::getCache('values'))) {
+            self::setCache('values', \collect(self::cases())
+                ->mapWithKeys(fn ($enum) => [$enum->name => $enum->value])->all());
+        }
+        return self::getCache('values');
+    }
+
+    /**
+     * Get enums
+     *
+     * @return array
+     */
+    public static function toArray(): array
+    {
+        if (empty(self::getCache('enums'))) {
+            $definitions = self::getCustomDefinitions();
+            self::setCache('enums', \collect(self::cases())
+                ->mapWithKeys(function ($enum) use ($definitions) {
+                    $baseArray = [
+                        'name' => $enum->name,
+                        'label' => $enum->label(),
+                        'value' => $enum->value,
+                    ];
+                    foreach ($definitions as $index => $elements) {
+                        $index = Str::lower(Str::singular($index));
+                        if (!isset($elements[$enum->name])) {
+                            throw new \Error("Missing definition {$index} " . self::class . " for {$enum->name}");
+                        }
+                        $baseArray[$index] = $elements[$enum->name];
+                    }
+                    return [$enum->name => (object)$baseArray];
+                })->all());
+        }
+        return self::getCache('enums');
+    }
+
+    /**
+     * Fetch enum using value
+     *
+     * @param \App\Traits\Enums\BaseEnum|integer|string $value
+     * @return \App\Traits\Enums\BaseEnum|null
+     */
+    public static function make(self|int|string $value): self|null
+    {
+        return !\is_object($value) ?
+            \collect(self::cases())->keyBy('value')->get($value) : $value;
+    }
+
+
+    // * CACHE
+
+    /**
+     * Get cache array
+     *
+     * @param string $index
+     * @return array
+     */
+    private static function getCache(string $index): array
+    {
+        self::initCache();
+        if (!isset($GLOBALS[self::class]['props'][$index])) {
+            $GLOBALS[self::class]['props'][$index] = [];
+        }
+        return $GLOBALS[self::class]['props'][$index];
+    }
+
+    /**
+     * Set cache array
+     *
+     * @param string $index
+     * @param array  $items
+     * @return void
+     */
+    private static function setCache(string $index, array $items): void
+    {
+        self::initCache();
+        if (!isset($GLOBALS[self::class]['props'][$index])) {
+            $GLOBALS[self::class]['props'][$index] = [];
+        }
+        $GLOBALS[self::class]['props'][$index] = $items;
+    }
+
+    /**
+     * Init cache if needed
+     *
+     * @return void
+     */
+    private static function initCache(): void
+    {
+        if (!isset($GLOBALS[self::class])) {
+            $GLOBALS[self::class] = [
+                'props' => [
+                    'enums' => [],
+                    'values' => [],
+                    'labels' => []
+                ],
+                'customProps' => null
+            ];
+        }
+    }
+
+    // * PRIVATE
+
+    /**
+     * Fetch the LABELS constant if exists
+     *
+     * @return array|null
+     */
+    private static function getLabelsConstant(): array|null
+    {
+        $class_name = self::class;
+        try {
+            $constant_reflex = new \ReflectionClassConstant($class_name, 'LABELS');
+            return $constant_reflex->getValue();
+        } catch (\ReflectionException $e) {
+            return null;
+        }
+    }
+
+    /**
+     * Get custom constants
+     *
+     * @return array
+     */
+    private static function getCustomDefinitions(): array
+    {
+        // ? Has custom props in cache ?
+        if (\is_null($GLOBALS[self::class]['customProps'])) {
+            $names = \collect(self::cases())->keyBy('name');
+
+            $GLOBALS[self::class]['customProps'] = \collect((new \ReflectionClass(self::class))->getConstants())
+                ->filter(function (mixed $constant, string $key) use ($names) {
+                    if ($key === 'LABELS' or !\is_array($constant)) {
+                        return false;
+                    }
+                    return \collect($constant)->keys()
+                        ->filter(fn (string $name) => $names->has($name))->count();
+                })->all();
+        }
+        return $GLOBALS[self::class]['customProps'];
+    }
+}

app/Traits/Models/MiniCrudModel.php

@@ -0,0 +1,179 @@
+<?php
+
+namespace App\Traits\Models;
+
+use App\Enums\InputType;
+use App\Lib\Helpers\FileStorageHelper;
+use App\Lib\Helpers\ToolboxHelper;
+
+trait MiniCrudModel
+{
+    /**
+     * Fill the model with an array of attributes.
+     *
+     * @param  array $attributes
+     * @return void
+     * @throws \Illuminate\Database\Eloquent\MassAssignmentException If fill prop is not allowed.
+     * @phpcs:disable Squiz.Commenting.FunctionComment.EmptyThrows
+     */
+    public function fill(array $attributes)
+    {
+        // phpcs:enable
+        parent::fill($attributes);
+        if (isset($attributes['data'])) {
+            $this->setData($attributes['data']);
+        }
+    }
+
+    /**
+     * Apply function on data typed text while on save event
+     *
+     * @return void
+     */
+    public function minicrudCreating()
+    {
+        /** @var array<string,array> */
+        $data = $this->data;
+        foreach ($data as &$input) {
+            switch ($input['inputType']) {
+                case InputType::text->value:
+                    $input['text'] = clean($input['text']);
+                    $input['text'] = FileStorageHelper::storeModelFilesFromHtml($this, $input['text']);
+                    break;
+            } //end switch
+        } //end foreach
+        $this->data = $data;
+    }
+
+    /**
+     * Apply function on data typed text while on update event
+     *
+     * @return void
+     */
+    public function minicrudUpdating()
+    {
+        $this->minicrudCreating();
+    }
+
+    /**
+     * Apply function on data typed text while on updated event
+     *
+     * @return void
+     */
+    public function minicrudUpdated()
+    {
+        /** @var array */
+        foreach ($this->data as $index => $input) {
+            switch ($input['inputType']) {
+                case InputType::text->value:
+                    $original = ToolboxHelper::getOriginal($this, 'data');
+                    FileStorageHelper::removeOldModelFilesFromHtml(
+                        $input['text'],
+                        $original[$index]['text'] ?? ''
+                    );
+                    break;
+            } //end switch
+        } //end foreach
+    }
+
+    /**
+     * Apply function on data typed text while on deleted event
+     *
+     * @return void
+     */
+    public function minicrudDeleted()
+    {
+        /** @var array */
+        foreach ($this->data as $input) {
+            switch ($input['inputType']) {
+                case InputType::text->value:
+                    FileStorageHelper::removeModelFilesOfHtml($input['text']);
+                    break;
+            } //end switch
+        } //end foreach
+    }
+
+    /**
+     * Set a specific prop
+     *
+     * @param array $data
+     * @return void
+     */
+    private function setData(array $data): void
+    {
+        $attrs = $this->attributes;
+        if (isset($attrs['data'])) {
+            unset($attrs['data']);
+        }
+        $this->setAttribute('data', $data);
+    }
+
+    /**
+     * Set a specific prop
+     *
+     * @param array $value
+     * @return void
+     */
+    protected function setDataAttribute(array $value): void
+    {
+        $this->attributes['data'] = $this->castAttributeAsJson(
+            'data',
+            $this->serializeData($value)
+        );
+    }
+
+    /**
+     * Set a specific prop
+     *
+     * @param string|null $data
+     * @return array
+     */
+    protected function getDataAttribute(string|null $data): array
+    {
+        return $this->fromJson($data ?? $this->attributes['data'] ?? '[]');
+    }
+
+    /**
+     * Serialize properties
+     *
+     * @param array $data
+     * @return array
+     * @throws \ErrorException If input type is no handled.
+     * @throws \Illuminate\Validation\ValidationException If url is a bo url.
+     * @phpcs:disable Squiz.Commenting.FunctionCommentThrowTag.WrongNumber
+     * @phpcs:disable Generic.Metrics.CyclomaticComplexity.TooHigh
+     */
+    private function serializeData(array $data): array
+    {
+        foreach ($data as $o => $input) {
+            switch ($input['inputType']) {
+                case InputType::image->value:
+                    $data[$o]['value'] = \preg_replace(
+                        '/^\/|^/',
+                        '',
+                        FileStorageHelper::storeFile($this, $input['value'], true)
+                    );
+                    break;
+                case InputType::selectEnum->value:
+                case InputType::boolean->value:
+                case InputType::password->value:
+                case InputType::email->value:
+                case InputType::number->value:
+                case InputType::videoVimeo->value:
+                case InputType::videoYoutube->value:
+                    break;
+                case InputType::string->value:
+                case InputType::text->value:
+                case InputType::url->value:
+                    ToolboxHelper::assertNoInternalBoUrls('content', $input['value']);
+                    break;
+                default:
+                    throw new \ErrorException(sprintf(
+                        'Unknown input Type %s',
+                        $input['inputType']
+                    ));
+            } //end switch
+        } //end foreach
+        return $data;
+    }
+}

artisan

@@ -0,0 +1,53 @@
+#!/usr/bin/env php
+<?php
+
+define('LARAVEL_START', microtime(true));
+
+/*
+|--------------------------------------------------------------------------
+| Register The Auto Loader
+|--------------------------------------------------------------------------
+|
+| Composer provides a convenient, automatically generated class loader
+| for our application. We just need to utilize it! We'll require it
+| into the script here so that we do not have to worry about the
+| loading of any of our classes manually. It's great to relax.
+|
+*/
+
+require __DIR__.'/vendor/autoload.php';
+
+$app = require_once __DIR__.'/bootstrap/app.php';
+
+/*
+|--------------------------------------------------------------------------
+| Run The Artisan Application
+|--------------------------------------------------------------------------
+|
+| When we run the console application, the current CLI command will be
+| executed in this console and the response sent back to a terminal
+| or another output device for the developers. Here goes nothing!
+|
+*/
+
+$kernel = $app->make(Illuminate\Contracts\Console\Kernel::class);
+
+$status = $kernel->handle(
+    $input = new Symfony\Component\Console\Input\ArgvInput,
+    new Symfony\Component\Console\Output\ConsoleOutput
+);
+
+/*
+|--------------------------------------------------------------------------
+| Shutdown The Application
+|--------------------------------------------------------------------------
+|
+| Once Artisan has finished running, we will fire off the shutdown events
+| so that any final work may be done by the application before we shut
+| down the process. This is the last thing to happen to the request.
+|
+*/
+
+$kernel->terminate($input, $status);
+
+exit($status);

bootstrap/app.php

@@ -0,0 +1,55 @@
+<?php
+
+/*
+|--------------------------------------------------------------------------
+| Create The Application
+|--------------------------------------------------------------------------
+|
+| The first thing we will do is create a new Laravel application instance
+| which serves as the "glue" for all the components of Laravel, and is
+| the IoC container for the system binding all of the various parts.
+|
+*/
+
+$app = new Illuminate\Foundation\Application(
+    $_ENV['APP_BASE_PATH'] ?? dirname(__DIR__)
+);
+
+/*
+|--------------------------------------------------------------------------
+| Bind Important Interfaces
+|--------------------------------------------------------------------------
+|
+| Next, we need to bind some important interfaces into the container so
+| we will be able to resolve them when needed. The kernels serve the
+| incoming requests to this application from both the web and CLI.
+|
+*/
+
+$app->singleton(
+    Illuminate\Contracts\Http\Kernel::class,
+    App\Http\Kernel::class
+);
+
+$app->singleton(
+    Illuminate\Contracts\Console\Kernel::class,
+    App\Console\Kernel::class
+);
+
+$app->singleton(
+    Illuminate\Contracts\Debug\ExceptionHandler::class,
+    App\Exceptions\Handler::class
+);
+
+/*
+|--------------------------------------------------------------------------
+| Return The Application
+|--------------------------------------------------------------------------
+|
+| This script returns the application instance. The instance is given to
+| the calling script so we can separate the building of the instances
+| from the actual running of the application and sending responses.
+|
+*/
+
+return $app;

bootstrap/cache/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

composer.json

@@ -0,0 +1,83 @@
+{
+    "name": "laravel/laravel",
+    "type": "project",
+    "description": "The Laravel Framework.",
+    "keywords": [
+        "framework",
+        "laravel"
+    ],
+    "license": "MIT",
+    "require": {
+        "php": "^8.1",
+        "diglactic/laravel-breadcrumbs": "^8.0",
+        "guzzlehttp/guzzle": "^7.2",
+        "laravel/framework": "^10.0",
+        "laravel/tinker": "^2.8",
+        "laravel/ui": "^4.2",
+        "mews/purifier": "^3.4",
+        "sentry/sentry-laravel": "*"
+    },
+    "require-dev": {
+        "fakerphp/faker": "^1.9.1",
+        "kitloong/laravel-migrations-generator": "^6.8",
+        "krlove/eloquent-model-generator": "dev-l10-compatibility",
+        "laravel/pint": "^1.0",
+        "laravel/sail": "^1.18",
+        "mockery/mockery": "^1.4.4",
+        "nunomaduro/collision": "^7.0",
+        "phpunit/phpunit": "^10.0",
+        "slevomat/coding-standard": "^8.10",
+        "spatie/laravel-ignition": "^2.0",
+        "thedoctor0/laravel-factory-generator": "^1.2"
+    },
+    "autoload": {
+        "psr-4": {
+            "App\\": "app/",
+            "Database\\Factories\\": "database/factories/",
+            "Database\\Seeders\\": "database/seeders/"
+        }
+    },
+    "repositories": [
+        {
+            "type": "vcs",
+            "url": "https://github.com/laravel-shift/eloquent-model-generator.git"
+        }
+    ],
+    "autoload-dev": {
+        "psr-4": {
+            "Tests\\": "tests/"
+        }
+    },
+    "scripts": {
+        "post-autoload-dump": [
+            "Illuminate\\Foundation\\ComposerScripts::postAutoloadDump",
+            "@php artisan package:discover --ansi"
+        ],
+        "post-update-cmd": [
+            "@php artisan vendor:publish --tag=laravel-assets --ansi --force"
+        ],
+        "post-root-package-install": [
+            "@php -r \"file_exists('.env') || copy('.env.example', '.env');\""
+        ],
+        "post-create-project-cmd": [
+            "@php artisan key:generate --ansi"
+        ]
+    },
+    "extra": {
+        "laravel": {
+            "dont-discover": []
+        }
+    },
+    "config": {
+        "optimize-autoloader": true,
+        "preferred-install": "dist",
+        "sort-packages": true,
+        "allow-plugins": {
+            "pestphp/pest-plugin": true,
+            "php-http/discovery": true,
+            "dealerdirect/phpcodesniffer-composer-installer": true
+        }
+    },
+    "minimum-stability": "stable",
+    "prefer-stable": true
+}

config/app.php

@@ -0,0 +1,214 @@
+<?php
+
+use Illuminate\Support\Facades\Facade;
+
+return [
+
+    /*
+        |--------------------------------------------------------------------------
+        | Application Name
+        |--------------------------------------------------------------------------
+        |
+        | This value is the name of your application. This value is used when the
+        | framework needs to place the application's name in a notification or
+        | any other location as required by the application or its packages.
+        |
+    */
+
+    'name' => env('APP_NAME', 'Laravel'),
+
+    /*
+        |--------------------------------------------------------------------------
+        | Application Environment
+        |--------------------------------------------------------------------------
+        |
+        | This value determines the "environment" your application is currently
+        | running in. This may determine how you prefer to configure various
+        | services the application utilizes. Set this in your ".env" file.
+        |
+    */
+
+    'env' => env('APP_ENV', 'production'),
+
+    /*
+        |--------------------------------------------------------------------------
+        | Application Debug Mode
+        |--------------------------------------------------------------------------
+        |
+        | When your application is in debug mode, detailed error messages with
+        | stack traces will be shown on every error that occurs within your
+        | application. If disabled, a simple generic error page is shown.
+        |
+    */
+
+    'debug' => (bool)env('APP_DEBUG', false),
+
+    /*
+        |--------------------------------------------------------------------------
+        | Application URL
+        |--------------------------------------------------------------------------
+        |
+        | This URL is used by the console to properly generate URLs when using
+        | the Artisan command line tool. You should set this to the root of
+        | your application so that it is used when running Artisan tasks.
+        |
+    */
+
+    'url' => env('APP_URL', 'http://localhost'),
+
+    'asset_url' => env('ASSET_URL'),
+
+    /*
+        |--------------------------------------------------------------------------
+        | Application Timezone
+        |--------------------------------------------------------------------------
+        |
+        | Here you may specify the default timezone for your application, which
+        | will be used by the PHP date and date-time functions. We have gone
+        | ahead and set this to a sensible default for you out of the box.
+        |
+    */
+
+    'timezone' => 'Europe/Paris',
+
+    /*
+        |--------------------------------------------------------------------------
+        | Application Locale Configuration
+        |--------------------------------------------------------------------------
+        |
+        | The application locale determines the default locale that will be used
+        | by the translation service provider. You are free to set this value
+        | to any of the locales which will be supported by the application.
+        |
+    */
+
+    'locale' => 'fr',
+
+    /*
+        |--------------------------------------------------------------------------
+        | Application Fallback Locale
+        |--------------------------------------------------------------------------
+        |
+        | The fallback locale determines the locale to use when the current one
+        | is not available. You may change the value to correspond to any of
+        | the language folders that are provided through your application.
+        |
+    */
+
+    'fallback_locale' => 'en',
+
+    /*
+        |--------------------------------------------------------------------------
+        | Faker Locale
+        |--------------------------------------------------------------------------
+        |
+        | This locale will be used by the Faker PHP library when generating fake
+        | data for your database seeds. For example, this will be used to get
+        | localized telephone numbers, street address information and more.
+        |
+    */
+
+    'faker_locale' => 'en_US',
+
+    /*
+        |--------------------------------------------------------------------------
+        | Encryption Key
+        |--------------------------------------------------------------------------
+        |
+        | This key is used by the Illuminate encrypter service and should be set
+        | to a random, 32 character string, otherwise these encrypted strings
+        | will not be safe. Please do this before deploying an application!
+        |
+    */
+
+    'key' => env('APP_KEY'),
+
+    'cipher' => 'AES-256-CBC',
+
+    /*
+        |--------------------------------------------------------------------------
+        | Maintenance Mode Driver
+        |--------------------------------------------------------------------------
+        |
+        | These configuration options determine the driver used to determine and
+        | manage Laravel's "maintenance mode" status. The "cache" driver will
+        | allow maintenance mode to be controlled across multiple machines.
+        |
+        | Supported drivers: "file", "cache"
+        |
+    */
+
+    'maintenance' => [
+        'driver' => 'file'
+    ],
+
+    /*
+        |--------------------------------------------------------------------------
+        | Autoloaded Service Providers
+        |--------------------------------------------------------------------------
+        |
+        | The service providers listed here will be automatically loaded on the
+        | request to your application. Feel free to add your own services to
+        | this array to grant expanded functionality to your applications.
+        |
+    */
+
+    'providers' => [
+
+        /*
+         * Laravel Framework Service Providers...
+         */
+
+        Illuminate\Auth\AuthServiceProvider::class,
+        Illuminate\Broadcasting\BroadcastServiceProvider::class,
+        Illuminate\Bus\BusServiceProvider::class,
+        Illuminate\Cache\CacheServiceProvider::class,
+        Illuminate\Foundation\Providers\ConsoleSupportServiceProvider::class,
+        Illuminate\Cookie\CookieServiceProvider::class,
+        Illuminate\Database\DatabaseServiceProvider::class,
+        Illuminate\Encryption\EncryptionServiceProvider::class,
+        Illuminate\Filesystem\FilesystemServiceProvider::class,
+        Illuminate\Foundation\Providers\FoundationServiceProvider::class,
+        Illuminate\Hashing\HashServiceProvider::class,
+        Illuminate\Mail\MailServiceProvider::class,
+        Illuminate\Notifications\NotificationServiceProvider::class,
+        Illuminate\Pagination\PaginationServiceProvider::class,
+        Illuminate\Pipeline\PipelineServiceProvider::class,
+        Illuminate\Queue\QueueServiceProvider::class,
+        Illuminate\Redis\RedisServiceProvider::class,
+        Illuminate\Auth\Passwords\PasswordResetServiceProvider::class,
+        Illuminate\Session\SessionServiceProvider::class,
+        Illuminate\Translation\TranslationServiceProvider::class,
+        Illuminate\Validation\ValidationServiceProvider::class,
+        Illuminate\View\ViewServiceProvider::class,
+
+        /*
+         * Package Service Providers...
+         */
+
+        /*
+         * Application Service Providers...
+         */
+
+        App\Providers\AppServiceProvider::class,
+        App\Providers\AuthServiceProvider::class,
+        App\Providers\EventServiceProvider::class,
+        App\Providers\RouteServiceProvider::class,
+        App\Providers\TranslationServiceProvider::class
+
+    ],
+
+    /*
+        |--------------------------------------------------------------------------
+        | Class Aliases
+        |--------------------------------------------------------------------------
+        |
+        | This array of class aliases will be registered when this application
+        | is started. However, feel free to register as many as you wish as
+        | the aliases are "lazy" loaded so they don't hinder performance.
+        |
+    */
+
+    'aliases' => Facade::defaultAliases()->merge([])->toArray(),
+
+];

config/auth.php

@@ -0,0 +1,116 @@
+<?php
+
+return [
+
+    /*
+        |--------------------------------------------------------------------------
+        | Authentication Defaults
+        |--------------------------------------------------------------------------
+        |
+        | This option controls the default authentication "guard" and password
+        | reset options for your application. You may change these defaults
+        | as required, but they're a perfect start for most applications.
+        |
+    */
+
+    'defaults' => [
+        'guard' => 'frontend',
+        'passwords' => 'users',
+    ],
+
+    /*
+        |--------------------------------------------------------------------------
+        | Authentication Guards
+        |--------------------------------------------------------------------------
+        |
+        | Next, you may define every authentication guard for your application.
+        | Of course, a great default configuration has been defined for you
+        | here which uses session storage and the Eloquent user provider.
+        |
+        | All authentication drivers have a user provider. This defines how the
+        | users are actually retrieved out of your database or other storage
+        | mechanisms used by this application to persist your user's data.
+        |
+        | Supported: "session"
+        |
+    */
+
+    'guards' => [
+        'backend' => [
+            'driver' => 'session',
+            'provider' => 'users',
+        ],
+
+        'frontend' => [
+            'driver' => 'session',
+            // ! Remplacer "users" par le model authenticable voulu
+            'provider' => 'users',
+        ],
+    ],
+
+    /*
+        |--------------------------------------------------------------------------
+        | User Providers
+        |--------------------------------------------------------------------------
+        |
+        | All authentication drivers have a user provider. This defines how the
+        | users are actually retrieved out of your database or other storage
+        | mechanisms used by this application to persist your user's data.
+        |
+        | If you have multiple user tables or models you may configure multiple
+        | sources which represent each model / table. These sources may then
+        | be assigned to any extra authentication guards you have defined.
+        |
+        | Supported: "database", "eloquent"
+        |
+    */
+
+    'providers' => [
+        'users' => [
+            'driver' => 'eloquent',
+            'model' => App\Models\User::class,
+        ],
+    ],
+
+    /*
+        |--------------------------------------------------------------------------
+        | Resetting Passwords
+        |--------------------------------------------------------------------------
+        |
+        | You may specify multiple password reset configurations if you have more
+        | than one user table or model in the application and you want to have
+        | separate password reset settings based on the specific user types.
+        |
+        | The expiry time is the number of minutes that each reset token will be
+        | considered valid. This security feature keeps tokens short-lived so
+        | they have less time to be guessed. You may change this as needed.
+        |
+        | The throttle setting is the number of seconds a user must wait before
+        | generating more password reset tokens. This prevents the user from
+        | quickly generating a very large amount of password reset tokens.
+        |
+    */
+
+    'passwords' => [
+        'users' => [
+            'provider' => 'users',
+            'table' => 'password_reset_tokens',
+            'expire' => 60,
+            'throttle' => 60,
+        ],
+    ],
+
+    /*
+        |--------------------------------------------------------------------------
+        | Password Confirmation Timeout
+        |--------------------------------------------------------------------------
+        |
+        | Here you may define the amount of seconds before a password confirmation
+        | times out and the user is prompted to re-enter their password via the
+        | confirmation screen. By default, the timeout lasts for three hours.
+        |
+    */
+
+    'password_timeout' => 10800,
+
+];

config/breadcrumbs.php

@@ -0,0 +1,78 @@
+<?php
+
+return [
+
+    /*
+        |--------------------------------------------------------------------------
+        | View Name
+        |--------------------------------------------------------------------------
+        |
+        | Choose a view to display when Breadcrumbs::render() is called.
+        | Built in templates are:
+        |
+        | - 'breadcrumbs::bootstrap5'  - Bootstrap 5
+        | - 'breadcrumbs::bootstrap4'  - Bootstrap 4
+        | - 'breadcrumbs::bulma'       - Bulma
+        | - 'breadcrumbs::foundation6' - Foundation 6
+        | - 'breadcrumbs::json-ld'     - JSON-LD Structured Data
+        | - 'breadcrumbs::materialize' - Materialize
+        | - 'breadcrumbs::tailwind'    - Tailwind CSS
+        | - 'breadcrumbs::uikit'       - UIkit
+        |
+        | Or a custom view, e.g. '_partials/breadcrumbs'.
+        |
+    */
+
+    'view' => 'breadcrumbs/breadrcumb-layout',
+
+    /*
+        |--------------------------------------------------------------------------
+        | Breadcrumbs File(s)
+        |--------------------------------------------------------------------------
+        |
+        | The file(s) where breadcrumbs are defined. e.g.
+        |
+        | - base_path('routes/breadcrumbs.php')
+        | - glob(base_path('breadcrumbs/*.php'))
+        |
+    */
+
+    'files' => [
+        base_path('routes/breadcrumbs-bo.php'),
+        base_path('routes/breadcrumbs-fo.php'),
+    ],
+
+    /*
+        |--------------------------------------------------------------------------
+        | Exceptions
+        |--------------------------------------------------------------------------
+        |
+        | Determine when to throw an exception.
+        |
+    */
+
+    // * When route-bound breadcrumbs are used but the current route doesn't have a name (UnnamedRouteException)
+    'unnamed-route-exception' => true,
+
+    // * When route-bound breadcrumbs are used and the matching breadcrumb doesn't exist (InvalidBreadcrumbException)
+    'missing-route-bound-breadcrumb-exception' => true,
+
+    // * When a named breadcrumb is used but doesn't exist (InvalidBreadcrumbException)
+    'invalid-named-breadcrumb-exception' => true,
+
+    /*
+        |--------------------------------------------------------------------------
+        | Classes
+        |--------------------------------------------------------------------------
+        |
+        | Subclass the default classes for more advanced customisations.
+        |
+    */
+
+    // * Manager
+    'manager-class' => Diglactic\Breadcrumbs\Manager::class,
+
+    // * Generator
+    'generator-class' => Diglactic\Breadcrumbs\Generator::class,
+
+];

config/broadcasting.php

@@ -0,0 +1,70 @@
+<?php
+
+return [
+
+    /*
+        |--------------------------------------------------------------------------
+        | Default Broadcaster
+        |--------------------------------------------------------------------------
+        |
+        | This option controls the default broadcaster that will be used by the
+        | framework when an event needs to be broadcast. You may set this to
+        | any of the connections defined in the "connections" array below.
+        |
+        | Supported: "pusher", "ably", "redis", "log", "null"
+        |
+    */
+
+    'default' => env('BROADCAST_DRIVER', 'null'),
+
+    /*
+        |--------------------------------------------------------------------------
+        | Broadcast Connections
+        |--------------------------------------------------------------------------
+        |
+        | Here you may define all of the broadcast connections that will be used
+        | to broadcast events to other systems or over websockets. Samples of
+        | each available type of connection are provided inside this array.
+        |
+    */
+
+    'connections' => [
+
+        'pusher' => [
+            'driver' => 'pusher',
+            'key' => env('PUSHER_APP_KEY'),
+            'secret' => env('PUSHER_APP_SECRET'),
+            'app_id' => env('PUSHER_APP_ID'),
+            'options' => [
+                'host' => env('PUSHER_HOST') ?: 'api-' . env('PUSHER_APP_CLUSTER', 'mt1') . '.pusher.com',
+                'port' => env('PUSHER_PORT', 443),
+                'scheme' => env('PUSHER_SCHEME', 'https'),
+                'encrypted' => true,
+                'useTLS' => env('PUSHER_SCHEME', 'https') === 'https',
+            ],
+            'client_options' => [
+                // Guzzle client options: https://docs.guzzlephp.org/en/stable/request-options.html .
+            ],
+        ],
+
+        'ably' => [
+            'driver' => 'ably',
+            'key' => env('ABLY_KEY'),
+        ],
+
+        'redis' => [
+            'driver' => 'redis',
+            'connection' => 'default',
+        ],
+
+        'log' => [
+            'driver' => 'log',
+        ],
+
+        'null' => [
+            'driver' => 'null',
+        ],
+
+    ],
+
+];

config/cache.php

@@ -0,0 +1,110 @@
+<?php
+
+use Illuminate\Support\Str;
+
+return [
+
+    /*
+        |--------------------------------------------------------------------------
+        | Default Cache Store
+        |--------------------------------------------------------------------------
+        |
+        | This option controls the default cache connection that gets used while
+        | using this caching library. This connection is used when another is
+        | not explicitly specified when executing a given caching function.
+        |
+    */
+
+    'default' => env('CACHE_DRIVER', 'file'),
+
+    /*
+        |--------------------------------------------------------------------------
+        | Cache Stores
+        |--------------------------------------------------------------------------
+        |
+        | Here you may define all of the cache "stores" for your application as
+        | well as their drivers. You may even define multiple stores for the
+        | same cache driver to group types of items stored in your caches.
+        |
+        | Supported drivers: "apc", "array", "database", "file",
+        |         "memcached", "redis", "dynamodb", "octane", "null"
+        |
+    */
+
+    'stores' => [
+
+        'apc' => [
+            'driver' => 'apc',
+        ],
+
+        'array' => [
+            'driver' => 'array',
+            'serialize' => false,
+        ],
+
+        'database' => [
+            'driver' => 'database',
+            'table' => 'cache',
+            'connection' => null,
+            'lock_connection' => null,
+        ],
+
+        'file' => [
+            'driver' => 'file',
+            'path' => storage_path('framework/cache/data'),
+        ],
+
+        'memcached' => [
+            'driver' => 'memcached',
+            'persistent_id' => env('MEMCACHED_PERSISTENT_ID'),
+            'sasl' => [
+                env('MEMCACHED_USERNAME'),
+                env('MEMCACHED_PASSWORD'),
+            ],
+            'options' => [
+                // Memcached::OPT_CONNECT_TIMEOUT => 2000, .
+            ],
+            'servers' => [
+                [
+                    'host' => env('MEMCACHED_HOST', '127.0.0.1'),
+                    'port' => env('MEMCACHED_PORT', 11211),
+                    'weight' => 100,
+                ],
+            ],
+        ],
+
+        'redis' => [
+            'driver' => 'redis',
+            'connection' => 'cache',
+            'lock_connection' => 'default',
+        ],
+
+        'dynamodb' => [
+            'driver' => 'dynamodb',
+            'key' => env('AWS_ACCESS_KEY_ID'),
+            'secret' => env('AWS_SECRET_ACCESS_KEY'),
+            'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
+            'table' => env('DYNAMODB_CACHE_TABLE', 'cache'),
+            'endpoint' => env('DYNAMODB_ENDPOINT'),
+        ],
+
+        'octane' => [
+            'driver' => 'octane',
+        ],
+
+    ],
+
+    /*
+        |--------------------------------------------------------------------------
+        | Cache Key Prefix
+        |--------------------------------------------------------------------------
+        |
+        | When utilizing the APC, database, memcached, Redis, or DynamoDB cache
+        | stores there might be other applications using the same cache. For
+        | that reason, you may prefix every cache key to avoid collisions.
+        |
+    */
+
+    'prefix' => env('CACHE_PREFIX', Str::slug(env('APP_NAME', 'laravel'), '_') . '_cache_'),
+
+];

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' => ['api/*', 'sanctum/csrf-cookie'],
+
+    'allowed_methods' => ['*'],
+
+    'allowed_origins' => ['*'],
+
+    'allowed_origins_patterns' => [],
+
+    'allowed_headers' => ['*'],
+
+    'exposed_headers' => [],
+
+    'max_age' => 0,
+
+    'supports_credentials' => false,
+
+];

config/database.php

@@ -0,0 +1,149 @@
+<?php
+
+use Illuminate\Support\Str;
+
+return [
+
+    /*
+        |--------------------------------------------------------------------------
+        | Default Database Connection Name
+        |--------------------------------------------------------------------------
+        |
+        | Here you may specify which of the database connections below you wish
+        | to use as your default connection for all database work. Of course
+        | you may use many connections at once using the Database library.
+        |
+    */
+
+    'default' => env('DB_CONNECTION', 'mysql'),
+
+    /*
+        |--------------------------------------------------------------------------
+        | Database Connections
+        |--------------------------------------------------------------------------
+        |
+        | Here are each of the database connections setup for your application.
+        | Of course, examples of configuring each database platform that is
+        | supported by Laravel is shown below to make development simple.
+        |
+        |
+        | All database work in Laravel is done through the PHP PDO facilities
+        | so make sure you have the driver for your particular database of
+        | choice installed on your machine before you begin development.
+        |
+    */
+
+    'connections' => [
+
+        'sqlite' => [
+            'driver' => 'sqlite',
+            'url' => env('DATABASE_URL'),
+            'database' => env('DB_DATABASE', database_path('database.sqlite')),
+            'prefix' => '',
+            'foreign_key_constraints' => env('DB_FOREIGN_KEYS', true),
+        ],
+
+        'mysql' => [
+            'driver' => 'mysql',
+            'url' => env('DATABASE_URL'),
+            'host' => env('DB_HOST', '127.0.0.1'),
+            'port' => env('DB_PORT', '3306'),
+            'database' => env('DB_DATABASE', 'forge'),
+            'username' => env('DB_USERNAME', 'forge'),
+            'password' => env('DB_PASSWORD', ''),
+            'unix_socket' => env('DB_SOCKET', ''),
+            'charset' => 'utf8mb4',
+            'collation' => 'utf8mb4_unicode_ci',
+            'prefix' => '',
+            'prefix_indexes' => true,
+            'strict' => true,
+            'engine' => null,
+            'options' => extension_loaded('pdo_mysql') ? array_filter([
+                PDO::MYSQL_ATTR_SSL_CA => env('MYSQL_ATTR_SSL_CA'),
+            ]) : [],
+        ],
+
+        'pgsql' => [
+            'driver' => 'pgsql',
+            'url' => env('DATABASE_URL'),
+            'host' => env('DB_HOST', '127.0.0.1'),
+            'port' => env('DB_PORT', '5432'),
+            'database' => env('DB_DATABASE', 'forge'),
+            'username' => env('DB_USERNAME', 'forge'),
+            'password' => env('DB_PASSWORD', ''),
+            'charset' => 'utf8',
+            'prefix' => '',
+            'prefix_indexes' => true,
+            'search_path' => 'public',
+            'sslmode' => 'prefer',
+        ],
+
+        'sqlsrv' => [
+            'driver' => 'sqlsrv',
+            'url' => env('DATABASE_URL'),
+            'host' => env('DB_HOST', 'localhost'),
+            'port' => env('DB_PORT', '1433'),
+            'database' => env('DB_DATABASE', 'forge'),
+            'username' => env('DB_USERNAME', 'forge'),
+            'password' => env('DB_PASSWORD', ''),
+            'charset' => 'utf8',
+            'prefix' => '',
+            'prefix_indexes' => true,
+        ],
+
+    ],
+
+    /*
+        |--------------------------------------------------------------------------
+        | Migration Repository Table
+        |--------------------------------------------------------------------------
+        |
+        | This table keeps track of all the migrations that have already run for
+        | your application. Using this information, we can determine which of
+        | the migrations on disk haven't actually been run in the database.
+        |
+    */
+
+    'migrations' => 'migrations',
+
+    /*
+        |--------------------------------------------------------------------------
+        | Redis Databases
+        |--------------------------------------------------------------------------
+        |
+        | Redis is an open source, fast, and advanced key-value store that also
+        | provides a richer body of commands than a typical key-value system
+        | such as APC or Memcached. Laravel makes it easy to dig right in.
+        |
+    */
+
+    'redis' => [
+
+        'client' => env('REDIS_CLIENT', 'phpredis'),
+
+        'options' => [
+            'cluster' => env('REDIS_CLUSTER', 'redis'),
+            'prefix' => env('REDIS_PREFIX', Str::slug(env('APP_NAME', 'laravel'), '_') . '_database_'),
+        ],
+
+        'default' => [
+            'url' => env('REDIS_URL'),
+            'host' => env('REDIS_HOST', '127.0.0.1'),
+            'username' => env('REDIS_USERNAME'),
+            'password' => env('REDIS_PASSWORD'),
+            'port' => env('REDIS_PORT', '6379'),
+            'database' => env('REDIS_DB', '0'),
+        ],
+
+        'cache' => [
+            'url' => env('REDIS_URL'),
+            'host' => env('REDIS_HOST', '127.0.0.1'),
+            'username' => env('REDIS_USERNAME'),
+            'password' => env('REDIS_PASSWORD'),
+            'port' => env('REDIS_PORT', '6379'),
+            'database' => env('REDIS_CACHE_DB', '1'),
+        ],
+
+    ],
+
+];

config/filesystems.php

@@ -0,0 +1,83 @@
+<?php
+
+return [
+
+    /*
+        |--------------------------------------------------------------------------
+        | Default Filesystem Disk
+        |--------------------------------------------------------------------------
+        |
+        | Here you may specify the default filesystem disk that should be used
+        | by the framework. The "local" disk, as well as a variety of cloud
+        | based disks are available to your application. Just store away!
+        |
+    */
+
+    'default' => env('FILESYSTEM_DISK', 'local'),
+
+    /*
+        |--------------------------------------------------------------------------
+        | Filesystem Disks
+        |--------------------------------------------------------------------------
+        |
+        | Here you may configure as many filesystem "disks" as you wish, and you
+        | may even configure multiple disks of the same driver. Defaults have
+        | been set up for each driver as an example of the required values.
+        |
+        | Supported Drivers: "local", "ftp", "sftp", "s3"
+        |
+    */
+
+    'disks' => [
+
+        'local' => [
+            'driver' => 'local',
+            'root' => storage_path('app'),
+            'throw' => false,
+        ],
+
+        'public' => [
+            'driver' => 'local',
+            'root' => storage_path('app/public'),
+            'url' => env('APP_URL') . '/storage',
+            'visibility' => 'public',
+            'throw' => false,
+        ],
+
+        'private' => [
+            'driver' => 'local',
+            'root' => storage_path('app/private'),
+            'visibility' => 'private',
+            'throw' => false,
+        ],
+
+        's3' => [
+            'driver' => 's3',
+            'key' => env('AWS_ACCESS_KEY_ID'),
+            'secret' => env('AWS_SECRET_ACCESS_KEY'),
+            'region' => env('AWS_DEFAULT_REGION'),
+            'bucket' => env('AWS_BUCKET'),
+            'url' => env('AWS_URL'),
+            'endpoint' => env('AWS_ENDPOINT'),
+            'use_path_style_endpoint' => env('AWS_USE_PATH_STYLE_ENDPOINT', false),
+            'throw' => false,
+        ],
+
+    ],
+
+    /*
+        |--------------------------------------------------------------------------
+        | Symbolic Links
+        |--------------------------------------------------------------------------
+        |
+        | Here you may configure the symbolic links that will be created when the
+        | `storage:link` Artisan command is executed. The array keys should be
+        | the locations of the links and the values should be their targets.
+        |
+    */
+
+    'links' => [
+        public_path('storage') => storage_path('app/public'),
+    ],
+
+];

config/hashing.php

@@ -0,0 +1,52 @@
+<?php
+
+return [
+
+    /*
+        |--------------------------------------------------------------------------
+        | Default Hash Driver
+        |--------------------------------------------------------------------------
+        |
+        | This option controls the default hash driver that will be used to hash
+        | passwords for your application. By default, the bcrypt algorithm is
+        | used; however, you remain free to modify this option if you wish.
+        |
+        | Supported: "bcrypt", "argon", "argon2id"
+        |
+    */
+
+    'driver' => 'bcrypt',
+
+    /*
+        |--------------------------------------------------------------------------
+        | Bcrypt Options
+        |--------------------------------------------------------------------------
+        |
+        | Here you may specify the configuration options that should be used when
+        | passwords are hashed using the Bcrypt algorithm. This will allow you
+        | to control the amount of time it takes to hash the given password.
+        |
+    */
+
+    'bcrypt' => [
+        'rounds' => env('BCRYPT_ROUNDS', 10),
+    ],
+
+    /*
+        |--------------------------------------------------------------------------
+        | Argon Options
+        |--------------------------------------------------------------------------
+        |
+        | Here you may specify the configuration options that should be used when
+        | passwords are hashed using the Argon algorithm. These will allow you
+        | to control the amount of time it takes to hash the given password.
+        |
+    */
+
+    'argon' => [
+        'memory' => 65536,
+        'threads' => 1,
+        'time' => 4,
+    ],
+
+];

config/logging.php

@@ -0,0 +1,131 @@
+<?php
+
+use Monolog\Handler\NullHandler;
+use Monolog\Handler\StreamHandler;
+use Monolog\Handler\SyslogUdpHandler;
+use Monolog\Processor\PsrLogMessageProcessor;
+
+return [
+
+    /*
+        |--------------------------------------------------------------------------
+        | Default Log Channel
+        |--------------------------------------------------------------------------
+        |
+        | This option defines the default log channel that gets used when writing
+        | messages to the logs. The name specified in this option should match
+        | one of the channels defined in the "channels" configuration array.
+        |
+    */
+
+    'default' => env('LOG_CHANNEL', 'stack'),
+
+    /*
+        |--------------------------------------------------------------------------
+        | Deprecations Log Channel
+        |--------------------------------------------------------------------------
+        |
+        | This option controls the log channel that should be used to log warnings
+        | regarding deprecated PHP and library features. This allows you to get
+        | your application ready for upcoming major versions of dependencies.
+        |
+    */
+
+    'deprecations' => [
+        'channel' => env('LOG_DEPRECATIONS_CHANNEL', 'null'),
+        'trace' => false,
+    ],
+
+    /*
+        |--------------------------------------------------------------------------
+        | Log Channels
+        |--------------------------------------------------------------------------
+        |
+        | Here you may configure the log channels for your application. Out of
+        | the box, Laravel uses the Monolog PHP logging library. This gives
+        | you a variety of powerful log handlers / formatters to utilize.
+        |
+        | Available Drivers: "single", "daily", "slack", "syslog",
+        |                    "errorlog", "monolog",
+        |                    "custom", "stack"
+        |
+    */
+
+    'channels' => [
+        'stack' => [
+            'driver' => 'stack',
+            'channels' => ['single'],
+            'ignore_exceptions' => false,
+        ],
+
+        'single' => [
+            'driver' => 'single',
+            'path' => storage_path('logs/laravel.log'),
+            'level' => env('LOG_LEVEL', 'debug'),
+            'replace_placeholders' => true,
+        ],
+
+        'daily' => [
+            'driver' => 'daily',
+            'path' => storage_path('logs/laravel.log'),
+            'level' => env('LOG_LEVEL', 'debug'),
+            'days' => 14,
+            'replace_placeholders' => true,
+        ],
+
+        'slack' => [
+            'driver' => 'slack',
+            'url' => env('LOG_SLACK_WEBHOOK_URL'),
+            'username' => 'Laravel Log',
+            'emoji' => ':boom:',
+            'level' => env('LOG_LEVEL', 'critical'),
+            'replace_placeholders' => true,
+        ],
+
+        'papertrail' => [
+            'driver' => 'monolog',
+            'level' => env('LOG_LEVEL', 'debug'),
+            'handler' => env('LOG_PAPERTRAIL_HANDLER', SyslogUdpHandler::class),
+            'handler_with' => [
+                'host' => env('PAPERTRAIL_URL'),
+                'port' => env('PAPERTRAIL_PORT'),
+                'connectionString' => 'tls://' . env('PAPERTRAIL_URL') . ':' . env('PAPERTRAIL_PORT'),
+            ],
+            'processors' => [PsrLogMessageProcessor::class],
+        ],
+
+        'stderr' => [
+            'driver' => 'monolog',
+            'level' => env('LOG_LEVEL', 'debug'),
+            'handler' => StreamHandler::class,
+            'formatter' => env('LOG_STDERR_FORMATTER'),
+            'with' => [
+                'stream' => 'php://stderr',
+            ],
+            'processors' => [PsrLogMessageProcessor::class],
+        ],
+
+        'syslog' => [
+            'driver' => 'syslog',
+            'level' => env('LOG_LEVEL', 'debug'),
+            'facility' => LOG_USER,
+            'replace_placeholders' => true,
+        ],
+
+        'errorlog' => [
+            'driver' => 'errorlog',
+            'level' => env('LOG_LEVEL', 'debug'),
+            'replace_placeholders' => true,
+        ],
+
+        'null' => [
+            'driver' => 'monolog',
+            'handler' => NullHandler::class,
+        ],
+
+        'emergency' => [
+            'path' => storage_path('logs/laravel.log'),
+        ],
+    ],
+
+];

config/mail.php

@@ -0,0 +1,118 @@
+<?php
+
+return [
+
+    /*
+        |--------------------------------------------------------------------------
+        | Default Mailer
+        |--------------------------------------------------------------------------
+        |
+        | This option controls the default mailer that is used to send any email
+        | messages sent by your application. Alternative mailers may be setup
+        | and used as needed; however, this mailer will be used by default.
+        |
+    */
+
+    'default' => env('MAIL_MAILER', 'smtp'),
+
+    /*
+        |--------------------------------------------------------------------------
+        | Mailer Configurations
+        |--------------------------------------------------------------------------
+        |
+        | Here you may configure all of the mailers used by your application plus
+        | their respective settings. Several examples have been configured for
+        | you and you are free to add your own as your application requires.
+        |
+        | Laravel supports a variety of mail "transport" drivers to be used while
+        | sending an e-mail. You will specify which one you are using for your
+        | mailers below. You are free to add additional mailers as required.
+        |
+        | Supported: "smtp", "sendmail", "mailgun", "ses", "ses-v2",
+        |            "postmark", "log", "array", "failover"
+        |
+    */
+
+    'mailers' => [
+        'smtp' => [
+            'transport' => 'smtp',
+            'host' => env('MAIL_HOST', 'smtp.mailgun.org'),
+            'port' => env('MAIL_PORT', 587),
+            'encryption' => env('MAIL_ENCRYPTION', 'tls'),
+            'username' => env('MAIL_USERNAME'),
+            'password' => env('MAIL_PASSWORD'),
+            'timeout' => null,
+            'local_domain' => env('MAIL_EHLO_DOMAIN'),
+        ],
+
+        'ses' => [
+            'transport' => 'ses',
+        ],
+
+        'mailgun' => [
+            'transport' => 'mailgun'
+        ],
+
+        'postmark' => [
+            'transport' => 'postmark'
+        ],
+
+        'sendmail' => [
+            'transport' => 'sendmail',
+            'path' => env('MAIL_SENDMAIL_PATH', '/usr/sbin/sendmail -bs -i'),
+        ],
+
+        'log' => [
+            'transport' => 'log',
+            'channel' => env('MAIL_LOG_CHANNEL'),
+        ],
+
+        'array' => [
+            'transport' => 'array',
+        ],
+
+        'failover' => [
+            'transport' => 'failover',
+            'mailers' => [
+                'smtp',
+                'log',
+            ],
+        ],
+    ],
+
+    /*
+        |--------------------------------------------------------------------------
+        | Global "From" Address
+        |--------------------------------------------------------------------------
+        |
+        | You may wish for all e-mails sent by your application to be sent from
+        | the same address. Here, you may specify a name and address that is
+        | used globally for all e-mails that are sent by your application.
+        |
+    */
+
+    'from' => [
+        'address' => env('MAIL_FROM_ADDRESS', 'hello@example.com'),
+        'name' => env('MAIL_FROM_NAME', 'Example'),
+    ],
+
+    /*
+        |--------------------------------------------------------------------------
+        | Markdown Mail Settings
+        |--------------------------------------------------------------------------
+        |
+        | If you are using Markdown based email rendering, you may configure your
+        | theme and component paths here, allowing you to customize the design
+        | of the emails. Or, you may simply stick with the Laravel defaults!
+        |
+    */
+
+    'markdown' => [
+        'theme' => 'default',
+
+        'paths' => [
+            resource_path('views/vendor/mail'),
+        ],
+    ],
+
+];

config/purifier.php

@@ -0,0 +1,121 @@
+<?php
+
+/**
+ * Ok, glad you are here
+ * first we get a config instance, and set the settings
+ * $config = HTMLPurifier_Config::createDefault();
+ * $config->set('Core.Encoding', $this->config->get('purifier.encoding'));
+ * $config->set('Cache.SerializerPath', $this->config->get('purifier.cachePath'));
+ * if ( ! $this->config->get('purifier.finalize')) {
+ *     $config->autoFinalize = false;
+ * }
+ * $config->load [$this->getConfig());
+ *
+ * You must NOT delete the default settings
+ * anything in settings should be compacted with params that needed to instance HTMLPurifier_Config.
+ *
+ * @link http://htmlpurifier.org/live/configdoc/plain.html
+ */
+
+// phpcs:disable Generic.Files.LineLength.TooLong
+return [
+    'encoding'      => 'UTF-8',
+    'finalize'      => true,
+    'cachePath'     => storage_path('app/purifier'),
+    'cacheFileMode' => 0755,
+    'settings'      => [
+        'default' => [
+            'HTML.SafeIframe'          => true,
+            // * For iframes
+            'URI.SafeIframeRegexp'     => "%^(http://|https://|//)(www.youtube.com/embed/|player.vimeo.com/video/|vimeo.com/)%",
+            'HTML.Doctype'             => 'HTML 4.01 Transitional',
+            // * Legacy filter en full avec safe legacy.
+            // 'HTML.Allowed'             => 'h1[style],h2[style],h3[style],h4[style],h5[style],h6[style],figure[class|style],oembed[url],div[style],b,strong,i,em,u,a[href|title|target|rel],ul[style],ol[style],dl[style],li,p[style],br,span[style|class],img[width|height|alt|src|style|class|title],iframe[src|width|height|class|frameborder|style],table[style|align|border|cellspacing|cellpadding|width],thead,tbody,th[colspan|align|valign|style],tr[align|valign|style],td[style|colspan|rowspan|scope|align|valign],hr,dl,dt',
+            // * Restricted basics.
+            'HTML.Allowed'             => 'br,p[style],b[style],u[style],i[style],a[href|title|target|rel],strong[style],span[class],ul[style],ol[style],li[style],h2[style],h3[style],h4[style],hr,blockquote[style]',
+            // * Legacy filter en full avec safe legacy.
+            // 'CSS.AllowedProperties'    => 'font,font-size,font-weight,font-style,font-family,text-decoration,padding-left,color,background-color,text-align,list-style-type,float,width,height,vertical-align,border-color,margin-left',
+            // * Restricted basics.
+            'CSS.AllowedProperties'    => 'text-align,margin-left',
+            'AutoFormat.AutoParagraph' => false,
+            'AutoFormat.RemoveEmpty'   => false,
+            'AutoFormat.RemoveEmpty.RemoveNbsp' => false,
+        ],
+        'custom_definition' => [
+            'id'  => 'html5-definitions',
+            'rev' => 1,
+            'debug' => true,
+            'elements' => [
+                // * http://developers.whatwg.org/sections.html
+                ['section', 'Block', 'Flow', 'Common'],
+                ['nav',     'Block', 'Flow', 'Common'],
+                ['article', 'Block', 'Flow', 'Common'],
+                ['aside',   'Block', 'Flow', 'Common'],
+                ['header',  'Block', 'Flow', 'Common'],
+                ['footer',  'Block', 'Flow', 'Common'],
+
+                // * Content model actually excludes several tags, not modelled here
+                ['address', 'Block', 'Flow', 'Common'],
+                ['hgroup', 'Block', 'Required: h1 | h2 | h3 | h4 | h5 | h6', 'Common'],
+
+                // * http://developers.whatwg.org/grouping-content.html
+                ['figure', 'Block', 'Optional: (figcaption, Flow) | (Flow, figcaption) | Flow', 'Common'],
+                ['figcaption', 'Inline', 'Flow', 'Common'],
+                ['oembed', 'Inline', 'Flow', 'Common'],
+
+                // * http://developers.whatwg.org/the-video-element.html#the-video-element
+                ['video', 'Block', 'Optional: (source, Flow) | (Flow, source) | Flow', 'Common', [
+                    'src' => 'URI',
+                    'type' => 'Text',
+                    'width' => 'Length',
+                    'height' => 'Length',
+                    'poster' => 'URI',
+                    'preload' => 'Enum#auto,metadata,none',
+                    'controls' => 'Bool',
+                ]],
+                ['source', 'Block', 'Flow', 'Common', [
+                    'src' => 'URI',
+                    'type' => 'Text',
+                ]],
+
+                // * http://developers.whatwg.org/text-level-semantics.html
+                ['s',    'Inline', 'Inline', 'Common'],
+                ['var',  'Inline', 'Inline', 'Common'],
+                ['sub',  'Inline', 'Inline', 'Common'],
+                ['sup',  'Inline', 'Inline', 'Common'],
+                ['mark', 'Inline', 'Inline', 'Common'],
+                ['wbr',  'Inline', 'Empty', 'Core'],
+
+                // * http://developers.whatwg.org/edits.html
+                ['ins', 'Block', 'Flow', 'Common', ['cite' => 'URI', 'datetime' => 'CDATA']],
+                ['del', 'Block', 'Flow', 'Common', ['cite' => 'URI', 'datetime' => 'CDATA']],
+            ],
+            'attributes' => [
+                ['iframe', 'allowfullscreen', 'Bool'],
+                ['table', 'height', 'Text'],
+                ['td', 'border', 'Text'],
+                ['th', 'border', 'Text'],
+                ['tr', 'width', 'Text'],
+                ['tr', 'height', 'Text'],
+                ['tr', 'border', 'Text'],
+                ['figure', 'class', 'Text'],
+                ['figure', 'style', 'Text'],
+                ['oembed', 'url', 'Text'],
+                ['span', 'style', 'Text'],
+                ['img', 'style', 'Text'],
+            ],
+        ],
+        'custom_attributes' => [
+            ['a', 'target', 'Enum#_blank,_self,_target,_top'],
+            ['ol', 'style', 'Text'],
+            ['figure', 'style', 'Text'],
+            ['img', 'style', 'Text'],
+            ['span', 'style', 'Text'],
+            ['oembed', 'url', 'Text'],
+        ],
+        'custom_elements' => [
+            ['u', 'Inline', 'Inline', 'Common'],
+            ['oembed', 'Inline', 'Inline', 'Common'],
+        ],
+    ],
+];

config/queue.php

@@ -0,0 +1,109 @@
+<?php
+
+return [
+
+    /*
+        |--------------------------------------------------------------------------
+        | Default Queue Connection Name
+        |--------------------------------------------------------------------------
+        |
+        | Laravel's queue API supports an assortment of back-ends via a single
+        | API, giving you convenient access to each back-end using the same
+        | syntax for every one. Here you may define a default connection.
+        |
+    */
+
+    'default' => env('QUEUE_CONNECTION', 'sync'),
+
+    /*
+        |--------------------------------------------------------------------------
+        | Queue Connections
+        |--------------------------------------------------------------------------
+        |
+        | Here you may configure the connection information for each server that
+        | is used by your application. A default configuration has been added
+        | for each back-end shipped with Laravel. You are free to add more.
+        |
+        | Drivers: "sync", "database", "beanstalkd", "sqs", "redis", "null"
+        |
+    */
+
+    'connections' => [
+
+        'sync' => [
+            'driver' => 'sync',
+        ],
+
+        'database' => [
+            'driver' => 'database',
+            'table' => 'jobs',
+            'queue' => 'default',
+            'retry_after' => 90,
+            'after_commit' => false,
+        ],
+
+        'beanstalkd' => [
+            'driver' => 'beanstalkd',
+            'host' => 'localhost',
+            'queue' => 'default',
+            'retry_after' => 90,
+            'block_for' => 0,
+            'after_commit' => false,
+        ],
+
+        'sqs' => [
+            'driver' => 'sqs',
+            'key' => env('AWS_ACCESS_KEY_ID'),
+            'secret' => env('AWS_SECRET_ACCESS_KEY'),
+            'prefix' => env('SQS_PREFIX', 'https://sqs.us-east-1.amazonaws.com/your-account-id'),
+            'queue' => env('SQS_QUEUE', 'default'),
+            'suffix' => env('SQS_SUFFIX'),
+            'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
+            'after_commit' => false,
+        ],
+
+        'redis' => [
+            'driver' => 'redis',
+            'connection' => 'default',
+            'queue' => env('REDIS_QUEUE', 'default'),
+            'retry_after' => 90,
+            'block_for' => null,
+            'after_commit' => false,
+        ],
+
+    ],
+
+    /*
+        |--------------------------------------------------------------------------
+        | Job Batching
+        |--------------------------------------------------------------------------
+        |
+        | The following options configure the database and table that store job
+        | batching information. These options can be updated to any database
+        | connection and table which has been defined by your application.
+        |
+    */
+
+    'batching' => [
+        'database' => env('DB_CONNECTION', 'mysql'),
+        'table' => 'job_batches',
+    ],
+
+    /*
+        |--------------------------------------------------------------------------
+        | Failed Queue Jobs
+        |--------------------------------------------------------------------------
+        |
+        | These options configure the behavior of failed queue job logging so you
+        | can control which database and table are used to store the jobs that
+        | have failed. You may change them to any database / table you wish.
+        |
+    */
+
+    'failed' => [
+        'driver' => env('QUEUE_FAILED_DRIVER', 'database-uuids'),
+        'database' => env('DB_CONNECTION', 'mysql'),
+        'table' => 'failed_jobs',
+    ],
+
+];

config/sentry.php

@@ -0,0 +1,61 @@
+<?php
+
+return [
+
+    'dsn' => env('SENTRY_LARAVEL_DSN', env('SENTRY_DSN')),
+
+    // The release version of your application.
+    // Example with dynamic git hash: trim(exec('git --git-dir ' . base_path('.git') . ' log --pretty="%h" -n1 HEAD')).
+    'release' => env('SENTRY_RELEASE'),
+
+    // When left empty or `null` the Laravel environment will be used.
+    'environment' => env('SENTRY_ENVIRONMENT'),
+
+    'breadcrumbs' => [
+        // Capture Laravel logs in breadcrumbs.
+        'logs' => true,
+
+        // Capture SQL queries in breadcrumbs.
+        'sql_queries' => true,
+
+        // Capture bindings on SQL queries logged in breadcrumbs.
+        'sql_bindings' => false,
+
+        // Capture queue job information in breadcrumbs.
+        'queue_info' => true,
+
+        // Capture command information in breadcrumbs.
+        'command_info' => true,
+    ],
+
+    'tracing' => [
+        // Trace queue jobs as their own transactions.
+        'queue_job_transactions' => env('SENTRY_TRACE_QUEUE_ENABLED', false),
+
+        // Capture queue jobs as spans when executed on the sync driver.
+        'queue_jobs' => true,
+
+        // Capture SQL queries as spans.
+        'sql_queries' => true,
+
+        // Try to find out where the SQL query originated from and add it to the query spans.
+        'sql_origin' => true,
+
+        // Capture views as spans.
+        'views' => true,
+
+        // Indicates if the tracing integrations supplied by Sentry should be loaded.
+        'default_integrations' => true,
+
+        // Indicates that requests without a matching route should be traced.
+        'missing_routes' => false,
+    ],
+
+    // @see: https://docs.sentry.io/platforms/php/guides/laravel/configuration/options/#send-default-pii.
+    'send_default_pii' => env('SENTRY_SEND_DEFAULT_PII', false),
+
+    // @see: https://docs.sentry.io/platforms/php/guides/laravel/configuration/options/#traces-sample-rate.
+    'traces_sample_rate' => env('SENTRY_TRACES_SAMPLE_RATE') === null ? null : (float)env('SENTRY_TRACES_SAMPLE_RATE'),
+
+    'before_send' => [\App\Lib\Helpers\ExceptionsHelper::class, 'sentryEventHandler'],
+];

config/services.php

@@ -0,0 +1,34 @@
+<?php
+
+return [
+
+    /*
+        |--------------------------------------------------------------------------
+        | Third Party Services
+        |--------------------------------------------------------------------------
+        |
+        | This file is for storing the credentials for third party services such
+        | as Mailgun, Postmark, AWS and more. This file provides the de facto
+        | location for this type of information, allowing packages to have
+        | a conventional file to locate the various service credentials.
+        |
+    */
+
+    'mailgun' => [
+        'domain' => env('MAILGUN_DOMAIN'),
+        'secret' => env('MAILGUN_SECRET'),
+        'endpoint' => env('MAILGUN_ENDPOINT', 'api.mailgun.net'),
+        'scheme' => 'https',
+    ],
+
+    'postmark' => [
+        'token' => env('POSTMARK_TOKEN'),
+    ],
+
+    'ses' => [
+        'key' => env('AWS_ACCESS_KEY_ID'),
+        'secret' => env('AWS_SECRET_ACCESS_KEY'),
+        'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
+    ],
+
+];

config/session.php

@@ -0,0 +1,201 @@
+<?php
+
+use Illuminate\Support\Str;
+
+return [
+
+    /*
+        |--------------------------------------------------------------------------
+        | Default Session Driver
+        |--------------------------------------------------------------------------
+        |
+        | This option controls the default session "driver" that will be used on
+        | requests. By default, we will use the lightweight native driver but
+        | you may specify any of the other wonderful drivers provided here.
+        |
+        | Supported: "file", "cookie", "database", "apc",
+        |            "memcached", "redis", "dynamodb", "array"
+        |
+    */
+
+    'driver' => env('SESSION_DRIVER', 'file'),
+
+    /*
+        |--------------------------------------------------------------------------
+        | Session Lifetime
+        |--------------------------------------------------------------------------
+        |
+        | Here you may specify the number of minutes that you wish the session
+        | to be allowed to remain idle before it expires. If you want them
+        | to immediately expire on the browser closing, set that option.
+        |
+    */
+
+    'lifetime' => env('SESSION_LIFETIME', 120),
+
+    'expire_on_close' => false,
+
+    /*
+        |--------------------------------------------------------------------------
+        | Session Encryption
+        |--------------------------------------------------------------------------
+        |
+        | This option allows you to easily specify that all of your session data
+        | should be encrypted before it is stored. All encryption will be run
+        | automatically by Laravel and you can use the Session like normal.
+        |
+    */
+
+    'encrypt' => false,
+
+    /*
+        |--------------------------------------------------------------------------
+        | Session File Location
+        |--------------------------------------------------------------------------
+        |
+        | When using the native session driver, we need a location where session
+        | files may be stored. A default has been set for you but a different
+        | location may be specified. This is only needed for file sessions.
+        |
+    */
+
+    'files' => storage_path('framework/sessions'),
+
+    /*
+        |--------------------------------------------------------------------------
+        | Session Database Connection
+        |--------------------------------------------------------------------------
+        |
+        | When using the "database" or "redis" session drivers, you may specify a
+        | connection that should be used to manage these sessions. This should
+        | correspond to a connection in your database configuration options.
+        |
+    */
+
+    'connection' => env('SESSION_CONNECTION'),
+
+    /*
+        |--------------------------------------------------------------------------
+        | Session Database Table
+        |--------------------------------------------------------------------------
+        |
+        | When using the "database" session driver, you may specify the table we
+        | should use to manage the sessions. Of course, a sensible default is
+        | provided for you; however, you are free to change this as needed.
+        |
+    */
+
+    'table' => 'sessions',
+
+    /*
+        |--------------------------------------------------------------------------
+        | Session Cache Store
+        |--------------------------------------------------------------------------
+        |
+        | While using one of the framework's cache driven session backends you may
+        | list a cache store that should be used for these sessions. This value
+        | must match with one of the application's configured cache "stores".
+        |
+        | Affects: "apc", "dynamodb", "memcached", "redis"
+        |
+    */
+
+    'store' => env('SESSION_STORE'),
+
+    /*
+        |--------------------------------------------------------------------------
+        | Session Sweeping Lottery
+        |--------------------------------------------------------------------------
+        |
+        | Some session drivers must manually sweep their storage location to get
+        | rid of old sessions from storage. Here are the chances that it will
+        | happen on a given request. By default, the odds are 2 out of 100.
+        |
+    */
+
+    'lottery' => [2, 100],
+
+    /*
+        |--------------------------------------------------------------------------
+        | Session Cookie Name
+        |--------------------------------------------------------------------------
+        |
+        | Here you may change the name of the cookie used to identify a session
+        | instance by ID. The name specified here will get used every time a
+        | new session cookie is created by the framework for every driver.
+        |
+    */
+
+    'cookie' => env(
+        'SESSION_COOKIE',
+        Str::slug(env('APP_NAME', 'laravel'), '_') . '_session'
+    ),
+
+    /*
+        |--------------------------------------------------------------------------
+        | Session Cookie Path
+        |--------------------------------------------------------------------------
+        |
+        | The session cookie path determines the path for which the cookie will
+        | be regarded as available. Typically, this will be the root path of
+        | your application but you are free to change this when necessary.
+        |
+    */
+
+    'path' => '/',
+
+    /*
+        |--------------------------------------------------------------------------
+        | Session Cookie Domain
+        |--------------------------------------------------------------------------
+        |
+        | Here you may change the domain of the cookie used to identify a session
+        | in your application. This will determine which domains the cookie is
+        | available to in your application. A sensible default has been set.
+        |
+    */
+
+    'domain' => env('SESSION_DOMAIN'),
+
+    /*
+        |--------------------------------------------------------------------------
+        | HTTPS Only Cookies
+        |--------------------------------------------------------------------------
+        |
+        | By setting this option to true, session cookies will only be sent back
+        | to the server if the browser has a HTTPS connection. This will keep
+        | the cookie from being sent to you when it can't be done securely.
+        |
+    */
+
+    'secure' => env('SESSION_SECURE_COOKIE'),
+
+    /*
+        |--------------------------------------------------------------------------
+        | HTTP Access Only
+        |--------------------------------------------------------------------------
+        |
+        | Setting this value to true will prevent JavaScript from accessing the
+        | value of the cookie and the cookie will only be accessible through
+        | the HTTP protocol. You are free to modify this option if needed.
+        |
+    */
+
+    'http_only' => true,
+
+    /*
+        |--------------------------------------------------------------------------
+        | Same-Site Cookies
+        |--------------------------------------------------------------------------
+        |
+        | This option determines how your cookies behave when cross-site requests
+        | take place, and can be used to mitigate CSRF attacks. By default, we
+        | will set this value to "lax" since this is a secure default value.
+        |
+        | Supported: "lax", "strict", "none", null
+        |
+    */
+
+    'same_site' => 'lax',
+
+];

config/view.php

@@ -0,0 +1,38 @@
+<?php
+
+return [
+
+    /*
+        |--------------------------------------------------------------------------
+        | View Storage Paths
+        |--------------------------------------------------------------------------
+        |
+        | Most templating systems load templates from disk. Here you may specify
+        | an array of paths that should be checked for your views. Of course
+        | the usual Laravel view path has already been registered for you.
+        |
+    */
+
+    'paths' => [
+        resource_path('views'),
+        // ! for vendor publish (mail notifications par ex)
+        resource_path('views/vendor'),
+    ],
+
+    /*
+        |--------------------------------------------------------------------------
+        | Compiled View Path
+        |--------------------------------------------------------------------------
+        |
+        | This option determines where all the compiled Blade templates will be
+        | stored for your application. Typically, this is within the storage
+        | directory. However, as usual, you are free to change this value.
+        |
+    */
+
+    'compiled' => env(
+        'VIEW_COMPILED_PATH',
+        realpath(storage_path('framework/views'))
+    ),
+
+];

database/.gitignore

@@ -0,0 +1 @@
+*.sqlite*

database/factories/UserFactory.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace Database\Factories;
+
+use Illuminate\Database\Eloquent\Factories\Factory;
+use Illuminate\Support\Str;
+
+class UserFactory extends Factory
+{
+    /**
+     * Define the model's default state.
+     *
+     * @return array<string, mixed>
+     */
+    public function definition()
+    {
+        return [
+            'firstname' => fake()->firstname(),
+            'lastname' => fake()->lastname(),
+            'email' => fake()->unique()->safeEmail(),
+            'email_verified_at' => now(),
+            // * password
+            'password' => '$2y$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi',
+            'remember_token' => Str::random(10),
+        ];
+    }
+
+    /**
+     * Indicate that the model's email address should be unverified.
+     *
+     * @return static
+     */
+    public function unverified(): static
+    {
+        // phpcs:ignore Generic.CodeAnalysis.UnusedFunctionParameter.FoundInExtendedClass
+        return $this->state(fn (array $attributes) => [
+            'email_verified_at' => null,
+        ]);
+    }
+}

database/migrations/2014_10_12_000000_create_users_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.
+     *
+     * @return void
+     */
+    public function up()
+    {
+        Schema::create('users', function (Blueprint $table) {
+            $table->id();
+            $table->string('firstname');
+            $table->string('lastname');
+            $table->string('email')->unique();
+            $table->timestamp('email_verified_at')->nullable();
+            $table->string('password');
+            $table->rememberToken();
+            $table->timestamps();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     *
+     * @return void
+     */
+    public function down()
+    {
+        Schema::dropIfExists('users');
+    }
+};

database/migrations/2014_10_12_100000_create_password_resets_table.php

@@ -0,0 +1,32 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     *
+     * @return void
+     */
+    public function up()
+    {
+        Schema::create('password_resets', function (Blueprint $table) {
+            $table->string('email')->index();
+            $table->string('token');
+            $table->timestamp('created_at')->nullable();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     *
+     * @return void
+     */
+    public function down()
+    {
+        Schema::dropIfExists('password_resets');
+    }
+};

database/migrations/2019_08_19_000000_create_failed_jobs_table.php

@@ -0,0 +1,36 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     *
+     * @return void
+     */
+    public function up()
+    {
+        Schema::create('failed_jobs', function (Blueprint $table) {
+            $table->id();
+            $table->string('uuid')->unique();
+            $table->text('connection');
+            $table->text('queue');
+            $table->longText('payload');
+            $table->longText('exception');
+            $table->timestamp('failed_at')->useCurrent();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     *
+     * @return void
+     */
+    public function down()
+    {
+        Schema::dropIfExists('failed_jobs');
+    }
+};

database/seeders/DatabaseSeeder.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Database\Seeders;
+
+use Illuminate\Database\Seeder;
+
+class DatabaseSeeder extends Seeder
+{
+    /**
+     * Seed the application's database.
+     *
+     * @return void
+     */
+    public function run()
+    {
+    }
+}

jsconfig.json

@@ -0,0 +1,3 @@
+{
+  "include": ["./resources/js/**/*"]
+}

package.json

@@ -0,0 +1,68 @@
+{
+    "private": true,
+    "scripts": {
+        "prod": "vite build --mode production",
+        "dev": "NODE_ENV=development vite build -d --mode development",
+        "watch": "NODE_ENV=development vite build --mode development --watch",
+        "eslint": "node ./node_modules/.bin/eslint --max-warnings 0 -c .eslintrc.json ./resources",
+        "eslint-fix": "node ./node_modules/.bin/eslint --fix --max-warnings 0 -c .eslintrc.json ./resources",
+        "eslint-ci": "node ./node_modules/.bin/eslint --max-warnings 0 -c .eslintrc.json ./resources -f junit",
+        "stylelint": "node ./node_modules/.bin/stylelint --config './.stylelintrc.json' --max-warnings 0 '**/resources/**/*.scss'",
+        "stylelint-fix": "node ./node_modules/.bin/stylelint --config './.stylelintrc.json' --fix --max-warnings 0 '**/resources/**/*.scss'",
+        "stylelint-ci": "node ./node_modules/.bin/stylelint --config './.stylelintrc.json' --max-warnings 0 '**/resources/**/*.scss' -f json"
+    },
+    "devDependencies": {
+        "@babel/types": "^7.21.2",
+        "@fortawesome/fontawesome-svg-core": "^6.1.2",
+        "@fortawesome/free-brands-svg-icons": "^6.1.2",
+        "@fortawesome/free-regular-svg-icons": "^6.1.2",
+        "@fortawesome/free-solid-svg-icons": "^6.1.2",
+        "@fortawesome/vue-fontawesome": "^3.0.1",
+        "@rushstack/eslint-patch": "^1.1.4",
+        "@sipec/vue3-tags-input": "^3.0.4",
+        "@types/bootstrap": "^5.2.6",
+        "@types/cropperjs": "^1.3.0",
+        "@types/toastify-js": "^1.11.1",
+        "@types/webpack-env": "^1.18.0",
+        "@typescript-eslint/eslint-plugin": "^5.36.2",
+        "@typescript-eslint/parser": "^5.36.2",
+        "@vitejs/plugin-legacy": "^4.0.1",
+        "@vitejs/plugin-vue": "^4.0.0",
+        "@vue/eslint-config-typescript": "^11.0.0",
+        "axios": "^1.1.2",
+        "bootstrap": "^5.2.3",
+        "cropperjs": "^1.5.12",
+        "eslint": "^8.35.0",
+        "eslint-import-resolver-alias": "^1.1.2",
+        "eslint-plugin-vue": "^9.4.0",
+        "laravel-vite-plugin": "^0.7.2",
+        "postcss": "^8.4.21",
+        "postcss-discard-comments": "^5.1.2",
+        "postcss-html": "^1.5.0",
+        "postcss-scss": "^4.0.6",
+        "prettier": "^2.7.1",
+        "resolve-url-loader": "^5.0.0",
+        "sass": "^1.58.3",
+        "slugify": "^1.6.5",
+        "stylelint": "^14.16.1",
+        "stylelint-config-idiomatic-order": "^8.1.0",
+        "stylelint-config-sass-guidelines": "^9.0.1",
+        "stylelint-config-standard-scss": "^6.1.0",
+        "stylelint-scss": "^4.4.0",
+        "stylelint-webpack-plugin": "^3.3.0",
+        "sweetalert2": "^11.4.8",
+        "toastify-js": "^1.12.0",
+        "ts-loader": "^9.3.1",
+        "typescript": "^4.9.5",
+        "typescript-eslint": "^0.0.1-alpha.0",
+        "vite": "^4.0.0",
+        "vite-plugin-checker": "^0.5.6",
+        "vite-plugin-eslint": "^1.8.1",
+        "vite-plugin-stylelint": "^4.2.0",
+        "vue": "^3.2.38",
+        "vue-eslint-parser": "^9.1.0",
+        "vue-loader": "^16.8.3",
+        "vue-tsc": "^1.2.0",
+        "vue3-nestable": "^3.0.3"
+    }
+}

phpcs.xml

@@ -0,0 +1,129 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ruleset name="LDC Laravel"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="vendor/squizlabs/php_codesniffer/phpcs.xsd">
+    <description>Created with the PHP Coding Standard Generator. http://edorian.github.com/php-coding-standard-generator/</description>
+    <arg name="colors" />
+    <arg name="extensions" value="php" />
+    <file>app/</file>
+    <file>config/</file>
+    <file>database/factories</file>
+    <file>routes/</file>
+    <rule ref="PSR1" />
+    <rule ref="PSR12" />
+
+    <rule ref="Generic.Classes.DuplicateClassName"/>
+    <rule ref="Generic.CodeAnalysis.EmptyStatement"/>
+    <rule ref="Generic.CodeAnalysis.ForLoopShouldBeWhileLoop"/>
+    <rule ref="Generic.CodeAnalysis.ForLoopWithTestFunctionCall"/>
+    <rule ref="Generic.CodeAnalysis.JumbledIncrementer"/>
+    <rule ref="Generic.CodeAnalysis.UnconditionalIfStatement"/>
+    <rule ref="Generic.CodeAnalysis.UnnecessaryFinalModifier"/>
+    <rule ref="Generic.CodeAnalysis.UnusedFunctionParameter"/>
+    <rule ref="Generic.CodeAnalysis.UselessOverridingMethod"/>
+    <rule ref="Generic.Commenting.DocComment.SpacingBeforeTags"/>
+    <rule ref="Generic.Commenting.Todo"/>
+    <rule ref="Generic.Commenting.Fixme"/>
+    <rule ref="Generic.ControlStructures.InlineControlStructure"/>
+    <rule ref="Generic.Files.ByteOrderMark"/>
+    <rule ref="Generic.Files.LineEndings"/>
+    <rule ref="Generic.Files.LineLength"/>
+    <rule ref="Generic.Formatting.DisallowMultipleStatements"/>
+    <rule ref="Generic.Formatting.MultipleStatementAlignment"/>
+    <rule ref="Generic.Formatting.NoSpaceAfterCast"/>
+    <rule ref="Generic.Functions.CallTimePassByReference"/>
+    <rule ref="Generic.Functions.FunctionCallArgumentSpacing"/>
+    <rule ref="Generic.Metrics.CyclomaticComplexity"/>
+    <rule ref="Generic.Metrics.NestingLevel"/>
+    <rule ref="Generic.NamingConventions.ConstructorName"/>
+    <rule ref="Generic.NamingConventions.UpperCaseConstantName"/>
+    <rule ref="Generic.NamingConventions.CamelCapsFunctionName"/>
+    <rule ref="Generic.PHP.DeprecatedFunctions"/>
+    <rule ref="Generic.PHP.DisallowShortOpenTag"/>
+    <rule ref="Generic.PHP.ForbiddenFunctions"/>
+    <rule ref="Generic.PHP.NoSilencedErrors"/>
+    <rule ref="Generic.Strings.UnnecessaryStringConcat"/>
+    <rule ref="Generic.WhiteSpace.DisallowTabIndent"/>
+    <rule ref="Generic.WhiteSpace.ScopeIndent"/>
+    <rule ref="MySource.PHP.EvalObjectFactory"/>
+    <rule ref="MySource.PHP.GetRequestData"/>
+    <rule ref="MySource.PHP.AjaxNullComparison"/>
+    <rule ref="PEAR.Classes.ClassDeclaration"/>
+    <rule ref="PEAR.Commenting.InlineComment"/>
+    <rule ref="PSR1.Classes.ClassDeclaration"/>
+    <rule ref="PSR1.Files.SideEffects"/>
+    <rule ref="PSR2.Classes.ClassDeclaration"/>
+    <rule ref="PSR2.Classes.PropertyDeclaration"/>
+    <rule ref="PSR2.ControlStructures.ElseIfDeclaration"/>
+    <rule ref="PSR2.ControlStructures.SwitchDeclaration"/>
+    <rule ref="PSR2.Files.EndFileNewline"/>
+    <rule ref="PSR2.Methods.MethodDeclaration"/>
+    <rule ref="PSR2.Namespaces.NamespaceDeclaration"/>
+    <rule ref="PSR2.Namespaces.UseDeclaration"/>
+    <rule ref="Squiz.PHP.CommentedOutCode"/>
+    <rule ref="Squiz.PHP.DisallowMultipleAssignments">
+        <exclude name="Squiz.PHP.DisallowMultipleAssignments.FoundInControlStructure" />
+    </rule>
+    <rule ref="Squiz.PHP.DisallowSizeFunctionsInLoops"/>
+
+    <rule ref="Squiz.PHP.DiscouragedFunctions">
+        <properties>
+            <property name="error" value="true"/>
+        </properties>
+    </rule>
+    <rule ref="Squiz.PHP.Eval"/>
+    <rule ref="Squiz.PHP.GlobalKeyword"/>
+    <rule ref="Squiz.PHP.Heredoc"/>
+    <rule ref="Squiz.PHP.InnerFunctions"/>
+    <rule ref="Squiz.PHP.LowercasePHPFunctions"/>
+    <rule ref="Squiz.PHP.NonExecutableCode"/>
+    <rule ref="Squiz.Scope.MemberVarScope"/>
+    <rule ref="Squiz.Scope.MethodScope"/>
+    <rule ref="Squiz.Scope.StaticThisUsage"/>
+    <rule ref="Squiz.WhiteSpace.LanguageConstructSpacing"/>
+    <rule ref="Squiz.WhiteSpace.LogicalOperatorSpacing"/>
+    <rule ref="Squiz.WhiteSpace.MemberVarSpacing">
+        <properties>
+            <property name="spacingBeforeFirst " value="false"/>
+        </properties>
+    </rule>
+    <rule ref="Squiz.WhiteSpace.OperatorSpacing">
+        <properties>
+            <property name="ignoreNewlines" value="true"/>
+        </properties>
+    </rule>
+    <rule ref="Squiz.WhiteSpace.ObjectOperatorSpacing">
+        <properties>
+            <property name="ignoreNewlines" value="true"/>
+        </properties>
+    </rule>
+    <rule ref="Squiz.WhiteSpace.ScopeKeywordSpacing"/>
+    <rule ref="Squiz.WhiteSpace.SemicolonSpacing"/>
+    <rule ref="Squiz.Commenting.BlockComment">
+        <exclude name="Squiz.Commenting.BlockComment.WrongStart" />
+    </rule>
+    <rule ref="Squiz.Commenting.ClassComment">
+        <exclude name="Squiz.Commenting.ClassComment.Missing" />
+        <exclude name="Squiz.Commenting.ClassComment.TagNotAllowed" />
+    </rule>
+    <rule ref="Squiz.Commenting.DocCommentAlignment"/>
+    <rule ref="Squiz.Commenting.EmptyCatchComment"/>
+    <rule ref="Squiz.Commenting.FunctionComment">
+        <exclude name="Squiz.Commenting.FunctionComment.MissingParamComment" />
+    </rule>
+    <rule ref="Squiz.Commenting.FunctionCommentThrowTag"/>
+    <rule ref="Squiz.Commenting.InlineComment">
+        <exclude name="Squiz.Commenting.InlineComment.DocBlock" />
+    </rule>
+    <rule ref="Squiz.Commenting.LongConditionClosingComment">
+        <exclude name="Squiz.Commenting.LongConditionClosingComment.SpacingBefore" />
+    </rule>
+    <rule ref="Squiz.Commenting.PostStatementComment"/>
+    <rule ref="Squiz.Commenting.VariableComment"/>
+    <rule ref="SlevomatCodingStandard.Namespaces.UnusedUses.UnusedUse" />
+
+    <!-- For Laravel migrations -->
+    <rule ref="PSR1.Classes.ClassDeclaration.MissingNamespace">
+        <exclude-pattern>*/database/migrations/*</exclude-pattern>
+    </rule>
+
+</ruleset>

phpunit.xml

@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:noNamespaceSchemaLocation="./vendor/phpunit/phpunit/phpunit.xsd"
+         bootstrap="vendor/autoload.php"
+         colors="true"
+>
+    <testsuites>
+        <testsuite name="Unit">
+            <directory suffix="Test.php">./tests/Unit</directory>
+        </testsuite>
+        <testsuite name="Feature">
+            <directory suffix="Test.php">./tests/Feature</directory>
+        </testsuite>
+    </testsuites>
+    <coverage>
+        <include>
+            <directory suffix=".php">./app</directory>
+        </include>
+    </coverage>
+    <php>
+        <env name="APP_ENV" value="testing"/>
+        <env name="BCRYPT_ROUNDS" value="4"/>
+        <env name="CACHE_DRIVER" value="array"/>
+        <!-- <env name="DB_CONNECTION" value="sqlite"/> -->
+        <!-- <env name="DB_DATABASE" value=":memory:"/> -->
+        <env name="MAIL_MAILER" value="array"/>
+        <env name="QUEUE_CONNECTION" value="sync"/>
+        <env name="SESSION_DRIVER" value="array"/>
+        <env name="TELESCOPE_ENABLED" value="false"/>
+    </php>
+</phpunit>

public/.htaccess

@@ -0,0 +1,21 @@
+<IfModule mod_rewrite.c>
+    <IfModule mod_negotiation.c>
+        Options -MultiViews -Indexes
+    </IfModule>
+
+    RewriteEngine On
+
+    # Handle Authorization Header
+    RewriteCond %{HTTP:Authorization} .
+    RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]
+
+    # Redirect Trailing Slashes If Not A Folder...
+    RewriteCond %{REQUEST_FILENAME} !-d
+    RewriteCond %{REQUEST_URI} (.+)/$
+    RewriteRule ^ %1 [L,R=301]
+
+    # Send Requests To Front Controller...
+    RewriteCond %{REQUEST_FILENAME} !-d
+    RewriteCond %{REQUEST_FILENAME} !-f
+    RewriteRule ^ index.php [L]
+</IfModule>

public/build/mix-manifest.json

@@ -0,0 +1,8 @@
+{
+    "/js/bo.js": "/js/bo.js?id=d5b460177c4d519c44b95ddb6724fa79",
+    "/js/fo.js": "/js/fo.js?id=fef554706b17ee4e1db4e25e6804f84b",
+    "/css/v-extract.css": "/css/v-extract.css?id=4bf51e09a4f414af42bd780185c43dab",
+    "/css/fo.css": "/css/fo.css?id=2e86c464cd3b465bb9d4d4788ce6bff9",
+    "/css/mail/html/themes/default.css": "/css/mail/html/themes/default.css?id=2f72d8d81b954a90c2117ccb349c6f11",
+    "/css/bo.css": "/css/bo.css?id=fdafca775eb083d0ecc191a7ef48fd1a"
+}

public/index.php

@@ -0,0 +1,55 @@
+<?php
+
+use Illuminate\Contracts\Http\Kernel;
+use Illuminate\Http\Request;
+
+define('LARAVEL_START', microtime(true));
+
+/*
+|--------------------------------------------------------------------------
+| Check If The Application Is Under Maintenance
+|--------------------------------------------------------------------------
+|
+| If the application is in maintenance / demo mode via the "down" command
+| we will load this file so that any pre-rendered content can be shown
+| instead of starting the framework, which could cause an exception.
+|
+*/
+
+if (file_exists($maintenance = __DIR__.'/../storage/framework/maintenance.php')) {
+    require $maintenance;
+}
+
+/*
+|--------------------------------------------------------------------------
+| Register The Auto Loader
+|--------------------------------------------------------------------------
+|
+| Composer provides a convenient, automatically generated class loader for
+| this application. We just need to utilize it! We'll simply require it
+| into the script here so we don't need to manually load our classes.
+|
+*/
+
+require __DIR__.'/../vendor/autoload.php';
+
+/*
+|--------------------------------------------------------------------------
+| Run The Application
+|--------------------------------------------------------------------------
+|
+| Once we have the application, we can handle the incoming request using
+| the application's HTTP kernel. Then, we will send the response back
+| to this client's browser, allowing them to enjoy our application.
+|
+*/
+
+$app = require_once __DIR__.'/../bootstrap/app.php';
+
+$kernel = $app->make(Kernel::class);
+
+$response = $kernel->handle(
+    $request = Request::capture()
+)->send();
+
+$kernel->terminate($request, $response);

public/robots.txt

@@ -0,0 +1,2 @@
+User-agent: *
+Disallow:

resources/js/vendor/ckeditor/.gitignore

@@ -0,0 +1 @@
+node_modules