Initial commit

composer.json

+{
+    "name": "goldenscarab/modulus",
+    "description": "CMS maison pour développeur",
+    "require": {
+        "php": ">=7.2"
+    },
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Goldenscarab",
+            "email": "web@goldenscarab.fr"
+        }
+    ],
+    "autoload": {
+        "psr-4": {
+            "Goldenscarab\\Modulus\\": "src/"
+        },
+        "files": [
+
+        ]
+    },
+    "minimum-stability": "dev",
+    "prefer-stable": false,
+    "extra": {
+        "laravel": {
+            "providers": [
+                "Goldenscarab\\Modulus\\App\\Providers\\ModulusServiceProvider"
+            ]
+        }
+    },
+    "require-dev": {
+        "laravel/framework": "8.x",
+        "goldenscarab/modulus-helpers": "1.x",
+        "goldenscarab/modulus-service-field": "1.0.x",
+        "goldenscarab/modulus-service-template": "0.1.x",
+        "spatie/laravel-permission": "4.x",
+        "spatie/laravel-cookie-consent": "2.x",
+        "maatwebsite/excel": "3.x",
+        "barryvdh/laravel-debugbar": "3.x",
+        "barryvdh/laravel-elfinder": "0.4.x"
+    }
+}

src/app/Http/Controllers/Api/UserController.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Controllers\Api;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Response;
+use Illuminate\Routing\Controller;
+use Goldenscarab\Modulus\App\Http\Repositories\UserRepository;
+
+class UserController extends Controller
+{
+    private $user_repo;
+
+    public function __construct(UserRepository $user_repo)
+    {
+        $this->user_repo = $user_repo;
+    }
+
+    /**
+     * Display a listing of the resource.
+     * @return Response
+     */
+    public function index(Request $request)
+    {
+        $sort      = $request->get('sort', 'lastname');
+        $direction = $request->get('direction', 'asc');
+        $perpage   = $request->get('perpage', 15);
+        $search    = $request->get('search');
+
+        $users = $this->user_repo->list($sort, $direction, $perpage, $search);
+
+        return response()->json($users);
+    }
+
+    /**
+     * Store a newly created resource in storage.
+     * @param Request $request
+     * @return Response
+     */
+    public function store(Request $request)
+    {
+        //
+    }
+
+    /**
+     * Show the specified resource.
+     * @param int $id
+     * @return Response
+     */
+    public function show($id)
+    {
+        //
+    }
+
+    /**
+     * Update the specified resource in storage.
+     * @param Request $request
+     * @param int $id
+     * @return Response
+     */
+    public function update(Request $request, $id)
+    {
+        //
+    }
+
+    /**
+     * Remove the specified resource from storage.
+     * @param int $id
+     * @return Response
+     */
+    public function destroy($id)
+    {
+        //
+    }
+}

src/app/Http/Controllers/Auth/AuthenticatedSessionController.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Controllers\Auth;
+
+use App\Http\Controllers\Controller;
+use Goldenscarab\Modulus\App\Http\Requests\LoginRequest;
+use Goldenscarab\Modulus\App\Providers\RouteServiceProvider;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+
+class AuthenticatedSessionController extends Controller
+{
+    /**
+     * Display the login view.
+     *
+     * @return \Illuminate\View\View
+     */
+    public function create()
+    {
+        return view('auth.login');
+    }
+
+    /**
+     * Handle an incoming authentication request.
+     *
+     * @param  \App\Http\Requests\Auth\LoginRequest  $request
+     * @return \Illuminate\Http\RedirectResponse
+     */
+    public function store(LoginRequest $request)
+    {
+        $request->authenticate();
+
+        $request->session()->regenerate();
+
+        return redirect()->intended();
+    }
+
+    /**
+     * Destroy an authenticated session.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Illuminate\Http\RedirectResponse
+     */
+    public function destroy(Request $request)
+    {
+        Auth::guard('web')->logout();
+
+        $request->session()->invalidate();
+
+        $request->session()->regenerateToken();
+
+        return redirect('/');
+    }
+}

src/app/Http/Controllers/Auth/ConfirmablePasswordController.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Controllers\Auth;
+
+use App\Http\Controllers\Controller;
+use Goldenscarab\Modulus\App\Providers\RouteServiceProvider;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Validation\ValidationException;
+
+class ConfirmablePasswordController extends Controller
+{
+    /**
+     * Show the confirm password view.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Illuminate\View\View
+     */
+    public function show(Request $request)
+    {
+        return view('auth.confirm-password');
+    }
+
+    /**
+     * Confirm the user's password.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return mixed
+     */
+    public function store(Request $request)
+    {
+        if (! Auth::guard('web')->validate([
+            'email' => $request->user()->email,
+            'password' => $request->password,
+        ])) {
+            throw ValidationException::withMessages([
+                'password' => __('auth.password'),
+            ]);
+        }
+
+        $request->session()->put('auth.password_confirmed_at', time());
+
+        return redirect()->intended(RouteServiceProvider::HOME);
+    }
+}

src/app/Http/Controllers/Auth/EmailVerificationNotificationController.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Controllers\Auth;
+
+use App\Http\Controllers\Controller;
+use App\Providers\RouteServiceProvider;
+use Illuminate\Http\Request;
+
+class EmailVerificationNotificationController extends Controller
+{
+    /**
+     * Send a new email verification notification.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Illuminate\Http\Response
+     */
+    public function store(Request $request)
+    {
+        if ($request->user()->hasVerifiedEmail()) {
+            return redirect()->intended(RouteServiceProvider::HOME);
+        }
+
+        $request->user()->sendEmailVerificationNotification();
+
+        return back()->with('status', 'verification-link-sent');
+    }
+}

src/app/Http/Controllers/Auth/EmailVerificationPromptController.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Controllers\Auth;
+
+use App\Http\Controllers\Controller;
+use App\Providers\RouteServiceProvider;
+use Illuminate\Http\Request;
+
+class EmailVerificationPromptController extends Controller
+{
+    /**
+     * Display the email verification prompt.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return mixed
+     */
+    public function __invoke(Request $request)
+    {
+        return $request->user()->hasVerifiedEmail()
+                    ? redirect()->intended(RouteServiceProvider::HOME)
+                    : view('auth.verify-email');
+    }
+}

src/app/Http/Controllers/Auth/NewPasswordController.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Controllers\Auth;
+
+use App\Http\Controllers\Controller;
+use Illuminate\Auth\Events\PasswordReset;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Hash;
+use Illuminate\Support\Facades\Password;
+use Illuminate\Support\Str;
+
+class NewPasswordController extends Controller
+{
+    /**
+     * Display the password reset view.
+     *
+     * @return \Illuminate\View\View
+     */
+    public function create(Request $request)
+    {
+        return view('auth.reset-password', ['request' => $request]);
+    }
+
+    /**
+     * Handle an incoming new password request.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Illuminate\Http\RedirectResponse
+     *
+     * @throws \Illuminate\Validation\ValidationException
+     */
+    public function store(Request $request)
+    {
+        $request->validate([
+            'token' => 'required',
+            'email' => 'required|email',
+            'password' => 'required|string|confirmed|min:8',
+        ]);
+
+        // Here we will attempt to reset the user's password. If it is successful we
+        // will update the password on an actual user model and persist it to the
+        // database. Otherwise we will parse the error and return the response.
+        $status = Password::reset(
+            $request->only('email', 'password', 'password_confirmation', 'token'),
+            function ($user) use ($request) {
+                $user->forceFill([
+                    'password' => Hash::make($request->password),
+                    'remember_token' => Str::random(60),
+                ])->save();
+
+                event(new PasswordReset($user));
+            }
+        );
+
+        // If the password was successfully reset, we will redirect the user back to
+        // the application's home authenticated view. If there is an error we can
+        // redirect them back to where they came from with their error message.
+        return $status == Password::PASSWORD_RESET
+                    ? redirect()->route('login')->with('status', __($status))
+                    : back()->withInput($request->only('email'))
+                            ->withErrors(['email' => __($status)]);
+    }
+}

src/app/Http/Controllers/Auth/PasswordResetLinkController.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Controllers\Auth;
+
+use App\Http\Controllers\Controller;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Password;
+
+class PasswordResetLinkController extends Controller
+{
+    /**
+     * Display the password reset link request view.
+     *
+     * @return \Illuminate\View\View
+     */
+    public function create()
+    {
+        return view('auth.forgot-password');
+    }
+
+    /**
+     * Handle an incoming password reset link request.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Illuminate\Http\RedirectResponse
+     *
+     * @throws \Illuminate\Validation\ValidationException
+     */
+    public function store(Request $request)
+    {
+        $request->validate([
+            'email' => 'required|email',
+        ]);
+
+        // We will send the password reset link to this user. Once we have attempted
+        // to send the link, we will examine the response then see the message we
+        // need to show to the user. Finally, we'll send out a proper response.
+        $status = Password::sendResetLink(
+            $request->only('email')
+        );
+
+        return $status == Password::RESET_LINK_SENT
+                    ? back()->with('status', __($status))
+                    : back()->withInput($request->only('email'))
+                            ->withErrors(['email' => __($status)]);
+    }
+}

src/app/Http/Controllers/Auth/RegisteredUserController.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Controllers\Auth;
+
+use App\Http\Controllers\Controller;
+use App\Models\User;
+use App\Providers\RouteServiceProvider;
+use Illuminate\Auth\Events\Registered;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\Hash;
+
+class RegisteredUserController extends Controller
+{
+    /**
+     * Display the registration view.
+     *
+     * @return \Illuminate\View\View
+     */
+    public function create()
+    {
+        return view('auth.register');
+    }
+
+    /**
+     * Handle an incoming registration request.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Illuminate\Http\RedirectResponse
+     *
+     * @throws \Illuminate\Validation\ValidationException
+     */
+    public function store(Request $request)
+    {
+        $request->validate([
+            'name' => 'required|string|max:255',
+            'email' => 'required|string|email|max:255|unique:users',
+            'password' => 'required|string|confirmed|min:8',
+        ]);
+
+        Auth::login($user = User::create([
+            'name' => $request->name,
+            'email' => $request->email,
+            'password' => Hash::make($request->password),
+        ]));
+
+        event(new Registered($user));
+
+        return redirect(RouteServiceProvider::HOME);
+    }
+}

src/app/Http/Controllers/Auth/VerifyEmailController.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Controllers\Auth;
+
+use App\Http\Controllers\Controller;
+use App\Providers\RouteServiceProvider;
+use Illuminate\Auth\Events\Verified;
+use Illuminate\Foundation\Auth\EmailVerificationRequest;
+
+class VerifyEmailController extends Controller
+{
+    /**
+     * Mark the authenticated user's email address as verified.
+     *
+     * @param  \Illuminate\Foundation\Auth\EmailVerificationRequest  $request
+     * @return \Illuminate\Http\RedirectResponse
+     */
+    public function __invoke(EmailVerificationRequest $request)
+    {
+        if ($request->user()->hasVerifiedEmail()) {
+            return redirect()->intended(RouteServiceProvider::HOME.'?verified=1');
+        }
+
+        if ($request->user()->markEmailAsVerified()) {
+            event(new Verified($request->user()));
+        }
+
+        return redirect()->intended(RouteServiceProvider::HOME.'?verified=1');
+    }
+}

src/app/Http/Controllers/Back/DashboardController.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Controllers\Back;
+
+use App\Http\Controllers\Controller;
+
+use Carbon\Carbon;
+use Illuminate\Http\Request;
+use Goldenscarab\Modulus\App\Http\Exports\TrackingExport;
+
+use Maatwebsite\Excel\Facades\Excel;
+use Illuminate\Support\Facades\Session;
+use Illuminate\Support\Facades\Redirect;
+use Goldenscarab\Modulus\App\Http\Repositories\TrackerRepository;
+use Modules\Device\Http\Services\Facades\DeviceService;
+
+class DashboardController extends Controller
+{
+
+    private $tracker_repo;
+
+    public function __construct(TrackerRepository $tracker)
+    {
+        $this->tracker_repo = $tracker;
+    }
+
+
+    /**
+     * Show the application dashboard.
+     *
+     * @return \Illuminate\Http\Response
+     */
+    public function index()
+    {
+        $current_week  = $this->tracker_repo->currentWeek();
+        $current_month = $this->tracker_repo->currentMonth();
+        $last_week     = $this->tracker_repo->lastWeek();
+        $last_month    = $this->tracker_repo->lastMonth();
+        $current_year  = $this->tracker_repo->currentYear();
+        $last_year     = $this->tracker_repo->lastYear();
+
+        // Groupement des visite par mois de l'année courante
+        $current_year_by_month = $current_year->groupBy(function ($item, $key) {
+            return ucfirst($item->created_at->format('m'));
+        });
+
+        // Groupement des visite par mois de l'année courante
+        $last_year_by_month = $last_year->groupBy(function ($item, $key) {
+            return ucfirst($item->created_at->format('m'));
+        });
+
+        return view('back.dashboard.index')->with([
+            'title'                 => "Tableau de bord",
+            'subtitle'              => "Analyse",
+            'current_week'          => $current_week,
+            'current_month'         => $current_month,
+            'current_year'          => $current_year,
+            'current_year_by_month' => $current_year_by_month,
+            'last_week'             => $last_week,
+            'last_month'            => $last_month,
+            'last_year'             => $last_year,
+            'last_year_by_month'    => $last_year_by_month,
+
+        ]);
+    }
+
+    /**
+     * Export des logs sous forme de tableau Excel
+     * @return Download Le fichier Excel d'export
+     */
+    public function export()
+    {
+        return Excel::download(new TrackingExport, date('Ymd_His_') . 'export-tracking.xlsx');
+    }
+
+    /**
+     * Purge le dossier des logs
+     * @return Redirect dashbord
+     */
+    public function truncate()
+    {
+        $this->tracker_repo->truncate();
+
+        Session::flash('success', "Logs effacés avec suucès");
+
+        return Redirect::route('back.dashboard');
+    }
+
+}

src/app/Http/Controllers/Back/ModuleController.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Controllers\Back;
+
+use Illuminate\Support\Str;
+use Illuminate\Http\Request;
+use App\Http\Controllers\Controller;
+
+use Nwidart\Modules\Facades\Module;
+use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Facades\Artisan;
+use Illuminate\Support\Facades\Session;
+use Illuminate\Support\Facades\Redirect;
+use Illuminate\Support\Facades\Response;
+use Goldenscarab\Modulus\App\Http\Repositories\ModuleRepository;
+use Goldenscarab\Modulus\App\Http\Services\Permission\Facade\PermissionService;
+
+
+/**
+ * Controlleur de Modules
+ *
+ *
+ * @author      Sylvain CARRE
+ * @version     v1 Administration des streams à partir de modèles
+ * @copyright   2018 Goldenscarab ©
+ * @license     MIT
+
+ */
+class ModuleController extends Controller
+{
+
+    private $module_repo;
+
+    /**
+     * Constructeur du controller ModuleStreamController
+     */
+    public function __construct(ModuleRepository $module_repo)
+    {
+        $this->module_repo = $module_repo;
+
+        // Définition des permissions par méthode
+        $this->middleware('permission:module-read')->only(['index', 'search']);
+        $this->middleware('permission:module-create')->only(['import']);
+        $this->middleware('permission:module-update')->only(['install', 'uninstall', 'reset']);
+        $this->middleware('permission:module-delete')->only(['delete']);
+
+        view()->share('route_prefix', "back.module");
+        view()->share('can_prefix', "module");
+        view()->share('route_param', current_query_to_string());
+    }
+
+    /**
+     * Méthode par défaut - Affichage de la liste des champs
+     * @return View     Liste des champs
+     */
+    public function index()
+    {
+        // Récupération des champs personnalisé
+        $modules = Module::toCollection();
+
+        // Désactiver les modules non installé
+        $modules->each(function(&$m, $key) {
+            // Recherche de la config du module dans modulus
+            $module = $this->module_repo->findBy('slug', $m->getAlias());
+
+            if (is_null($module)) {
+                $m->disable();
+            }
+        });
+
+        // On supprime de la liste les modules caché
+        $modules = $modules->filter(function($module, $key) {
+            return $module->get('hidden') == false;
+        });
+
+        $breadcrumb = array(
+            'Accueil' => route('back.dashboard'),
+            'Modules' => null
+        );
+
+    	return view('back.module.index')->with([
+            'seo_title'  => 'Module liste',
+            'title'      => '<i class="fa fa-puzzle-piece mr-2"></i>Modules',
+            'subtitle'   => 'Liste des modules disponibles',
+            'breadcrumb' => $breadcrumb,
+            'modules'    => $modules
+    	]);
+    }
+
+
+    public function install($alias)
+    {
+        $module = Module::findOrFail($alias);
+
+        // Le module n'est pas activé on recharge pour prendre en compte la config du module
+        if ($module->isStatus(0)) {
+            $module->enable();
+            return Redirect::route('back.module.install', $alias);
+        }
+
+        // On recherche les autoloads
+        system('composer dump-autoload -d ' . base_path());
+        Artisan::call('config:cache');
+
+        // Migrations des tables du module et semence
+        Artisan::call('module:migrate', ['module' => $module->getName()]);
+        Artisan::call('module:seed', ['module' => $module->getName()]);
+
+        // Configuration dans Modulus
+        $module_config = array(
+            'name'     => $module->getName(),
+            'slug'     => $module->getAlias(),
+            'menu'     => config($module->getAlias() . '.menu'),
+            'priority' => $module->get('priority')
+        );
+
+        $this->module_repo->store(collect($module_config));
+
+        // Ajout des permissions d'accès au module
+        PermissionService::addPermissionsGroup('Module ' . $module->getName());
+
+        Session::flash('success', "Module installé avec succès");
+
+        return Redirect::route('back.module.index');
+    }
+
+    public function uninstall($alias)
+    {
+        // Récupération du module
+        $module = Module::findOrFail($alias);
+
+        // Suppression des migrations des tables du module
+        Artisan::call('module:migrate-rollback', ['module' => $module->getName()]);
+
+        // Suppression de la configuration back office
+        $this->module_repo->destroy($module->getAlias());
+
+        // Suppression des permissions d'accès au module
+        PermissionService::deletePermissionsGroup('Module ' . $module->getName());
+
+        // On désactive le module
+        $module->disable();
+
+        Artisan::call('config:cache');
+
+        Session::flash('success', "Module désinstallé avec succès");
+
+        return Redirect::route('back.module.index');
+    }
+
+    public function refresh($alias)
+    {
+        $module = Module::findOrFail($alias);
+
+        system('composer dump-autoload -d ' . base_path());
+        Artisan::call('config:cache');
+
+        // Suppression de la configuration back office
+        $this->module_repo->destroy($module->getAlias());
+
+        $module_config = array(
+            'name'     => $module->getName(),
+            'slug'     => $module->getAlias(),
+            'menu'     => config($module->getAlias() . '.menu'),
+            'priority' => $module->get('priority')
+        );
+
+        $this->module_repo->store(collect($module_config));
+
+        Session::flash('success', "Module mis à jour avec succès");
+
+        return Redirect::route('back.module.index');
+    }
+
+}

src/app/Http/Controllers/Back/PermissionController.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Controllers\back;
+
+use App\Http\Controllers\Controller;
+use Goldenscarab\Modulus\App\Models\Permission;
+use Illuminate\Http\Request;
+
+use Illuminate\Support\Facades\Session;
+use Illuminate\Support\Facades\Redirect;
+use Goldenscarab\Modulus\App\Http\Requests\PermissionStoreRequest;
+use Goldenscarab\Modulus\App\Http\Repositories\PermissionRepository;
+
+
+class PermissionController extends Controller
+{
+    private $permission_repo;
+
+    public function __construct(PermissionRepository $permission)
+    {
+        $this->permission_repo = $permission;
+
+        $this->middleware('permission:permission-read')->only('index');
+        $this->middleware('permission:permission-create')->only(['create']);
+        $this->middleware('permission:permission-update')->only(['update']);
+        $this->middleware('permission:permission-delete')->only('delete');
+
+        view()->share('route_prefix', "back.user.permission");
+    }
+
+    public function index(Request $request)
+    {
+        // Option de tri de colonne
+        $sorting   = $request->get('sorting', 'id');
+        $direction = $request->get('direction', 'asc');
+        $perpage   = $request->get('perpage', 999);
+
+        $search = $request->get('search');
+
+        $permissions = $this->permission_repo->list($sorting, $direction, $perpage, $search);
+
+        $permissions = $permissions->unique('short_name');
+
+        $breadcrumb = array(
+            'Accueil'      => route('back.dashboard'),
+            'Utilisateurs' => route('back.user.index'),
+            'Permissions'  => null
+        );
+
+    	return view('back.user.permission.list')->with([
+            'title'       => '<i class="fa fa-unlock-alt mr-1" aria-hidden="true"></i>Permissions',
+            'breadcrumb'  => $breadcrumb,
+            'permissions' => $permissions,
+    	]);
+    }
+
+    public function create()
+    {
+        $permission   = $this->permission_repo->new();
+
+        $breadcrumb = array(
+            'Accueil'      => route('back.dashboard'),
+            'Utilisateurs' => route('back.user.index'),
+            'Permissions'  => route('back.user.permission.index'),
+            'Ajouter'      => null
+        );
+
+        return view('back.user.permission.form')->with([
+            'title'        => '<i class="fa fa-unlock-alt mr-1" aria-hidden="true"></i>Permission',
+            'subtitle'     => $permission->display_name,
+            'action'       => '<i class="fa fa-plus mr-2"></i>Ajouter',
+            'breadcrumb'   => $breadcrumb,
+            'item'   => $permission,
+        ]);
+    }
+
+    public function update($id)
+    {
+        $permission   = $this->permission_repo->findOrFail($id);
+
+        $breadcrumb = array(
+            'Accueil'      => route('back.dashboard'),
+            'Utilisateurs' => route('back.user.index'),
+            'Permissions'  => route('back.user.permission.index'),
+            'Modifier'      => null
+        );
+
+        return view('back.user.permission.form')->with([
+            'title'        => '<i class="fa fa-unlock-alt mr-1" aria-hidden="true"></i>Permission',
+            'subtitle'     => $permission->display_name,
+            'action'       => '<i class="fa fa-pencil-square-o mr-2"></i>Modifier',
+            'breadcrumb'   => $breadcrumb,
+            'item'         => $permission,
+        ]);
+    }
+
+    public function store(PermissionStoreRequest $request, $id = null)
+    {
+        $permission_data = collect($request->except(['_token']));
+
+
+        if (is_null($id)) {
+            $base_name = $request->get('name');
+        } else {
+            $permission = $this->permission_repo->find($id);
+            $base_name = $permission->short_name;
+        }
+
+        // Création / mise à jour des enfants de la permission
+        foreach (Permission::getSuffixes() as $suffix => $description) {
+            $name = $base_name . '-' . $suffix;
+            $perm = $this->permission_repo->findBy('name', $name);
+
+            $this->permission_repo->store(collect([
+                'name'         => $request->get('name') . '-' . $suffix,
+                'display_name' => $request->get('display_name') . ' ' . ucfirst($suffix),
+                'description'  => $request->get('description') . ' ' . $description,
+            ]), data_get($perm, 'id'));
+        }
+
+        Session::flash('success', "Permission ". (is_null($id) ? 'créée' : 'modifiée') ." avec succès");
+
+        return Redirect::route('back.user.permission.index');
+    }
+
+    public function delete($id)
+    {
+        $permission = $this->permission_repo->findOrFail($id);
+        $base_name = $permission->short_name;
+
+        foreach (Permission::getSuffixes() as $suffix => $description) {
+            $name = $base_name . '-' . $suffix;
+            $perm = $this->permission_repo->findBy('name', $name);
+            $perm->delete();
+        }
+
+        Session::flash('success', 'Permission supprimée avec succès');
+
+        return Redirect::route('back.user.permission.index');
+    }
+
+}

src/app/Http/Controllers/Back/RoleController.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Controllers\back;
+
+use App\Http\Controllers\Controller;
+use Illuminate\Http\Request;
+
+use Goldenscarab\Modulus\App\Http\Requests\RoleStoreRequest;
+use Illuminate\Support\Facades\Session;
+use Illuminate\Support\Facades\Redirect;
+use Goldenscarab\Modulus\App\Http\Repositories\RoleRepository;
+use Goldenscarab\Modulus\App\Http\Repositories\PermissionRepository;
+
+
+class RoleController extends Controller
+{
+
+    private $role_repo;
+
+    private $permission_repo;
+
+    public function __construct(RoleRepository $role)
+    {
+        $this->role_repo = $role;
+        $this->permission_repo = new PermissionRepository;
+
+        $this->middleware('permission:role-read')->only('index');
+        $this->middleware('permission:role-create')->only(['create']);
+        $this->middleware('permission:role-update')->only(['update']);
+        $this->middleware('permission:role-delete')->only('delete');
+
+        view()->share('route_prefix', "back.user.role");
+    }
+
+    public function index(Request $request)
+    {
+        // Option de tri de colonne
+        $sorting   = $request->get('sorting', 'id');
+        $direction = $request->get('direction', 'asc');
+        $perpage   = $request->get('perpage', 10);
+
+        $search = $request->get('search');
+
+        $roles = $this->role_repo->list($sorting, $direction, $perpage, $search);
+
+        $breadcrumb = array(
+            'Accueil'      => route('back.dashboard'),
+            'Utilisateurs' => route('back.user.index'),
+            'Rôles'        => null
+        );
+
+    	return view('back.user.role.list')->with([
+			'title'        => '<i class="fa fa-tags mr-1" aria-hidden="true"></i>Rôles',
+            'breadcrumb'   => $breadcrumb,
+			'roles'        => $roles,
+    	]);
+    }
+
+    public function create()
+    {
+        $role  = $this->role_repo->new();
+
+        $perms = $this->permission_repo->all();
+
+        $permissions = $this->formatPermissions($perms);
+
+        $breadcrumb = array(
+            'Accueil'      => route('back.dashboard'),
+            'Utilisateurs' => route('back.user.index'),
+            'Rôles'        => route('back.user.role.index'),
+            'Ajouter'      => null
+        );
+
+        return view('back.user.role.form')->with([
+            'title'        => '<i class="fa fa-tags mr-1" aria-hidden="true"></i>Rôle',
+            'action'       => '<i class="fa fa-plus mr-2"></i>Ajouter',
+            'breadcrumb'   => $breadcrumb,
+            'item'         => $role,
+            'permissions'  => $permissions
+        ]);
+    }
+
+    public function update($id)
+    {
+        $role  = $this->role_repo->findOrFail($id);
+
+        $perms = $this->permission_repo->all();
+
+        $permissions = $this->formatPermissions($perms);
+
+        $breadcrumb = array(
+            'Accueil'      => route('back.dashboard'),
+            'Utilisateurs' => route('back.user.index'),
+            'Rôles'        => route('back.user.role.index'),
+            'Modifier'     => null
+        );
+
+        return view('back.user.role.form')->with([
+            'title'        => '<i class="fa fa-tags mr-1" aria-hidden="true"></i>Rôle',
+            'subtitle'     => $role->display_name,
+            'action'       => '<i class="fa fa-pencil-square-o mr-2"></i>Modifier',
+            'breadcrumb'   => $breadcrumb,
+            'item'         => $role,
+            'permissions'  => $permissions
+        ]);
+    }
+
+    private function formatPermissions($perms)
+    {
+         $permissions = [];
+
+        // Traitement sur les permissions
+        $perms->each(function($item, $key) use (&$permissions) {
+
+            // Si la permission est conforme
+            if (preg_match('/-(.[^-]+)$/i', $item->name, $match)) {
+
+                $group = str_replace($match[0], '', $item->name);
+                $perm  = $match[1];
+            } else {
+                $group = $item->name;
+                $perm  = 'other';
+            }
+
+            $name = trim(str_ireplace($perm, '', $item->display_name));
+
+            $permissions[$name][$perm] = $item->id;
+
+        });
+
+        return $permissions;
+    }
+
+    public function store(RoleStoreRequest $request, $id = null)
+    {
+        $role_data = collect($request->except(['_token']));
+
+        $this->role_repo->store($role_data, $id);
+
+        Session::flash('success', "Rôle ". (is_null($id) ? 'crée' : 'modifié') ." avec succès");
+
+        return Redirect::route('back.user.role.index');
+    }
+
+    public function delete($id)
+    {
+        $this->role_repo->destroy($id);
+
+        Session::flash('success', 'Rôle supprimé avec succès');
+
+        return Redirect::route('back.user.role.index');
+    }
+
+}

src/app/Http/Controllers/Back/UserController.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Controllers\back;
+
+use App\Http\Controllers\Controller;
+use Illuminate\Support\Str;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Hash;
+use Illuminate\Support\Facades\Mail;
+use Maatwebsite\Excel\Facades\Excel;
+use Goldenscarab\Modulus\App\Mail\SendActiveAccountRequest;
+use Goldenscarab\Modulus\App\Http\Requests\UserStoreRequest;
+use Illuminate\Support\Facades\Session;
+use Illuminate\Support\Facades\Redirect;
+use Goldenscarab\Modulus\App\Http\Repositories\RoleRepository;
+use Goldenscarab\Modulus\App\Http\Repositories\UserRepository;
+use Goldenscarab\Modulus\App\Http\Requests\ProfileStoreRequest;
+
+
+class UserController extends Controller
+{
+
+    private $user_repo;
+    private $role_repo;
+
+    public function __construct(UserRepository $user)
+    {
+        $this->user_repo = $user;
+        $this->role_repo = new RoleRepository;
+
+        // Définition des permissions par méthode
+        $this->middleware('permission:user-read')->only('index');
+        $this->middleware('permission:user-create')->only('create');
+        $this->middleware('permission:user-update')->only('update');
+        $this->middleware('permission:user-delete')->only('delete');
+
+        view()->share('route_prefix', "back.user");
+    }
+
+    public function index(Request $request)
+    {
+        // Option de tri de colonne
+        $sorting   = $request->get('sorting', 'id');
+        $direction = $request->get('direction', 'asc');
+        $perpage   = $request->get('perpage', 10);
+
+        // Option de Recherche
+        $search = $request->get('search');
+        $role   = $request->get('role');
+
+        // Récupère des listes
+        $users = $this->user_repo->list($sorting, $direction, $perpage, $search, $role);
+        $roles = $this->role_repo->all();
+
+        $breadcrumb = array(
+            'Accueil'      => route('back.dashboard'),
+            'Utilisateurs' => null,
+        );
+
+        return view('back.user.list')->with([
+            'title'        => '<i class="fa fa-users mr-1" aria-hidden="true"></i>Utilisateurs',
+            'breadcrumb'   => $breadcrumb,
+            'users'        => $users,
+            'roles'        => $roles,
+        ]);
+    }
+
+    public function create()
+    {
+        $user   = $this->user_repo->new();
+        $avatars = $this->user_repo->getAvatars();
+        $roles  = $this->role_repo->all();
+
+        $breadcrumb = array(
+            'Accueil'      => route('back.dashboard'),
+            'Utilisateurs' => route('back.user.index'),
+            'Ajouter'      => null
+        );
+
+        return view('back.user.form')->with([
+            'title'      => '<i class="fa fa-users mr-1" aria-hidden="true"></i>Ajouter un utilisateur',
+            'action'     => '<i class="fa fa-plus mr-2"></i>Ajouter',
+            'breadcrumb' => $breadcrumb,
+            'item'       => $user,
+            'avatars'    => $avatars,
+            'roles'      => $roles
+        ]);
+    }
+
+    public function update($id)
+    {
+        $user   = $this->user_repo->findOrfail($id);
+        $avatars = $this->user_repo->getAvatars();
+        $roles  = $this->role_repo->all();
+
+        $breadcrumb = array(
+            'Accueil'      => route('back.dashboard'),
+            'Utilisateurs' => route('back.user.index'),
+            'Modifier'     => null
+        );
+
+        return view('back.user.form')->with([
+            'title'      => '<i class="fa fa-users mr-1" aria-hidden="true"></i>Modifier un utilisateur',
+            'action'     => '<i class="fa fa-pencil-square-o mr-2"></i>Modifier',
+            'breadcrumb' => $breadcrumb,
+            'item'       => $user,
+            'avatars'    => $avatars,
+            'roles'      => $roles
+        ]);
+    }
+
+    public function store(UserStoreRequest $request, $id = null)
+    {
+        // On récupère les données utilisateur
+        $user_data = collect($request->except(['_token']));
+
+        // On sauvegarde les données utilisateur
+        $user = $this->user_repo->store($user_data, $id);
+
+        // Cas d'une création
+        if (is_null($id)) {
+
+            $this->passwordReset($user);
+
+            Session::flash('success', "Utilisateur ajouté avec succès");
+
+            return Redirect::route('back.user.index');
+        }
+
+        Session::flash('success', "Utilisateur modifié avec succès");
+
+        return Redirect::route('back.user.index', $request->query());
+    }
+
+    /**
+     * Export des utilisateurs
+     * @return XLS Fichier Excel
+     */
+    public function export(Request $request)
+    {
+        // Option de tri de colonne
+        $sorting   = $request->get('sorting', 'id');
+        $direction = $request->get('direction', 'desc');
+
+        // Option de Recherche
+        $search = $request->get('search');
+        $role   = $request->get('role');
+        $sector = $request->get('sector');
+        $job    = $request->get('job');
+
+        // Récupère des listes
+        $users = $this->user_repo->list($sorting, $direction, 9999, $search, $role, $sector, $job);
+
+        //Création d'un nom de fichier
+        $file_name = date('Ymd_His_') . 'export-users';
+
+        // Construction du tableau d'export
+        $datas_export = [];
+
+        // Parcours des données
+        foreach ($users as $user) {
+
+            $entrie = [
+                'ID'               => $user->id,
+                'Nom'              => $user->lastname,
+                'Prénom'           => $user->firstname,
+                'E-mail'           => $user->email,
+                'Société'          => $user->company,
+                'Activité'         => $user->activity,
+                'Téléphone'        => $user->telephone,
+                'Adresse'          => $user->address,
+                'Code postal'      => $user->zipcode,
+                'Ville'            => $user->city,
+                'Commentaire'      => $user->comment,
+                'Email validé'     => $user->validated ? 'Oui' : 'Non',
+                'Rôle'             => $user->roles->isEmpty() ? '' : $user->roles->first()->display_name,
+                'Actif'            => $user->active ? 'Oui' : 'Non',
+                'Mis à jour le'    => $user->updated_at->format('d/m/Y H:i:s'),
+                'Créé le'          => $user->created_at->format('d/m/Y H:i:s')
+            ];
+
+            // On ajout la ligne (entrée data) au tableau d'export
+            $datas_export[] = $entrie;
+        }
+
+        // Création du document Excel
+        Excel::create($file_name, function($excel) use ($datas_export) {
+
+            // Paramétrage du tableau Excel
+            $excel->setTitle("Export du ". date('d/m/Y H:i:s'));
+            $excel->setCreator('BMV Communication');
+            $excel->setDescription('');
+
+            // Création d'une nouvelle feuille de calcul
+            $excel->sheet('Utilisateur', function($sheet) use ($datas_export) {
+
+                // Mise en style de la feuille de calcul
+                $sheet->setFontFamily('Arial');
+                $sheet->setFontSize(10);
+
+                // Ajout des données
+                $sheet->fromArray($datas_export, null, 'A1');
+
+                // Ajout d'une ligne d'entête
+                $sheet->prependRow(1, ["Export du ". date('d/m/Y H:i:s')]);
+                $sheet->prependRow(2, [""]);
+
+                // Mise à caractère gras des titres (ligne 3)
+                $sheet->row(3, function($row) {
+                    $row->setFontWeight('bold');
+                });
+
+                $sheet->setFreeze('A4');
+            });
+        })->download('xls');
+
+        exit;
+    }
+
+    public function profil()
+    {
+        $item = auth()->user();
+
+        return view('back.user.profil')->with([
+            'title'    => '<i class="fa fa-user mr-1"></i>Profil utilisateur',
+            'item'     => $item,
+        ]);
+    }
+
+    public function profilPost(ProfileStoreRequest $request)
+    {
+        $data = collect($request->except(['_token']));
+        $user = $this->user_repo->store($data, auth()->user()->id);
+
+        Session::flash('success', "Profil enregistré avec succès");
+
+        return Redirect::back();
+    }
+
+    public function delete($id)
+    {
+        $this->user_repo->destroy($id);
+
+        Session::flash('success', 'Utilisateur supprimé avec succès');
+
+        return Redirect::route('back.user.index');
+    }
+
+    public function sendCreatedAccountMail($id)
+    {
+        $user = $this->user_repo->findOrFail($id);
+
+        $this->passwordReset($user);
+
+        Session::flash('success', 'Mail de création de compte envoyé avec succès');
+
+        return Redirect::route('back.user.index');
+    }
+
+    private function passwordReset($user)
+    {
+        // On génère une nouvelle clée
+        $reset_token = hash_hmac('sha256', Str::random(40), config('app.key'));
+
+        // Ajoute une entrée de regénération de mot de passe
+        DB::table('password_resets')->insert([
+            'email'      => $user->email,
+            'token'      => Hash::make($reset_token),
+            'created_at' => \Carbon\Carbon::now(),
+        ]);
+
+        // On envoi le mail de notification d'activation de compte
+        Mail::to($user->email)->queue(new SendActiveAccountRequest($user, $reset_token));
+    }
+
+}

src/app/Http/Controllers/Front/IndexController.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Controllers\Front;
+
+use Illuminate\Support\Str;
+
+use Illuminate\Http\Request;
+use App\Http\Controllers\Controller;
+use Illuminate\Support\Facades\View;
+use Illuminate\Support\Facades\Route;
+use Illuminate\Support\Facades\Redirect;
+use Goldenscarab\Modulus\App\Jobs\Tracker;
+use Goldenscarab\Modulus\App\Http\Services\Compiler\Facade\CompilerService;
+use Modules\Setting\Http\Services\Facades\SettingService;
+
+
+class IndexController extends Controller
+{
+    public function __construct()
+    {
+        if (request()->route('segment1') == 'extranet') {
+        //if (Route::current()->parameter('segment1') == 'extranet') {
+            $this->middleware('auth');
+        }
+    }
+
+    /**
+     * Methode par defaut pour affichage des différentes vues demandées
+     * @param  String $slug     Slug de la vue demandée (facultatif)
+     * @return View             La vue demandée
+     */
+    public function index($segment1 = null, $segment2 = null, $segment3 = null)
+    {
+        if ($segment1 == str_replace('/', '', SettingService::get('homepage'))) {
+            return Redirect::to('/');
+        }
+
+        $uri =  ($segment1 ? '/' . $segment1 : '') .
+                ($segment2 ? '/' . $segment2 : '') .
+                ($segment3 ? '/' . $segment3 : '');
+
+        if (empty($uri)) {
+            $uri = SettingService::get('homepage');
+        }
+
+        // Recherche d'une surcharge
+        $override_path = 'front.overrides.';
+        $override_name = implode('_', array_filter([$segment1, $segment2, $segment3]));
+        $override_path_name = $override_path . $override_name;
+        if (View::exists($override_path_name)) {
+            return view($override_path_name);
+        }
+
+        CompilerService::createViewIfNotExists($uri);
+
+        // Un peu de tracking
+        dispatch(new Tracker);
+
+        // Chargement de la vue
+        return view(config('modulus.compiled_folder') . Str::slug($uri));
+    }
+}

src/app/Http/Exports/TrackingExport.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Exports;
+
+
+use Goldenscarab\Modulus\App\Http\Repositories\TrackerRepository;
+use Maatwebsite\Excel\Concerns\FromCollection;
+use Maatwebsite\Excel\Concerns\ShouldAutoSize;
+use Maatwebsite\Excel\Concerns\WithHeadings;
+use Maatwebsite\Excel\Concerns\WithEvents;
+use Maatwebsite\Excel\Events\BeforeExport;
+use Maatwebsite\Excel\Events\AfterSheet;
+use Modules\Setting\Http\Services\Facades\SettingService;
+
+
+
+class TrackingExport implements FromCollection, WithHeadings, ShouldAutoSize, WithEvents
+{
+    private $prop_title;
+
+    private $prop_description;
+
+    private $prop_author;
+
+    private $prop_subject;
+
+    private $prop_company;
+
+    private $sheet_title;
+
+    private $sheet_colums;
+
+
+
+	public function __construct()
+    {
+		$this->prop_description = "Export des tracking de visites sur le site ". SettingService::get('site_name');
+		$this->prop_title       = "Tracking visites";
+		$this->prop_author      = SettingService::get('meta_author');
+		$this->prop_subject     = "Export du site web ". SettingService::get('site_name');
+		$this->prop_company     = "Goldenscarab";
+		$this->sheet_title      = 'Traking';
+		$this->sheet_colums     = array(
+            'id'             => 'ID',
+            'ip'             => 'IP',
+            'connected_user' => 'Visiteur',
+            'zip_code'       => 'Code Postal',
+            'city'           => 'Ville',
+            'country_name'   => 'Pays',
+            'latitude'       => 'Latitude',
+            'longitude'      => 'Longitude',
+            'screen_width'   => 'Largeur écran',
+            'screen_height'  => 'Hauteur écran',
+            'created_at'     => 'Date'
+	    );
+    }
+
+    /**
+     * Récupération des données depuis la BDD
+     * @return Collection La liste des données à exporter
+     */
+    public function collection()
+    {
+        $tracker_repo = new TrackerRepository;
+        return $tracker_repo->currentYear(array_keys($this->sheet_colums));
+    }
+
+    /**
+     * Ajout d'une ligne d'entêtes (les titres)
+     * @return array Les titres
+     */
+    public function headings(): array
+    {
+        return array_values($this->sheet_colums);
+    }
+
+    /**
+     * Configuration de la feuille d'export
+     * @return array La config
+     */
+    public function registerEvents(): array
+    {
+        return [
+            BeforeExport::class => function(BeforeExport $event) {
+
+		        // Propriétées du tableau
+		        $event->writer->getProperties()
+		        			  ->setCreator($this->prop_author)
+		        			  ->setLastModifiedBy($this->prop_author)
+		        			  ->setTitle($this->prop_title)
+		        			  ->setSubject($this->prop_subject)
+		        			  ->setCompany($this->prop_company)
+		        			  ->setDescription($this->prop_description);
+		    },
+            AfterSheet::class => function(AfterSheet $event) {
+
+            	// Calcul de la zone des titres
+            	$title_end = chr(65 + count($this->sheet_colums) - 1);
+                $zone_title = sprintf('A1:%s1', $title_end);
+
+                // Style des titres
+                $event->sheet->getDelegate()->getStyle($zone_title)->getFont()->setBold(true);
+
+                // Filtre sur les titres
+                $event->sheet->setAutoFilter($zone_title);
+
+                // Volets verrouillés
+                $event->sheet->freezePane('A2');
+
+                // Titre de l'onglet
+                $event->sheet->setTitle($this->sheet_title);
+            },
+        ];
+    }
+}

src/app/Http/Middleware/Compiler.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Middleware;
+
+use Closure;
+use Illuminate\Support\Facades\Auth;
+use Goldenscarab\Modulus\App\Http\Services\Compiler\Facade\CompilerService;
+use Modules\Setting\Http\Services\Facades\SettingService;
+
+class Compiler
+{
+    /**
+     * Handle an incoming request.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @param  \Closure  $next
+     * @return mixed
+     */
+    public function handle($request, Closure $next, $guard = null)
+    {
+
+        if (SettingService::get('cache') != 1) {
+            CompilerService::clearAll();
+        }
+
+        // Création des différents éléments compilés si manquant
+        CompilerService::createHeaderIfNotExists();
+        CompilerService::createFooterIfNotExists();
+        CompilerService::createFrontCSSIfNotExists();
+        CompilerService::createFrontJSIfNotExists();
+        CompilerService::createBackCSSIfNotExists();
+        CompilerService::createBackJSIfNotExists();
+
+        return $next($request);
+    }
+}

src/app/Http/Middleware/ElfinderFolder.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Middleware;
+
+use Closure;
+
+use Illuminate\Http\Request;
+
+use Illuminate\Support\Facades\File;
+use Illuminate\Support\Facades\Config;
+
+
+class ElfinderFolder
+{
+    /**
+     * Handle an incoming request.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @param  \Closure  $next
+     * @return mixed
+     */
+    public function handle(Request $request, Closure $next)
+    {
+        // Il s'agit d'une campagne
+        if ($request->has('campaign_id')) {
+
+            // Préparation du chemin d'accès aux fichiers
+            $dir_root = 'files/campaigns/';
+            $dir_project = hash('whirlpool', $request->get('campaign_id'));
+            $path_upload = $dir_root . $dir_project;
+
+            // Si le dossier n'existe pas on le créer
+            if (!File::exists(public_path($path_upload))) {
+                File::makeDirectory(public_path($path_upload), 0775, true);
+            }
+
+            // Paramétrage du dossier de travail de elfinder
+            Config::set('elfinder.dir', [ $path_upload ]);
+            Config::set('elfinder.root_options.alias', $request->get('campaign_name'));
+        }
+
+        return $next($request);
+    }
+}

src/app/Http/Middleware/RedirectIfNotActive.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Middleware;
+
+use Closure;
+use Illuminate\Support\Facades\Auth;
+
+class RedirectIfNotActive
+{
+    /**
+     * Handle an incoming request.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @param  \Closure  $next
+     * @return mixed
+     */
+    public function handle($request, Closure $next, $guard = null)
+    {
+        // Vérification que l'utilisateur est bien actif
+        if (Auth::guard($guard)->check() && Auth::guard($guard)->user()->isActive() === false) {
+
+            $email = auth()->user()->email;
+
+            // Si il n'est pas actif, on le déconnecte
+            Auth::logout();
+
+            return redirect('/login')
+                    ->withErrors(['email' => "Ce compte est désactivé"])
+                    ->withInput(['email' => $email]);
+        }
+
+        return $next($request);
+    }
+}

src/app/Http/Repositories/ModuleRepository.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Repositories;
+
+use Goldenscarab\Modulus\App\Models\Module;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\Cache;
+
+
+class ModuleRepository implements RepositoryInterface {
+
+	public function all($columns = array('*'))
+	{
+		return Module::select($columns)->get();
+	}
+
+	public function new()
+	{
+		return new Module;
+	}
+
+	public function published($columns = array('*'))
+	{
+		return false;
+	}
+
+	public function list($filter, $sort = 'asc', $per_page = 15, $search = "")
+	{
+		return Module::search($search)->orderBy($filter, $sort)->paginate($per_page);
+	}
+
+	public function allByPosition()
+	{
+		return Module::orderBy('priority', 'desc')->get();
+	}
+
+	public function store(Collection $data, $id = null)
+	{
+		if (is_null($id)) {
+			$config = new Module;
+		} else {
+			$config = Module::findOrFail($id);
+		}
+
+		$config->name     = $data->get('name');
+        $config->slug     = $data->get('slug');
+        $config->menu     = $data->get('menu');
+        $config->priority = $data->get('priority');
+
+        $config->save();
+
+        Cache::forget('module.configs');
+
+        return $config;
+	}
+
+	public function find($id, $columns = array('*'))
+	{
+		return Module::select($columns)->find($id);
+	}
+
+	public function findOrFail($id, $columns = array('*'))
+	{
+		return Module::select($columns)->findOrFail($id);
+	}
+
+	public function findBy($field, $value, $columns = array('*'))
+	{
+		return Module::select($columns)->where($field, '=', $value)->first();
+	}
+
+	public function findOrFailBy($field, $value, $columns = array('*'))
+	{
+		return Module::select($columns)->where($field, '=', $value)->firstOrFail();
+	}
+
+	public function findAllBy($field, $value, $columns = array('*'))
+	{
+		return Module::select($columns)->where($field, '=', $value)->get();
+	}
+
+	public function findWhere($where, $columns = array('*'))
+	{
+		return Module::select($columns)->whereRaw($where)->get();
+	}
+
+	public function search($search)
+	{
+		return Module::search($search)->orderBy('position', 'asc')->get();
+	}
+
+	public function destroy($slug)
+	{
+        $config = Module::where('slug', $slug)->delete();
+        Cache::forget('module.configs');
+
+		return false;
+	}
+
+	public function first()
+	{
+		return Module::first();
+	}
+
+	public function lasts($limit)
+	{
+		return Module::latest()->limit($limit)->get();
+	}
+
+	public function duplicate($id)
+	{
+		return false;
+	}
+
+	private function calcNextPosition()
+	{
+		$config = Module::orderBy('position', 'desc')->first();
+
+		if (is_null($config)) {
+			return 1;
+		}
+
+		return $config->position + 1;
+	}
+
+}

src/app/Http/Repositories/PermissionRepository.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Repositories;
+
+use Goldenscarab\Modulus\App\Models\Permission;
+use Illuminate\Support\Collection;
+
+
+class PermissionRepository implements RepositoryInterface {
+
+	public function all($columns = array('*'))
+	{
+		return Permission::select($columns)->get();
+	}
+
+	public function new()
+	{
+		return new Permission;
+	}
+
+	public function published($columns = array('*'))
+	{
+		return false;
+	}
+
+	public function list($filter, $sort = 'asc', $per_page = 15, $search = "")
+	{
+		return Permission::where(function($query) use ($search) {
+			if (!empty($search)) {
+				$query->where('name', 'LIKE','%' . $search . '%')
+					  ->orWhere('display_name', 'LIKE','%' . $search . '%')
+					  ->orWhere('description', 'LIKE','%' . $search . '%');
+			}
+		})->orderBy($filter, $sort)->paginate($per_page);
+	}
+
+	public function store(Collection $data, $id = null)
+	{
+		if (is_null($id)) {
+			$permission = new Permission;
+		} else {
+			$permission = Permission::findOrFail($id);
+		}
+
+		$permission->name         = $data->get('name');
+		//$permission->guard_name   = $data->get('guard_name');
+		$permission->display_name = $data->get('display_name');
+		$permission->description  = $data->get('description');
+		$permission->save();
+
+        return $permission;
+	}
+
+	public function find($id, $columns = array('*'))
+	{
+		return Permission::select($columns)->find($id);
+	}
+
+	public function findOrFail($id, $columns = array('*'))
+	{
+		return Permission::select($columns)->findOrFail($id);
+	}
+
+	public function findBy($field, $value, $columns = array('*'))
+	{
+		return Permission::select($columns)->where($field, '=', $value)->first();
+	}
+
+	public function findOrFailBy($field, $value, $columns = array('*'))
+	{
+		return Permission::select($columns)->where($field, '=', $value)->firstOrFail();
+	}
+
+	public function findAllBy($field, $value, $columns = array('*'))
+	{
+		return Permission::select($columns)->where($field, '=', $value)->get();
+	}
+
+	public function findWhere($where, $columns = array('*'))
+	{
+		return Permission::select($columns)->whereRaw($where)->get();
+	}
+
+	public function destroy($id)
+	{
+		return Permission::findOrFail($id)->delete();
+	}
+
+	public function first()
+	{
+		return Permission::first();
+	}
+
+	public function lasts($limit)
+	{
+		return Permission::latest()->limit($limit)->get();
+	}
+
+	public function search($search)
+	{
+		return Permission::search($search)->get();
+	}
+
+	public function truncate()
+	{
+		return Permission::truncate();
+	}
+
+	public function duplicate($id)
+	{
+		return false;
+	}
+}

src/app/Http/Repositories/RepositoryInterface.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Repositories;
+
+use Illuminate\Support\Collection;
+
+interface RepositoryInterface {
+
+	public function all($columns = array('*'));
+
+	public function list($filter, $sort = 'asc', $per_page = 15, $search = "");
+
+	public function published($columns = array('*'));
+
+	public function new();
+
+	public function store(Collection $data, $id);
+
+	public function find($id, $columns = array('*'));
+
+	public function findOrFail($id, $columns = array('*'));
+
+	public function findBy($field, $value, $columns = array('*'));
+
+	public function findOrFailBy($field, $value, $columns = array('*'));
+
+	public function findAllBy($field, $value, $columns = array('*'));
+
+	public function findWhere($where, $columns = array('*'));
+
+	public function first();
+
+	public function lasts($limit);
+
+	public function search($search);
+
+	public function duplicate($id);
+
+	public function destroy($id);
+}

src/app/Http/Repositories/RoleRepository.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Repositories;
+
+use Spatie\Permission\Models\Role;
+use Illuminate\Support\Collection;
+
+
+class RoleRepository implements RepositoryInterface {
+
+	public function all($columns = array('*'))
+	{
+		return Role::select($columns)->get();
+	}
+
+	public function new()
+	{
+		return new Role;
+	}
+
+	public function published($columns = array('*'))
+	{
+		return false;
+	}
+
+	public function list($filter, $sort = 'asc', $per_page = 15, $search = "")
+	{
+		return Role::where(function($query) use ($search) {
+			if (!empty($search)) {
+				$query->where('name', 'LIKE','%' . $search . '%')
+					  ->orWhere('display_name', 'LIKE','%' . $search . '%')
+					  ->orWhere('description', 'LIKE','%' . $search . '%');
+			}
+		})->orderBy($filter, $sort)->paginate($per_page);
+	}
+
+	public function store(Collection $data, $id)
+	{
+		if (is_null($id)) {
+			$role = new Role;
+		} else {
+			$role = Role::findOrFail($id);
+		}
+
+		$role->name         = $data->get('name');
+		//$role->guard_name   = $data->get('guard_name');
+		$role->display_name = $data->get('display_name');
+		$role->description  = $data->get('description');
+
+		$role->save();
+
+		// Si il y a des permissions à activer
+		if ($data->has('permissions')) {
+
+			$role->syncPermissions($data->get('permissions'));
+		}
+
+        return $role;
+	}
+
+	public function find($id, $columns = array('*'))
+	{
+		return Role::with('perms')->select($columns)->find($id);
+	}
+
+	public function findOrFail($id, $columns = array('*'))
+	{
+		return Role::select($columns)->findOrFail($id);
+	}
+
+	public function findBy($field, $value, $columns = array('*'))
+	{
+		return Role::with('perms')->select($columns)->where($field, '=', $value)->first();
+	}
+
+	public function findOrFailBy($field, $value, $columns = array('*'))
+	{
+		return Role::select($columns)->where($field, '=', $value)->firstOrFail();
+	}
+
+	public function findAllBy($field, $value, $columns = array('*'))
+	{
+		return Role::with('perms')->select($columns)->where($field, '=', $value)->get();
+	}
+
+	public function findWhere($where, $columns = array('*'))
+	{
+		return Role::with('perms')->select($columns)->whereRaw($where)->get();
+	}
+
+	public function search($search)
+	{
+		return Role::search($search)->get();
+	}
+
+	public function destroy($id)
+	{
+		return Role::findOrFail($id)->delete();
+	}
+
+	public function first()
+	{
+		return Role::first();
+	}
+
+	public function lasts($limit)
+	{
+		return Role::latest()->limit($limit)->get();
+	}
+
+	public function truncate()
+	{
+		return Role::truncate();
+	}
+
+	public function duplicate($id)
+	{
+		return false;
+	}
+
+}

src/app/Http/Repositories/TrackerRepository.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Repositories;
+
+use Goldenscarab\Modulus\App\Models\Tracker;
+use Illuminate\Support\Collection;
+
+
+class TrackerRepository implements RepositoryInterface {
+
+	public function all($columns = array('*'))
+	{
+		return Tracker::select($columns)->orderBy('id', 'desc')->get();
+	}
+
+	public function list($filter, $sort = 'asc', $per_tracker = 15, $search = "")
+	{
+		return Tracker::search($search)->orderBy($filter, $sort)->paginate($per_tracker);
+	}
+
+	public function published($columns = array('*'))
+	{
+		return Tracker::select($columns)->active()->orderBy('title', 'asc')->get();
+	}
+
+	public function new()
+	{
+		return new Tracker;
+	}
+
+	public function store(Collection $data, $id = null)
+	{
+		if (is_null($id)) {
+			$tracker = new Tracker;
+		} else {
+			$tracker = Tracker::findOrFail($id);
+		}
+
+		$tracker->ip              = $data->get('ip');
+		$tracker->connected_user  = $data->get('connected_user');
+		$tracker->request_uri     = $data->get('request_uri');
+		$tracker->request_method  = $data->get('request_method');
+		$tracker->http_user_agent = $data->get('http_user_agent');
+		$tracker->provider        = $data->get('provider');
+		$tracker->zip_code        = $data->get('zip_code');
+		$tracker->city            = $data->get('city');
+		$tracker->region_name     = $data->get('region_name');
+		$tracker->country_name    = $data->get('country_name');
+		$tracker->latitude        = $data->get('latitude');
+		$tracker->longitude       = $data->get('longitude');
+		$tracker->screen_width    = $data->get('screen_width');
+		$tracker->screen_height   = $data->get('screen_height');
+        $tracker->save();
+
+        return $tracker;
+	}
+
+	public function find($id, $columns = array('*'))
+	{
+		return Tracker::select($columns)->find($id);
+	}
+
+	public function findOrFail($id, $columns = array('*'))
+	{
+		return Tracker::select($columns)->findOrFail($id);
+	}
+
+	public function findBy($field, $value, $columns = array('*'))
+	{
+		return Tracker::select($columns)->where($field, '=', $value)->first();
+	}
+
+	public function findOrFailBy($field, $value, $columns = array('*'))
+	{
+		return Tracker::select($columns)->where($field, '=', $value)->firstOrFail();
+	}
+
+	public function findAllBy($field, $value, $columns = array('*'))
+	{
+		return Tracker::select($columns)->where($field, '=', $value)->get();
+	}
+
+	public function findWhere($where, $columns = array('*'))
+	{
+		return Tracker::select($columns)->whereRaw($where)->get();
+	}
+
+	public function search($search)
+	{
+		return Tracker::search($search)->orderBy('lastname', 'asc')->get();
+	}
+
+	public function destroy($id)
+	{
+		return Tracker::findOrFail($id)->delete();
+	}
+
+	public function first()
+	{
+		return Tracker::first();
+	}
+
+	public function lasts($limit)
+	{
+		return Tracker::latest()->limit($limit)->get();
+	}
+
+	public function truncate()
+	{
+		return Tracker::truncate();
+	}
+
+	public function currentWeek($columns = array('*'))
+	{
+		return Tracker::select($columns)->currentWeek()->orderBy('id', 'desc')->get();
+	}
+
+	public function lastWeek($columns = array('*'))
+	{
+		return Tracker::select($columns)->lastWeek()->orderBy('id', 'desc')->get();
+	}
+
+	public function currentMonth($columns = array('*'))
+	{
+		return Tracker::select($columns)->currentMonth()->orderBy('id', 'asc')->get();
+	}
+
+	public function lastMonth($columns = array('*'))
+	{
+		return Tracker::select($columns)->lastMonth()->orderBy('id', 'asc')->get();
+	}
+
+	public function currentYear($columns = array('*'))
+	{
+		return Tracker::select($columns)->currentMonth()->orderBy('id', 'asc')->get();
+	}
+
+	public function lastYear($columns = array('*'))
+	{
+		return Tracker::select($columns)->lastMonth()->orderBy('id', 'asc')->get();
+	}
+
+	public function duplicate($id)
+	{
+		return false;
+	}
+}

src/app/Http/Repositories/UserRepository.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Repositories;
+
+use Goldenscarab\Modulus\App\Models\User;
+use Illuminate\Support\Str;
+use Illuminate\Support\Collection;
+
+
+class UserRepository implements RepositoryInterface {
+
+	public function all($columns = array('*'))
+	{
+		return User::with('roles')->select($columns)->orderBy('lastname', 'asc')->get();
+	}
+
+	public function list($filter, $sort = 'asc', $per_page = 15, $search = "", $role_id = null)
+	{
+		if ($role_id) {
+
+			return User::whereHas('roles', function($query) use ($role_id) {
+				$query->where('role_id', $role_id);
+			})->search($search)->orderBy($filter, $sort)->paginate($per_page);
+		}
+
+		return User::with('roles')->search($search)->orderBy($filter, $sort)->paginate($per_page);
+	}
+
+	public function published($columns = array('*'))
+	{
+		return User::active()->select($columns)->orderBy('lastname', 'asc')->get();
+	}
+
+	public function new()
+	{
+		return new User;
+	}
+
+	public function store(Collection $data, $id)
+	{
+		if (is_null($id)) {
+            $user = new User;
+		} else {
+			$user = User::findOrFail($id);
+		}
+        $user->api_token = Str::random(60);
+		$user->avatar    = $data->get('avatar');
+		$user->lastname  = $data->get('lastname');
+		$user->firstname = $data->get('firstname');
+		$user->email     = $data->get('email');
+		$user->comment   = $data->get('comment');
+		$user->company   = $data->get('company');
+		$user->activity  = $data->get('activity');
+		$user->telephone = $data->get('telephone');
+		$user->address   = $data->get('address');
+		$user->zipcode   = $data->get('zipcode');
+		$user->city      = $data->get('city');
+
+		// Si le champs active est donné
+		if ($data->has('active')) {
+			$user->active    = $data->get('active');
+		}
+
+		// Si le mot de passe est changé
+		if (!is_null($data->get('password'))) {
+            $user->password  = bcrypt($data->get('password'));
+        }
+
+        $user->save();
+
+        // Changement du role de l'utilisateur
+        if ($data->has('role')) {
+        	$user->syncRoles($data->get('role'));
+        }
+
+        return $user;
+	}
+
+	public function find($id, $columns = array('*'))
+	{
+		return User::with('roles')->select($columns)->find($id);
+	}
+
+	public function findOrFail($id, $columns = array('*'))
+	{
+		return User::select($columns)->findOrFail($id);
+	}
+
+	public function findBy($field, $value, $columns = array('*'))
+	{
+		return User::with('roles')->select($columns)->where($field, '=', $value)->first();
+	}
+
+	public function findOrFailBy($field, $value, $columns = array('*'))
+	{
+		return User::select($columns)->where($field, '=', $value)->firstOrFail();
+	}
+
+	public function findAllBy($field, $value, $columns = array('*'))
+	{
+		return User::with('roles')->select($columns)->where($field, '=', $value)->get();
+	}
+
+	public function findWhere($where, $columns = array('*'))
+	{
+		return User::with('roles')->select($columns)->whereRaw($where)->get();
+	}
+
+	public function search($search)
+	{
+		return User::search($search)->orderBy('lastname', 'asc')->get();
+	}
+
+	public function destroy($id)
+	{
+		return User::findOrFail($id)->delete();
+	}
+
+	public function first()
+	{
+		return User::first();
+	}
+
+	public function lasts($limit)
+	{
+		return User::latest()->limit($limit)->get();
+	}
+
+	public function truncate()
+	{
+		return User::truncate();
+	}
+
+	public function duplicate($id)
+	{
+		return false;
+	}
+
+	public function getAvatars()
+	{
+		return User::getAvatars();
+	}
+
+}

src/app/Http/Requests/LoginRequest.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Requests;
+
+use Illuminate\Auth\Events\Lockout;
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\RateLimiter;
+use Illuminate\Support\Str;
+use Illuminate\Validation\ValidationException;
+
+class LoginRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     *
+     * @return bool
+     */
+    public function authorize()
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array
+     */
+    public function rules()
+    {
+        return [
+            'email' => 'required|string|email',
+            'password' => 'required|string',
+        ];
+    }
+
+    /**
+     * Attempt to authenticate the request's credentials.
+     *
+     * @return void
+     *
+     * @throws \Illuminate\Validation\ValidationException
+     */
+    public function authenticate()
+    {
+        $this->ensureIsNotRateLimited();
+
+        if (! Auth::attempt($this->only('email', 'password'), $this->filled('remember'))) {
+            RateLimiter::hit($this->throttleKey());
+
+            throw ValidationException::withMessages([
+                'email' => __('auth.failed'),
+            ]);
+        }
+
+        RateLimiter::clear($this->throttleKey());
+    }
+
+    /**
+     * Ensure the login request is not rate limited.
+     *
+     * @return void
+     *
+     * @throws \Illuminate\Validation\ValidationException
+     */
+    public function ensureIsNotRateLimited()
+    {
+        if (! RateLimiter::tooManyAttempts($this->throttleKey(), 5)) {
+            return;
+        }
+
+        event(new Lockout($this));
+
+        $seconds = RateLimiter::availableIn($this->throttleKey());
+
+        throw ValidationException::withMessages([
+            'email' => trans('auth.throttle', [
+                'seconds' => $seconds,
+                'minutes' => ceil($seconds / 60),
+            ]),
+        ]);
+    }
+
+    /**
+     * Get the rate limiting throttle key for the request.
+     *
+     * @return string
+     */
+    public function throttleKey()
+    {
+        return Str::lower($this->input('email')).'|'.$this->ip();
+    }
+}

src/app/Http/Requests/PermissionStoreRequest.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class PermissionStoreRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     *
+     * @return bool
+     */
+    public function authorize()
+    {
+        if (empty($this->route('id'))) {
+            return auth()->user()->can('permission-create');
+        } else {
+            return auth()->user()->can('permission-update');
+        }
+
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array
+     */
+    public function rules()
+    {
+
+        return [
+            'name'         => 'required|max:254|string|unique:permissions,name,' . $this->route('id'),
+            'display_name' => 'required|max:254|string',
+            'description'  => 'nullable|max:254|string',
+        ];
+    }
+
+
+    /**
+     * Get custom attributes for validator errors.
+     *
+     * @return array
+     */
+    public function attributes()
+    {
+        return [
+            'name'         => 'Nom',
+            'display_name' => 'Étiquette',
+            'description'  => 'Description',
+        ];
+    }
+}

src/app/Http/Requests/ProfileStoreRequest.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+use Goldenscarab\Modulus\App\Rules\Telephone;
+
+class ProfileStoreRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     *
+     * @return bool
+     */
+    public function authorize()
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array
+     */
+    public function rules()
+    {
+
+        return [
+            'lastname'  => 'required|max:100|string',
+            'firstname' => 'required|max:100|string',
+            'email'     => 'required|email|unique:users,email,' . auth()->user()->id,
+
+            'company'   => 'nullable|max:100|string',
+            'activity'  => 'nullable|max:100|string',
+            'telephone' => ['nullable', 'max:100', new Telephone],
+
+            'address'   => 'nullable|max:254|string',
+            'zipcode'   => 'nullable|max:99999|integer',
+            'city'      => 'nullable|max:100|string',
+            'rgpd'      => 'required|in:1'
+        ];
+    }
+
+
+    /**
+     * Get custom attributes for validator errors.
+     *
+     * @return array
+     */
+    public function attributes()
+    {
+        return [
+            'lastname'  => 'Nom',
+            'firstname' => 'Prénom',
+            'email'     => 'Email',
+
+            'company'   => 'Société',
+            'activity'  => 'Activité',
+            'telephone' => 'Téléphone',
+
+            'address'   => 'Adresse',
+            'zipcode'   => 'Code postal',
+            'city'      => 'Ville',
+            'rgpd'      => 'Règlement Général sur la Protection des Données'
+        ];
+    }
+}

src/app/Http/Requests/RoleStoreRequest.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class RoleStoreRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     *
+     * @return bool
+     */
+    public function authorize()
+    {
+        if (empty($this->route('id'))) {
+            return auth()->user()->can('role-create');
+        } else {
+            return auth()->user()->can('role-update');
+        }
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array
+     */
+    public function rules()
+    {
+
+        return [
+            'name'         => 'required|max:254|string|unique:roles,name,' . $this->route('id'),
+            'display_name' => 'required|max:254|string',
+            'description'  => 'nullable|max:254|string',
+        ];
+    }
+
+
+    /**
+     * Get custom attributes for validator errors.
+     *
+     * @return array
+     */
+    public function attributes()
+    {
+        return [
+            'name'         => 'Nom',
+            'display_name' => 'Étiquette',
+            'description'  => 'Description',
+        ];
+    }
+}

src/app/Http/Requests/UserStoreRequest.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class UserStoreRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     *
+     * @return bool
+     */
+    public function authorize()
+    {
+        // Vérification des droits de création et modification
+        if (empty($this->route('id'))) {
+
+            return auth()->user()->can('user-create');
+
+        } else if (auth()->user()->can('user-update')) {
+
+            return true;
+
+        } else {
+
+            // Autorisé uniquement à son propre profil
+            return (auth()->id == $this->route('id'));
+        }
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array
+     */
+    public function rules()
+    {
+
+        return [
+            'avatar'    => 'string',
+            'lastname'  => 'required|min:3|max:100|string',
+            'firstname' => 'required|min:3|max:100|string',
+            'email'     => 'required|email|unique:users,email,' . $this->route('id'),
+            'role'      => 'array',
+            'comment'   => 'max:250',
+            'password'  => 'required_without:id|between:5,56|nullable',
+            'active'    => 'required_with:role|in:0,1'
+        ];
+    }
+
+
+    /**
+     * Get custom attributes for validator errors.
+     *
+     * @return array
+     */
+    public function attributes()
+    {
+        return [
+            'avatar'    => 'Avatar',
+            'lastname'  => 'Nom',
+            'firstname' => 'Prénom',
+            'comment'   => 'Commentaire',
+            'role'      => 'Role',
+            'password'  => 'Mot de passe',
+            'active'    => 'Actif'
+        ];
+    }
+}

src/app/Http/Services/App/AppService.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Services\App;
+
+use Exception;
+use Throwable;
+use RuntimeException;
+use Illuminate\Support\Facades\Blade;
+
+
+class AppService
+{
+    private $version_file = '.version';
+
+
+	/**
+     * Methode moteur de rendu blade depuis une variable
+     * @param  String $string Chaine à traitée
+     * @param  Array $__data Tableau des données à passer pour le traitement
+     * @return String         La vue parsé
+     */
+    public function bladeRender($string, &$__data = [])
+    {
+        // On compile la chaine de caractère en php
+        $__php = Blade::compileString($string);
+
+        $obLevel = ob_get_level();
+
+        $returned = null;
+
+        ob_start();
+
+        // Importe les variables dans la table des symboles
+        extract($__data, EXTR_SKIP);
+
+        // On tente d'exécuter le code
+        try {
+
+            $returned = eval('?' . '>' . $__php);
+
+        } catch (Exception $e) {
+
+            while (ob_get_level() > $obLevel) ob_end_clean();
+            throw $e;
+
+        } catch (Throwable $e) {
+
+            while (ob_get_level() > $obLevel) ob_end_clean();
+            throw new RuntimeException($e);
+        }
+
+        if (!is_null($returned)) {
+            return $returned;
+        }
+
+        // On retourne la chaine de caractère résultante
+        return ob_get_clean();
+    }
+
+}

src/app/Http/Services/App/Facade/AppService.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Services\App\Facade;
+
+use Illuminate\Support\Facades\Facade;
+
+class AppService extends Facade
+{
+
+
+    protected static function getFacadeAccessor()
+    {
+    	return 'AppService';
+    }
+
+}

src/app/Http/Services/Compiler/CompilerService.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Services\Compiler;
+
+use Illuminate\Support\Str;
+use Illuminate\Support\Facades\File;
+use Goldenscarab\Modulus\App\Http\Repositories\CompilerRepository;
+use Goldenscarab\Modulus\App\Http\Services\Module\Facade\ModuleService;
+use Modules\Menu\Http\Services\Facades\MenuService;
+use Modules\Page\Http\Services\Facades\PageService;
+use Modules\Custom\Http\Services\Facades\CustomService;
+
+
+class CompilerService
+{
+
+	private $front_css_file_name = 'front_compiled.css';
+	private $front_js_file_name  = 'front_compiled.js';
+	private $back_css_file_name  = 'back_compiled.css';
+	private $back_js_file_name   = 'back_compiled.js';
+	private $header_file_name    = '_header.blade.php';
+	private $footer_file_name    = '_footer.blade.php';
+
+    private $compiled_path = null;
+
+    public function __construct()
+    {
+        $this->compiled_path = resource_path('views') . '/' . config('modulus.compiled_folder', 'n/a');
+    }
+
+    /* Views */
+    public function hasView($file_name)
+    {
+    	$path_file = $this->compiled_path . $file_name;
+    	return File::exists($path_file);
+    }
+
+    public function putView($file_name, $content)
+    {
+    	$path_file = $this->compiled_path . $file_name;
+    	File::put($path_file, $content);
+    }
+
+    public function deleteView($file_name)
+    {
+    	$path_file = $this->compiled_path . $file_name;
+    	File::delete($path_file);
+    }
+
+    public function deleteViews()
+    {
+    	$path = $this->compiled_path;
+    	File::cleanDirectory($path);
+    }
+
+    public function createViewIfNotExists($uri)
+    {
+    	$view_name = Str::slug($uri) . '.blade.php';
+
+        // Si le dossier de travail n'existe pas
+        if (!File::isDirectory($this->compiled_path)) {
+            File::makeDirectory($this->compiled_path, 0777, true, true);
+        }
+
+        // Création de la vue compilée
+        if (!$this->hasView($view_name)) {
+            $compiled = PageService::makeCompiledContent($uri);
+            $this->putView($view_name, $compiled);
+        }
+    }
+
+    /* Header */
+    public function hasHeader()
+    {
+    	$path_file = resource_path('views') . '/' . config('modulus.compiled_folder') . $this->header_file_name;
+    	return File::exists($path_file);
+    }
+    public function putHeader($content)
+    {
+    	$path_file = resource_path('views') . '/' . config('modulus.compiled_folder') . $this->header_file_name;
+    	File::put($path_file, $content);
+    }
+    public function deleteHeader()
+    {
+    	$path_file = resource_path('views') . '/' . config('modulus.compiled_folder') . $this->header_file_name;
+    	File::delete($path_file);
+    }
+    public function createHeaderIfNotExists()
+    {
+    	if (!$this->hasHeader()) {
+            $this->putHeader(CustomService::makeCompiledHeader());
+        }
+    }
+
+
+    /* Footer */
+    public function hasFooter()
+    {
+    	$path_file = resource_path('views') . '/' . config('modulus.compiled_folder') . $this->footer_file_name;
+    	return File::exists($path_file);
+    }
+    public function putFooter($content)
+    {
+    	$path_file = resource_path('views') . '/' . config('modulus.compiled_folder') . $this->footer_file_name;
+    	File::put($path_file, $content);
+    }
+    public function deleteFooter()
+    {
+    	$path_file = resource_path('views') . '/' . config('modulus.compiled_folder') . $this->footer_file_name;
+        File::delete($path_file);
+    }
+    public function createFooterIfNotExists()
+    {
+    	if (!$this->hasFooter()) {
+            $this->putFooter(CustomService::makeCompiledFooter());
+        }
+    }
+
+
+    /* CSS */
+    public function hasFrontCSS()
+    {
+    	$path_file = public_path('css') . '/' . $this->front_css_file_name;
+    	return File::exists($path_file);
+    }
+    public function putFrontCSS($content)
+    {
+    	$path_file = public_path('css') . '/' . $this->front_css_file_name;
+    	File::put($path_file, $content);
+    }
+    public function deleteFrontCSS()
+    {
+    	$path_file = public_path('css') . '/' . $this->front_css_file_name;
+    	File::delete($path_file);
+    }
+    public function createFrontCSSIfNotExists()
+    {
+    	if (!$this->hasFrontCSS()) {
+            $css = '';
+            $css .= CustomService::makeCompiledCSS();
+            $css .= PageService::makeCompiledCSS();
+            $css .= MenuService::makeCompiledCSS();
+            $css .= ModuleService::makeCompiledCSSFront();
+            $this->putFrontCSS($css);
+        }
+    }
+
+    public function hasBackCSS()
+    {
+    	$path_file = public_path('css') . '/' . $this->back_css_file_name;
+    	return File::exists($path_file);
+    }
+    public function putBackCSS($content)
+    {
+    	$path_file = public_path('css') . '/' . $this->back_css_file_name;
+    	File::put($path_file, $content);
+    }
+    public function deleteBackCSS()
+    {
+    	$path_file = public_path('css') . '/' . $this->back_css_file_name;
+    	File::delete($path_file);
+    }
+    public function createBackCSSIfNotExists()
+    {
+    	if (!$this->hasBackCSS()) {
+            $css = '';
+            $css .= ModuleService::makeCompiledCSSBack();
+            $this->putBackCSS($css);
+        }
+    }
+
+    /* JS */
+    public function hasFrontJS()
+    {
+    	$path_file = public_path('js') . '/' . $this->front_js_file_name;
+    	return File::exists($path_file);
+    }
+    public function putFrontJS($content)
+    {
+    	$path_file = public_path('js') . '/' . $this->front_js_file_name;
+    	File::put($path_file, $content);
+    }
+    public function deleteFrontJS()
+    {
+    	$path_file = public_path('js') . '/' . $this->front_js_file_name;
+    	File::delete($path_file);
+    }
+    public function createFrontJSIfNotExists()
+    {
+    	if (!$this->hasFrontJS()) {
+            $js = '';
+            $js .= CustomService::makeCompiledJS();
+            $js .= PageService::makeCompiledJS();
+            $js .= MenuService::makeCompiledJS();
+            $js .= ModuleService::makeCompiledJSFront();
+            $this->putFrontJS($js);
+        }
+    }
+    public function hasBackJS()
+    {
+    	$path_file = public_path('js') . '/' . $this->back_js_file_name;
+    	return File::exists($path_file);
+    }
+    public function putBackJS($content)
+    {
+    	$path_file = public_path('js') . '/' . $this->back_js_file_name;
+    	File::put($path_file, $content);
+    }
+    public function deleteBackJS()
+    {
+    	$path_file = public_path('js') . '/' . $this->back_js_file_name;
+    	File::delete($path_file);
+    }
+    public function createBackJSIfNotExists()
+    {
+    	if (!$this->hasBackJS()) {
+            $js = '';
+            $js .= ModuleService::makeCompiledJSBack();
+            $this->putBackJS($js);
+        }
+    }
+
+    public function clearAll()
+    {
+        $this->deleteViews();
+        $this->deleteHeader();
+        $this->deleteFooter();
+        $this->deleteFrontCSS();
+        $this->deleteFrontJS();
+        $this->deleteBackCSS();
+        $this->deleteBackJS();
+    }
+
+}

src/app/Http/Services/Compiler/Facade/CompilerService.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Services\Compiler\Facade;
+
+use Illuminate\Support\Facades\Facade;
+
+class CompilerService extends Facade
+{
+
+
+    protected static function getFacadeAccessor()
+    {
+    	return 'CompilerService';
+    }
+
+}

src/app/Http/Services/Log/Facade/LogService.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Services\Log\Facade;
+
+use Illuminate\Support\Facades\Facade;
+
+class LogService extends Facade
+{
+
+
+    protected static function getFacadeAccessor()
+    {
+    	return 'LogService';
+    }
+
+}

src/app/Http/Services/Log/LogService.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Services\Log;
+
+use Illuminate\Support\Str;
+use Illuminate\Support\Facades\File;
+use Illuminate\Support\Facades\Storage;
+
+class LogService
+{
+    private $base_path = 'logs/';
+
+    private $expire_days = 100;
+
+    public function writeAsText($folder, $file_name, String $string)
+    {
+        $content = $this->makeHeader();
+        $content .= $string;
+
+        $this->storeLog($folder, $string);
+    }
+
+    public function writeAsArray($folder, $data)
+   	{
+        $content = $this->makeHeader();
+        $content .= print_r($data, true);
+
+        $this->storeLog($folder, $content);
+   	}
+
+    public function writeAsJson($folder, $data)
+   	{
+        $content = $this->makeHeader();
+        $content .= json_encode($data, JSON_PRETTY_PRINT) . PHP_EOL;
+
+        $this->storeLog($folder, $content);
+   	}
+
+    private function makePath($folder)
+    {
+        return $this->base_path . $folder . "/";
+    }
+
+    private function makeHeader()
+    {
+        $datetimestamp = \Carbon\Carbon::now()->setTimezone('Europe/Paris')->format('d-m-Y H:i:s');
+        $header  = "===============================================================================" . PHP_EOL;
+   		$header .=  "                            " . $datetimestamp . PHP_EOL;
+        $header .= "===============================================================================" . PHP_EOL;
+
+        return $header;
+    }
+
+    private function checkDir($folder)
+    {
+        $dir = storage_path('app/' . $this->makePath($folder));
+
+        if (!File::isWritable($dir)) {
+            File::makeDirectory($dir,  0777, true);
+        }
+    }
+
+    private function storeLog($folder, $data)
+    {
+        $file = date('Ymd') . '_' . Str::slug($folder) . '.log';
+        $path_name = $this->makePath($folder) . $file;
+        $this->checkDir($folder);
+        Storage::append($path_name, $data);
+   		$this->cleanExpiredLogs($folder);
+    }
+
+    private function cleanExpiredLogs($folder)
+   	{
+   		$absolute_path = storage_path('app/' . $this->makePath($folder));
+   		$command = "find " . $absolute_path . "/*.log -mtime +" . $this->expire_days . " -exec rm {} \; ";
+   		@exec($command);
+    }
+}

src/app/Http/Services/LogTracker/Facade/LogTrackerService.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Services\LogTracker\Facade;
+
+use Illuminate\Support\Facades\Facade;
+
+class LogTrackerService extends Facade
+{
+
+
+    protected static function getFacadeAccessor()
+    {
+    	return 'LogTrackerService';
+    }
+
+}

src/app/Http/Services/LogTracker/LogTrackerService.php

+<?php
+	namespace Goldenscarab\Modulus\App\Http\Services\LogTracker;
+
+	use Illuminate\Support\Collection;
+	use \Carbon\Carbon;
+
+
+	/*
+		 _               _____               _
+		| |    ___   __ |_   _| __ __ _  ___| | _____ _ __
+		| |   / _ \ / _` || || '__/ _` |/ __| |/ / _ \ '__|
+		| |__| (_) | (_| || || | | (_| | (__|   <  __/ |
+		|_____\___/ \__, ||_||_|  \__,_|\___|_|\_\___|_|
+		            |___/
+	 */
+
+	/**
+	 *
+	 * Loggeur de trace
+	 *
+	 * @category   Library
+	 * @package    LogTracker.php
+	 * @author     Sylvain CARRE
+	 * @copyright  2017 Goldenscarab
+	 * @version    v1.0
+	 * @license    MIT
+	 *
+	 */
+
+
+	class LogTrackerService
+	{
+		/* Attributs */
+		private $current_month_log_path_name;
+
+		private $separator = ':;:';
+
+
+		/* Méthodes */
+		public function __construct()
+		{
+			$this->current_month_log_path_name = 'logs/' . date('Y-m') . '_tracker.log';
+		}
+
+		/**
+		 * Ajout d'une ligne au fichier de log avec les informations
+		 * liées à l'ip utilisateur
+		 * @param  Collection $tracker Les données utilisateur
+		 * @return null
+		 */
+		public function save(Collection $tracker)
+		{
+			$data = array(
+                'date'            => date('Y-m-d H:i:s'),
+                'ip'              => $tracker->get('ip'),
+                'user_email'      => $tracker->get('user_email'),
+                'request_uri'     => $tracker->get('request_uri'),
+                'request_method'  => $tracker->get('request_method'),
+                'http_user_agent' => $tracker->get('http_user_agent'),
+                'provider'        => $tracker->get('provider'),
+                'zip_code'        => $tracker->get('zip_code'),
+                'city'            => $tracker->get('city'),
+                'region'          => $tracker->get('region'),
+                'country_name'    => $tracker->get('country_name'),
+                'latitude'        => $tracker->get('latitude'),
+                'longitude'       => $tracker->get('longitude'),
+			);
+
+			// Sauvegarde des données dans le fichier .log avec un séparateur de fin ','
+           \Storage::prepend($this->current_month_log_path_name, implode($this->separator, $data));
+		}
+
+		/**
+		 * Récupère les logs du mois courant
+		 * @return Collection Une collection des logs
+		 */
+		public function getCurrentMonth()
+		{
+			// On récupère les logs du fichier
+			$logs = $this->getLogsContent($this->current_month_log_path_name);
+
+			// On ajoute les logs du mois dans les logs de l'année
+			return $logs;
+		}
+
+		/**
+		 * Récupère les logs du mois dernier
+		 * @return Collection Une collection des logs
+		 */
+		public function getLastMonth()
+		{
+			// Création de la date du mois dernier
+			$last_month_date = Carbon::now()->subMonth()->format('Y-m');
+
+			// Création du nom de fichier log
+			$last_month_log_path_name = 'logs/' . $last_month_date . '_tracker.log';
+
+			// On récupère les logs du fichier
+			$logs = $this->getLogsContent($last_month_log_path_name);
+
+			return $logs;
+
+		}
+
+		/**
+		 * Récupère les dernières 200 IP qui ont visitées l'application
+		 * @return Collection Une collection des logs
+		 */
+		public function getLastIP()
+		{
+			// On récupère les logs du fichier
+			$logs = $this->getLogsContent($this->current_month_log_path_name);
+
+			$log_by_ip = $logs->groupBy('ip')->take(50);
+
+			unset($logs);
+
+			$ips = collect();
+
+			// Mise en forme des logs pour affichage
+			foreach ($log_by_ip as $ip => $logs) {
+
+				// On récupère le dernier log de l'ip
+				$log = $logs->first();
+
+				// Création des données liées à l'ip
+				$data = new \StdClass;
+				$data->ip              = $ip;
+				$data->user            = $log->user_email ? $log->user_email : 'Invité';
+				$data->request_uri     = $log->request_uri;
+				$data->request_method  = $log->request_method;
+				$data->provider        = $log->provider;
+				$data->zip_code        = $log->zip_code;
+				$data->city            = $log->city;
+				$data->region          = $log->region;
+				$data->country         = $log->country_name;
+				$data->latitude        = $log->latitude;
+				$data->longitude       = $log->longitude;
+				$data->http_user_agent = $log->http_user_agent;
+				$data->pages_view      = count($logs);
+				$data->last_activity   = Carbon::createFromFormat('Y-m-d H:i:s', $log->date)->diffForHumans();
+
+
+				$ips->put($ip, $data);
+
+			}
+
+			// On ajoute les logs du mois dans les logs de l'année
+			return $ips;
+		}
+
+		/**
+		 * Récupère les logs de l'année en cours
+		 * @return Collection Une collection des logs
+		 */
+		public function getCurrentYear()
+		{
+			$logs_of_the_year = collect();
+			$current_year     = date('Y');
+
+			// Parcours des mois de l'année en cours
+			for ($month = 1 ; $month <= date('m') ; $month++) {
+
+				// Formatage du mois de l'année
+				$month = sprintf('%02d', $month);
+
+				// Création du chemin vers le log
+				$path_file = 'logs/' . $current_year . '-' . $month . '_tracker.log';
+
+				// On récupère les logs du fichier si il existe
+				$logs = $this->getLogsContent($path_file);
+
+				// On ajoute les logs du mois avec son ondice dans le tableau année
+				$logs_of_the_year->put($month, $logs);
+
+				// On libère de la mémoire
+				unset($logs);
+
+			}
+
+			return $logs_of_the_year;
+		}
+
+		/**
+		 * Récupère les logs de l'année dernière
+		 * @return Collection Une collection des logs
+		 */
+		public function getLastYear()
+		{
+			$logs_of_last_year = collect();
+			$last_year         = Carbon::now()->subYear()->format('Y');
+
+			// Parcours des mois de l'année complète
+			for ($month = 1 ; $month <= 12 ; $month++) {
+
+				// Formatage du mois de l'année
+				$month = sprintf('%02d', $month);
+
+				// Création du chemin vers le log
+				$path_file = 'logs/' . $last_year . '-' . $month . '_tracker.log';
+
+				// On récupère les logs du fichier si il existe
+				$logs = $this->getLogsContent($path_file);
+
+				// On ajoute les logs du mois avec son ondice dans le tableau année
+				$logs_of_last_year->put($month, $logs);
+
+				// On libère de la mémoire
+				unset($logs);
+			}
+
+			return $logs_of_last_year;
+		}
+
+		/**
+		 * Lire un fichier de log depuis son chemin
+		 * @param  String $path_file Le nom avec le chemin vers le fichier
+		 * @return Collection            Les logs du fichier
+		 */
+		private function getLogsContent($path_file)
+		{
+			$logs = collect();
+			// Si le fichier log existe
+			if (\Storage::exists($path_file)) {
+
+				$logs_temp = \Storage::get($path_file);
+
+	        	$cols = array(
+	                'date',
+	                'ip',
+	                'user_email',
+	                'request_uri',
+	                'request_method',
+	                'http_user_agent',
+	                'provider',
+	                'zip_code',
+	                'city',
+	                'region',
+	                'country_name',
+	                'latitude',
+	                'longitude',
+				);
+
+	   			$log_array = $this->getCsvToObject($logs_temp, $cols);
+
+				// Création d'un collection
+				$logs = collect($log_array);
+
+				// On libère de la mémoire
+				unset($log_array, $logs_temp);
+			}
+
+			return $logs;
+		}
+
+
+		public function getCsvToObject($datas, $keys = false)
+		{
+			$tabDataFormat = array(); //Tableau des datas formatées
+
+			$tabDataBrut = explode("\n", $datas);
+
+			foreach ($tabDataBrut as $line) {
+				$datas_line = explode($this->separator, $line);
+
+				$tabDataFormat[] = (object) array_combine($keys, $datas_line);
+			}
+			return $tabDataFormat;
+		}
+
+
+
+		/**
+		 * Supprime de dossier logs contenant les logs de l'application
+		 * @return Boolean Vrai si le dossier est supprimé, Faux s'il n'est pas trouvé
+		 */
+		public static function purge()
+		{
+			return \Storage::deleteDirectory('./logs');
+		}
+	}
+

src/app/Http/Services/Module/Facade/ModuleService.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Services\Module\Facade;
+
+use Illuminate\Support\Facades\Facade;
+
+class ModuleService extends Facade
+{
+    protected static function getFacadeAccessor()
+    {
+    	return 'ModuleService';
+    }
+
+}

src/app/Http/Services/Module/ModuleService.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Services\Module;
+
+use Illuminate\Support\Collection;
+use Nwidart\Modules\Facades\Module;
+use Illuminate\Support\Facades\File;
+use Illuminate\Support\Facades\Cache;
+use Goldenscarab\Modulus\App\Http\Repositories\ModuleRepository;
+
+
+class ModuleService
+{
+
+    private $make_repo;
+
+    private $public_path_files;
+
+    public function __construct()
+    {
+        $this->public_path_files = '/module/upload/';
+    }
+
+    public function getModulesConfig()
+    {
+        $configs = Cache::remember('module.configs', config('cache.expire'), function () {
+
+            $module_repo = new ModuleRepository;
+
+            // Récupération des configs des modules installés
+            $configs = $module_repo->allByPosition();
+
+            return $configs;
+        });
+
+        return $configs;
+
+    }
+
+    public function makeCompiledCSSFront()
+    {
+        // Récupération des modules actifs
+        $modules = Module::collections();
+
+        // Chemin vers le fichiers js concerné
+        $module_assets_path = config('modules.paths.generator.assets.path');
+        $module_js_path = '/css/front.css';
+
+        $content = "";
+
+        // On parcours les modules
+        foreach ($modules as $module) {
+
+            // Construction du chemin vers le fichier js du module
+            $css_file = $module->getPath() . '/' . $module_assets_path . $module_js_path;
+
+            if (File::exists($css_file)) {
+                // Récupération du contenu
+                $content .= "/* *** Module ". $module->name ." *** */ \n";
+                $content .= File::get($css_file);
+                $content .= "\n\n";
+            }
+        }
+
+        return $content;
+    }
+
+    public function makeCompiledCSSBack()
+    {
+        // Récupération des modules actifs
+        $modules = Module::collections();
+
+        // Chemin vers le fichiers js concerné
+        $module_assets_path = config('modules.paths.generator.assets.path');
+        $module_js_path = '/css/back.css';
+
+        $content = "";
+
+        // On parcours les modules
+        foreach ($modules as $module) {
+
+            // Construction du chemin vers le fichier js du module
+            $css_file = $module->getPath() . '/' . $module_assets_path . $module_js_path;
+
+            if (File::exists($css_file)) {
+                // Récupération du contenu
+                $content .= "/* *** Module ". $module->name ." *** */ \n";
+                $content .= File::get($css_file);
+                $content .= "\n\n";
+            }
+        }
+    }
+
+    public function makeCompiledJSFront()
+    {
+        // Récupération des modules actifs
+        $modules = Module::collections();
+
+        // Chemin vers le fichiers js concerné
+        $module_assets_path = config('modules.paths.generator.assets.path');
+        $module_js_path = '/js/front.js';
+
+        $content = "";
+
+        // On parcours les modules
+        foreach ($modules as $module) {
+
+            // Construction du chemin vers le fichier js du module
+            $js_file = $module->getPath() . '/' . $module_assets_path . $module_js_path;
+
+            if (File::exists($js_file)) {
+                // Récupération du contenu
+                $content .= "/* *** Module ". $module->name ." *** */ \n";
+                $content .= File::get($js_file);
+                $content .= "\n\n";
+            }
+        }
+
+        return $content;
+    }
+
+    public function makeCompiledJSBack()
+    {
+        // Récupération des modules actifs
+        $modules = Module::collections();
+
+        // Chemin vers le fichiers js concerné
+        $module_assets_path = config('modules.paths.generator.assets.path');
+        $module_js_path = '/js/back.js';
+
+        $content = "";
+
+        // On parcours les modules
+        foreach ($modules as $module) {
+
+            // Construction du chemin vers le fichier js du module
+            $js_file = $module->getPath() . '/' . $module_assets_path . $module_js_path;
+
+            if (File::exists($js_file)) {
+                // Récupération du contenu
+                $content .= "/* *** Module ". $module->name ." *** */ \n";
+                $content .= File::get($js_file);
+                $content .= "\n\n";
+            }
+        }
+
+        return $content;
+    }
+
+}

src/app/Http/Services/Parser/Facade/ParserService.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Services\Parser\Facade;
+
+use Illuminate\Support\Facades\Facade;
+
+class ParserService extends Facade
+{
+
+
+    protected static function getFacadeAccessor()
+    {
+    	return 'ParserService';
+    }
+
+}

src/app/Http/Services/Parser/Parser.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Services\Parser;
+
+use Goldenscarab\Modulus\App\Http\Services\App\Facade\AppService;
+use Goldenscarab\Modulus\App\Http\Services\Parser\Workers\ParserFactory;
+
+
+class Parser
+{
+	/**
+	 * Liste des tags trouvé dans le contenu à traiter
+	 * @var Array
+	 */
+	private $tags;
+
+	/**
+	 * Tableau associatif entre le tag et son rendu
+	 * @var Array
+	 */
+	private $correlation_table;
+
+	/**
+	 * Regex permettant de trouver les tags
+	 * @var [type]
+	 */
+	private $tag_regex = null;
+
+
+
+	public function __construct()
+	{
+		// Recherche des tags du type : [ mon-tag ]
+		$this->tag_regex = "/\[[\s]([^\]\s]*)[\s]\]/";
+	}
+
+
+	/**
+	 * Traite des données html en recherchant et remplacant les tags trouvés
+	 *    1 - Récupération de la liste des tags présent dans le code
+	 *    2 - Analyse de chaque tags
+	 *    3 - Recherche du worker adapté au tag
+	 *    4 - Traitement du contenu à remplacer
+	 *    5 - Remplacement des tags par leur contenu
+	 *    6 - Remplacement des tags de non rendu
+	 * @param  String $html Contenu html
+	 * @return String       Contenu traité
+	 */
+	public function render($html)
+	{
+		// Niveau de recherche des TAG
+		$search_level = 0;
+
+		// Traitement des tags présents dans le html.
+		// On réitère l'opération tant qu'il y a des tags
+		do {
+
+			$search_level++;
+
+			// Récupération des tags présent dans le code
+			$this->tags = $this->getTagsFromHtml($html, $this->tag_regex);
+
+			// Transmission de la liste des tags à traité à la fabrique
+			// La fabrique doit renvoyer un tableau associatif avec le rendu de chaque tag
+			// Il s'agit de la table de correlation ([tag] => "rendu html")
+			$this->correlation_table = ParserFactory::make($this->tags);
+
+			// Remplacement des tags dans le html, grâce à la table de correlation
+			$this->tagsRendering($this->correlation_table, $html);
+
+		} while (count($this->tags[0]) > 0 && $search_level < 10);
+
+		//\AppService::logLoad("Parser Access");
+
+		// On traite potentiellement le code blade resultant
+		$html = AppService::bladeRender($html);
+
+		$this->replaceTagNoRender($html);
+
+		return $html;
+	}
+
+
+	/**
+	 * Récupère les tags présent dans le code à partir d'une expression régulière
+	 * @param  String $html  Le Html à traiter
+	 * @param  String $regex La regex permettant la d'extraire des tags du code
+	 * @return Array        Tableau des tags présent dans le code
+	 */
+	private function getTagsFromHtml($html, $regex)
+	{
+		$tags = null;
+
+		// Récupération des différents tags présent dans le contenu html
+		preg_match_all($regex, $html, $tags);
+
+		// On renvoi uniquement les tags sans leur carcasse ( [] )
+		return $tags;
+	}
+
+	/**
+	 * Remplace les tags dans le html par le rendu associé
+	 * @param  array $correlation_table  La table de correlation [tag => rendu]
+	 * @param  string $html              Le HTML à traiter
+	 * @return void                      Le traitement est fait par référence
+	 */
+	private function tagsRendering($correlation_table, &$html)
+	{
+
+		// Avant tout on vérifie qu'un tableau à bien été fourni
+		if (is_array($correlation_table)) {
+
+			// On parcours la tableau de correlation pour remplacement
+			foreach ($correlation_table as $tag => $render) {
+
+				// Remplacement du tag par son rendu
+				$html = str_replace($tag, $render, $html);
+			}
+
+		}
+	}
+
+	/**
+	 * Remplace les tags ne devant pas être traité par le parseur
+	 * @param  string &$html Le HTML à traiter
+	 * @return void          Le traitement est fait par référence
+	 */
+	private function replaceTagNoRender(&$html)
+	{
+		$html = str_replace('{#', '{!!', $html);
+		$html = str_replace('#}', '!!}', $html);
+		$html = str_replace('{@}', '@', $html);
+
+		$html = str_replace('<#php', '<?php', $html);
+		$html = str_replace('#>', '?>', $html);
+	}
+}

src/app/Http/Services/Parser/ParserService.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Services\Parser;
+
+
+
+
+class ParserService
+{
+
+	public function render($html)
+	{
+		$parser = new Parser();
+		$html = $parser->render($html);
+
+		return $html;
+	}
+
+}

src/app/Http/Services/Parser/Workers/ParserFactory.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Services\Parser\Workers;
+
+use Symfony\Component\Debug\Exception\FatalThrowableError;
+
+
+class ParserFactory
+{
+	/**
+	 * Délimiter du tag
+	 * @var string
+	 */
+	private static $tag_delimiter = '|';
+
+
+	/**
+	 * Création du rendu associé à un tag
+	 *   1 - Séparation des différentes partie composant le tag -> [ worker.job.method.parameters ]
+	 *   2 - Worker : il s'agit de l'ouvrier qui saura interpréter le restant du tag
+	 *   3 - Job : il s'agit du métier concerné
+	 *   4 - Method : il s'agit de la vue à utiliser dans le métier
+	 *   4 - Param : (Optionnelle), Il s'agit des paramètres à utiliser pour le traitement
+	 * @param  Array $missions 	Liste des tags à traiter
+	 * @return Array       		Tableau associatif : [ tag => rendu ]
+	 */
+	public static function make($missions)
+	{
+
+		// Avant tout on controle que l'on a bien un tableau
+		if (is_array($missions)) {
+
+			$rending = [];
+
+			// Parcours de chaque mission (tags sans les [])
+			foreach ($missions[1] as $key => $mission) {
+
+				$render = "";
+
+				// On étudie la demande
+				$mission_details = explode(self::$tag_delimiter, $mission);
+
+				// Dispatch des données composant la demande
+				$tag_worker = array_shift($mission_details);
+				$tag_job    = array_shift($mission_details);
+				$tag_method = array_shift($mission_details);
+				$tag_params = $mission_details;
+
+				// Construction du nom de l'ouvrier compétent pour traiter la demande
+				$worker_name =  __NAMESPACE__ . "\\Worker" . ucfirst($tag_worker);
+
+				// On vérifie si l'ouvrier est disponible
+				if (class_exists($worker_name)) {
+
+					// Convoquation de l'ouvrier
+					$worker = new $worker_name();
+
+					// On lui donne son ordre de mission (objectif)
+					$worker->setJob($tag_job);
+
+					// On lui donne la methode de travail
+					$worker->setMethod($tag_method);
+
+					// Aller au boulot maintenant, tic tac, tic tac !!!
+					// https://www.youtube.com/watch?v=A70xUvyPA_c
+					$worker->make($tag_params);
+
+					// On récupère le travail effectué
+					$render = $worker->getRender();
+
+					// Création d'une étiquette
+					$label = "<!-- # ". $mission . " # -->\n";
+
+					// Ajout de l'étiquette au travail
+					$render = $label . $render;
+
+				} else {
+
+					// Ohhh No !!! Il n'y a personne qui sait faire cette demande
+					throw new \InvalidArgumentException(":'( - The [$worker_name] worker was not found !");
+				}
+
+				// Classement du travail effectué et on passe à la suite
+				$rending[$missions[0][$key]] = $render;
+			}
+
+		}
+
+		return $rending;
+	}
+
+}

src/app/Http/Services/Parser/Workers/WorkerInterface.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Services\Parser\Workers;
+
+interface WorkerInterface
+{
+
+
+	public function setJob($job);
+
+	public function getJob();
+
+	public function setMethod($job);
+
+	public function getMethod();
+
+	public function getRender();
+
+	public function make($params);
+
+}
+

src/app/Http/Services/Parser/Workers/WorkerModule.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Services\Parser\Workers;
+
+use Illuminate\Support\Facades\Route;
+use Illuminate\Support\Facades\Request;
+
+
+
+/**
+ *  Traitement des tags module
+ */
+class WorkerModule implements WorkerInterface
+{
+
+	/**
+	 * La mission à exécutée
+	 * @var String
+	 */
+	private $job;
+
+	/**
+	 * Stock la methode à utiliser pour exécuter la mission
+	 * @var String
+	 */
+	private $method;
+
+	/**
+	 * Stock le résultat de la mission effectuée
+	 * @var String
+	 */
+	private $render;
+
+
+	public function __construct()
+	{
+
+	}
+
+	/* Accesseurs */
+	public function setJob($job)
+	{
+		$this->job = $job;
+	}
+
+	public function getJob()
+	{
+		return $this->job;
+	}
+
+	public function setMethod($method)
+	{
+		$this->method = $method;
+	}
+
+	public function getMethod()
+	{
+		return $this->method;
+	}
+
+	private function setRender($render)
+	{
+		$this->render = $render;
+	}
+
+	public function getRender()
+	{
+		return $this->render;
+	}
+
+
+	/**
+	 * Traitement de l'ordre de mission
+	 *
+	 * @return String Le contenu html voué à remplacer le tag du parser
+	 */
+	public function make($params = null)
+	{
+		$module_name = $this->getJob();
+		$method_name = $this->getMethod();
+
+		// Construction de l'url vers la vue partielle du module
+		$url = url('/module/'. $module_name . '/' . $method_name . '/' . implode('/', $params));
+
+		// Récupération du rendu de l'url
+		$render = Route::dispatch(Request::create($url, 'GET', array()))->getContent();
+
+		// Mise à jour de la fiche mission
+		$this->setRender($render);
+	}
+
+}
+

src/app/Http/Services/Parser/Workers/WorkerView.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Services\Parser\Workers;
+
+use Modules\Page\Http\Services\Facades\PageService;
+
+
+
+class WorkerView implements WorkerInterface
+{
+
+	/**
+	 * Stocke la mission à exécutée
+	 * @var String
+	 */
+	private $job;
+
+	/**
+	 * Stock la methode à utiliser pour exécuter la mission
+	 * @var String
+	 */
+	private $method;
+
+	/**
+	 * Stocke le résultat de la mission effectuée
+	 * @var Objet de type View
+	 */
+	private $render;
+
+	/**
+	 * Données nécessaire à la construction de la vue
+	 * @var Collection
+	 */
+	private $data;
+
+
+	public function __construct()
+	{
+		// Récolte des données générique du site
+		$this->data = null;
+	}
+
+	/* Accesseurs */
+	public function setJob($job)
+	{
+		$this->job = $job;
+	}
+
+	public function getJob()
+	{
+		return $this->job;
+	}
+
+	public function setMethod($method)
+	{
+		$this->method = $method;
+	}
+
+	public function getMethod()
+	{
+		return $this->method;
+	}
+
+	private function setRender($render)
+	{
+		$this->render = $render;
+	}
+
+	public function getRender()
+	{
+		return $this->render;
+	}
+
+	/********************/
+	/* Méthodes public  */
+	/********************/
+
+	/**
+	 * Traitement de l'ordre de mission
+	 * Tag type correspondant [ view:front.partials.ma-vue ]
+	 * @return String Le contenu html voué à remplacer le tag du parser
+	 */
+	public function make($params = null)
+	{
+		// On récupère l'ordre de mission, charger la vue portant le nom ...
+		$view_name = $this->getJob();
+
+		// On récupère la liste des vues disponibles
+		$views = PageService::getPartialsView($this->data);
+
+		// On récupère le chemin des vues partielles
+		$path_views = PageService::getLaravelPartialViewPath();
+
+		// Recherche approfondi dans la liste des vues disponibles
+		$view = $views->filter(function($view) use ($view_name, $path_views) {
+
+			// Si le nom de la vue correspond, on valide
+			return $view->getName() == $path_views . '.' . $view_name;
+
+		})->first();
+
+		// Mise à jour de la fiche mission
+		$this->setRender($view);
+	}
+
+	/********************/
+	/* Méthodes privées */
+	/********************/
+
+
+}
+

src/app/Http/Services/Permission/Facade/PermissionService.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Services\Permission\Facade;
+
+use Illuminate\Support\Facades\Facade;
+
+class PermissionService extends Facade
+{
+
+
+    protected static function getFacadeAccessor()
+    {
+    	return 'PermissionService';
+    }
+
+}

src/app/Http/Services/Permission/PermissionService.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Http\Services\Permission;
+
+use Illuminate\Support\Str;
+use Goldenscarab\Modulus\App\Http\Repositories\RoleRepository;
+use Goldenscarab\Modulus\App\Http\Repositories\PermissionRepository;
+
+
+class PermissionService
+{
+
+	private $perm_repo;
+	private $role_repo;
+
+	private $types = array(
+			'read'   => 'Lire',
+			'create' => 'Ajouter',
+			'update' => 'Modifier',
+			'delete' => 'Supprimer'
+		);
+
+	public function __construct(PermissionRepository $permission)
+	{
+		$this->perm_repo = $permission;
+		$this->role_repo = new RoleRepository;
+	}
+
+	public function addPermissionsGroup($display_name)
+	{
+		$name = Str::slug($display_name);
+
+		// On vérifie que la permission n'existe pas déja
+		$perm = $this->perm_repo->findBy('name', $name . '-read');
+
+		if($perm) {
+			return false;
+		}
+
+		// On récupère le role admin pour associer les nouvelles permission
+		$role = $this->role_repo->findOrFailBy('name', 'admin');
+
+		// Pour chaque élements du groupe
+		foreach ($this->types as $type => $human_type) {
+			$data = collect([
+				'name'         => $name . '-' . $type,
+				'display_name' => $display_name . ' ' . ucfirst($type),
+				'description'  => $human_type . ' ' . $display_name
+			]);
+
+			// Création de la permission
+			$perm = $this->perm_repo->store($data);
+
+			// Ajout de la permission au role admin
+			if ($perm) {
+				$role->givePermissionTo($perm);
+			}
+
+		}
+
+		return true;
+	}
+
+	public function deletePermissionsGroup($display_name)
+	{
+		// On récupère le role admin pour supprimer les permissions
+		$role_admin = $this->role_repo->findOrFailBy('name', 'admin');
+		$role_edit  = $this->role_repo->findOrFailBy('name', 'editeur');
+
+		// Pour chaque élements du groupe
+		foreach ($this->types as $type => $human_type) {
+
+			// Construction du nom de la permission
+			$name = Str::slug($display_name) . '-' . $type;
+			// Récupération de la permission
+			$perm = $this->perm_repo->findBy('name', $name);
+
+			// Si la permission est trouvée, alors on la supprime
+			if($perm) {
+				$role_admin->revokePermissionTo($perm);
+				$perm->delete();
+			}
+
+		}
+
+		return true;
+	}
+
+}

src/app/Http/Services/User/Facade/UserService.php

+<?php
+
+namespace App\Http\Services\User\Facade;
+
+use Illuminate\Support\Facades\Facade;
+
+class UserService extends Facade
+{
+
+
+    protected static function getFacadeAccessor()
+    {
+    	return 'UserService';
+    }
+
+}

src/app/Http/Services/User/UserService.php

+<?php
+
+namespace App\Http\Services\User;
+
+use App\Http\Repositories\UserRepository;
+
+class UserService
+{
+
+    private $user_repo;
+
+    public function __construct(UserRepository $user_repo)
+    {
+        $this->user_repo = $user_repo;
+    }
+
+    public function all()
+    {
+        return $this->user_repo->all();
+    }
+
+    public function findOrFail($id)
+    {
+        return $this->user_repo->findOrFail($id);
+    }
+
+    public function find($id)
+    {
+        return $this->user_repo->find($id);
+    }
+}

src/app/Jobs/RequestPostTracker.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Jobs;
+
+use Illuminate\Bus\Queueable;
+use Illuminate\Queue\SerializesModels;
+use Illuminate\Queue\InteractsWithQueue;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Foundation\Bus\Dispatchable;
+
+class RequestPostTracker implements ShouldQueue
+{
+    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
+
+    /**
+     * Url du web service de Geolocalisation
+     * @var string
+     */
+    private $template_url = "http://api.ipstack.com/%s?access_key=9eeb980eb6e32fdd5b3c9a72e7cc2e9b&format=1";
+
+
+    private $request;
+
+
+    /**
+     * Create a new job instance.
+     *
+     * @return void
+     */
+    public function __construct($request)
+    {
+        $this->request = $request;
+    }
+
+    /**
+     * Execute the job.
+     *
+     * @return void
+     */
+    public function handle()
+    {
+
+        $ip = \Request::ip();
+        $connected_user = !empty(\Auth::user()) ? \Auth::user()->email : null;
+
+        // On récupère la variable d'environnement serveur
+        $server = collect(\Request::server());
+
+        // Construction des données de log
+        $tracker = array(
+            'ip'              => $ip,
+            'connected_user'  => $connected_user,
+            'request_uri'     => $server->get('REQUEST_URI'),
+            'origin_url'      => $server->get('HTTP_REFERER'),
+            'request_method'  => $server->get('REQUEST_METHOD'),
+            'http_user_agent' => $server->get('HTTP_USER_AGENT'),
+        );
+
+        // Récupération des données geographique de l'ip
+        $url = sprintf($this->template_url, $ip);
+        $geoip  = collect(@json_decode(@file_get_contents($url)));
+
+        if (!$geoip->has('error')) {
+
+            $tracker['zip']          = $geoip->get('zip');
+            $tracker['city']         = $geoip->get('city');
+            $tracker['region_name']  = $geoip->get('region_name');
+            $tracker['country_name'] = $geoip->get('country_name');
+            $tracker['latitude']     = $geoip->get('latitude');
+            $tracker['longitude']    = $geoip->get('longitude');
+        } else {
+            $tracker['error'] = $geoip->get('error');
+        }
+
+        // On sauvegarde les données dans la donnée
+        $this->request->geoloc = $tracker;
+        $this->request->save();
+    }
+}

src/app/Jobs/Tracker.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Jobs;
+
+use Illuminate\Bus\Queueable;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Queue\SerializesModels;
+use Illuminate\Support\Facades\Request;
+use Illuminate\Queue\InteractsWithQueue;
+
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Foundation\Bus\Dispatchable;
+use Goldenscarab\Modulus\App\Http\Repositories\TrackerRepository;
+
+
+
+class Tracker implements ShouldQueue
+{
+    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
+
+    /**
+     * Url du web service de Geolocalisation
+     * @var string
+     */
+    private $template_url = "http://api.ipstack.com/%s?access_key=9eeb980eb6e32fdd5b3c9a72e7cc2e9b&format=1";
+
+    /**
+     * Liste des utilisateurs à ignorer
+     * @var array
+     */
+    private $ignore_role = ['admin', 'editeur'];
+
+
+    /**
+     * Create a new job instance.
+     *
+     * @return void
+     */
+    public function __construct()
+    {
+        //
+    }
+
+    /**
+     * Execute the job.
+     *
+     * @return void
+     */
+    public function handle()
+    {
+        $connected_user = Auth::user();
+
+        // Role à ignorer
+        if (Auth::check() && $connected_user->hasAnyRole($this->ignore_role)) {
+            return false;
+        }
+
+        // Données de connexion
+        $tracker = array(
+            'ip'              => Request::ip(),
+            'connected_user'  => !empty($connected_user) ? $connected_user->email : null,
+            'request_uri'     => Request::server('REQUEST_URI'),
+            'origin_url'      => Request::server('HTTP_REFERER'),
+            'request_method'  => Request::server('REQUEST_METHOD'),
+            'http_user_agent' => Request::server('HTTP_USER_AGENT'),
+            'screen_width'    => $_COOKIE['sw'] ?? null,
+            'screen_height'   => $_COOKIE['sh'] ?? null
+        );
+
+        // Récupération des données geographique de l'ip
+        $url = sprintf($this->template_url, Request::ip());
+        $geoip  = collect(@json_decode(@file_get_contents($url)));
+
+        if (!$geoip->has('error')) {
+
+            $tracker['zip_code']     = $geoip->get('zip');
+            $tracker['city']         = $geoip->get('city');
+            $tracker['region_name']  = $geoip->get('region_name');
+            $tracker['country_name'] = $geoip->get('country_name');
+            $tracker['latitude']     = $geoip->get('latitude');
+            $tracker['longitude']    = $geoip->get('longitude');
+        }
+
+        // Sauvegarde en BDD
+        $traker_repo = new TrackerRepository;
+        $traker_repo->store(collect($tracker));
+    }
+}

src/app/Mails/SendActiveAccountRequest.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Mail;
+
+use Illuminate\Bus\Queueable;
+use Illuminate\Mail\Mailable;
+use Illuminate\Queue\SerializesModels;
+use Illuminate\Contracts\Queue\ShouldQueue;
+
+
+use Goldenscarab\Modulus\App\Models\User;
+
+class SendActiveAccountRequest extends Mailable
+{
+    use Queueable, SerializesModels;
+
+    private $user;
+    private $reset_token;
+
+    /**
+     * Create a new message instance.
+     *
+     * @return void
+     */
+    public function __construct(User $user, $reset_token)
+    {
+        $this->user = $user;
+        $this->reset_token = $reset_token;
+    }
+
+    /**
+     * Build the message.
+     *
+     * @return $this
+     */
+    public function build()
+    {
+        return $this->subject(config('app.name') . " - Création de compte")
+                    ->view('back.user.mail.active_account_html')
+                    ->text('back.user.mail.active_account_txt')
+                    ->with([
+                        'user'        => $this->user,
+                        'reset_token' => $this->reset_token,
+                        'site_name'   => config('app.name')
+                    ]);
+    }
+}

src/app/Mails/SendTest.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Mail;
+
+use Illuminate\Bus\Queueable;
+use Illuminate\Mail\Mailable;
+use Illuminate\Queue\SerializesModels;
+use Illuminate\Contracts\Queue\ShouldQueue;
+
+
+class SendTest extends Mailable
+{
+    use Queueable, SerializesModels;
+
+
+    /**
+     * Create a new message instance.
+     *
+     * @return void
+     */
+    public function __construct()
+    {
+
+    }
+
+    /**
+     * Build the message.
+     *
+     * @return $this
+     */
+    public function build()
+    {
+
+        return $this->subject("Modulus - Test envoi de mail")
+                    ->view('mails.default-html')
+                    ->text('mails.default-txt')
+                    ->with([
+                        'title'      => 'Mail test',
+                        'greeting'   => 'Bonjour !',
+                        'content'    => "Ceci est un mail test.",
+                        'salutation' => 'Cordialement',
+                        'action'     => [
+                            'text' => 'Voir le site web',
+                            'href' => url('/'),
+                        ],
+                    ]);
+    }
+}

src/app/Models/Module.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Models;
+
+use Illuminate\Database\Eloquent\Model;
+
+class Module extends Model
+{
+    protected $searchable = ['name'];
+
+    protected $casts = ['menu' => 'object'];
+
+    // public function getMenuBackAttribute()
+    // {
+    //     if (isset($this->attributes['menu_back'])) {
+    //         return unserialize($this->attributes['menu_back']);
+    //     }
+    // }
+
+    // public function setMenuBackAttribute($content)
+    // {
+    //     $this->attributes['menu_back'] = serialize($content);
+    // }
+
+    // public function getMenuFrontAttribute()
+    // {
+    //     if (isset($this->attributes['menu_front'])) {
+    //         return unserialize($this->attributes['menu_front']);
+    //     }
+    // }
+
+    // public function setMenuFrontAttribute($content)
+    // {
+    //     $this->attributes['menu_front'] = serialize($content);
+    // }
+
+    public function scopeSearch($request, $search)
+    {
+        if (is_null($search)) {
+            return $request;
+        }
+
+        return $request
+            ->where('name',  'LIKE','%' . $search . '%');
+    }
+}

src/app/Models/Permission.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Models;
+
+use Illuminate\Database\Eloquent\Model;
+use Spatie\Permission\Models\Permission as SpatiePermission;
+
+class Permission extends SpatiePermission
+{
+    private static $suffixes = [
+        'read'   => 'Lire',
+        'create' => 'Créer',
+        'update' => 'Modifier',
+        'delete' => 'Supprimer'
+    ];
+
+    public function __contruct()
+    {
+    	parent::__construct();
+    }
+
+    public static function getSuffixes()
+    {
+    	return self::$suffixes;
+    }
+
+    protected function getShortNameAttribute()
+    {
+    	if (!empty($this->attributes['name'])) {
+	    	$name = $this->attributes['name'];
+	    	return trim(str_ireplace(array_keys(self::$suffixes), '', $name), '-');
+	    }
+    }
+
+    protected function getShortDisplaynameAttribute()
+    {
+    	if (!empty($this->attributes['display_name'])) {
+	    	$display_name = $this->attributes['display_name'];
+	    	return trim(str_ireplace(array_keys(self::$suffixes), '', $display_name));
+    	}
+    }
+
+    protected function getShortDescriptionAttribute()
+    {
+    	if (!empty($this->attributes['description'])) {
+	    	$description = $this->attributes['description'];
+	    	return trim(str_ireplace(array_values(self::$suffixes), '', $description));
+    	}
+    }
+
+
+}

src/app/Models/Tracker.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Models;
+
+use Illuminate\Database\Eloquent\Model;
+
+use Illuminate\Database\Eloquent\Builder;
+
+use Carbon\Carbon;
+
+class Tracker extends Model
+{
+
+    /* Relations */
+
+    /* Accesseurs */
+
+    /* Scopes */
+    public function scopeSearch(Builder $query, $search)
+    {
+        if (is_null($search)) {
+            return $query;
+        }
+
+        return $query->where('title', 'LIKE','%' . $search . '%')
+            ->orWhere('slug', 'LIKE','%' . $search . '%')
+            ->orWhere('content', 'LIKE','%' . $search . '%')
+            ->orWhere('comment', 'LIKE','%' . $search . '%');
+    }
+
+    public function scopeCurrentWeek(Builder $query)
+    {
+        $start_week = Carbon::now()->subWeek(1);
+        return $query->where('created_at', '>', $start_week);
+    }
+
+    public function scopeLastWeek(Builder $query)
+    {
+        $start_week = Carbon::now()->subWeek(2);
+        $end_week   = Carbon::now()->subWeek(1);
+        return $query->where('created_at', '>', $start_week)
+                     ->where('created_at', '<', $end_week);
+    }
+
+    public function scopeCurrentMonth(Builder $query)
+    {
+        $start_month = Carbon::now()->subMonth(1);
+        return $query->where('created_at', '>', $start_month);
+    }
+
+    public function scopeLastMonth(Builder $query)
+    {
+        $start_month = Carbon::now()->subMonth(2);
+        $end_month   = Carbon::now()->subMonth(1);
+        return $query->where('created_at', '>', $start_month)
+                     ->where('created_at', '<', $end_month);
+    }
+
+    public function scopeCurrentYear(Builder $query)
+    {
+        $start_year = Carbon::now()->subYear(1);
+        return $query->where('created_at', '>', $start_year);
+    }
+
+    public function scopeLastYear(Builder $query)
+    {
+        $start_year = Carbon::now()->subYear(2);
+        $end_year   = Carbon::now()->subYear(1);
+        return $query->where('created_at', '>', $start_year)
+                     ->where('created_at', '<', $end_year);
+    }
+
+}

src/app/Models/User.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Models;
+
+use Spatie\Permission\Traits\HasRoles;
+use Illuminate\Notifications\Notifiable;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Contracts\Auth\MustVerifyEmail;
+
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Foundation\Auth\User as Authenticatable;
+
+class User extends Authenticatable
+{
+    use HasFactory, Notifiable, HasRoles;
+
+    /**
+     * The attributes that are mass assignable.
+     *
+     * @var array
+     */
+    protected $fillable = [
+        'name',
+        'email',
+        'password',
+    ];
+
+    /**
+     * The attributes that should be hidden for arrays.
+     *
+     * @var array
+     */
+    protected $hidden = [
+        'password',
+        'remember_token',
+    ];
+
+    /**
+     * The attributes that should be cast to native types.
+     *
+     * @var array
+     */
+    protected $casts = [
+        'email_verified_at' => 'datetime',
+    ];
+
+    private static $avatars = [
+        [
+            'label' =>'Homme',
+            'image' => '/images/modulus/man.svg'
+        ],[
+            'label' =>'Femme',
+            'image' => '/images/modulus/woman.svg'
+        ],
+    ];
+
+    protected $appends = ['name'];
+
+    public static function getAvatars()
+    {
+        return self::$avatars;
+    }
+
+    protected function getRoleHtmlAttribute()
+    {
+        $roles = $this->getRoleNames();
+
+        $html = '';
+
+        foreach ($roles as $role) {
+           switch ($role) {
+               case 'admin':
+                   $html .= '<span class="badge badge-danger mr-1">Admin</span>' ;
+                   break;
+                case 'editeur':
+                   $html .= '<span class="badge badge-warning mr-1">Editeur</span>' ;
+                   break;
+               default:
+                   $html .= '<span class="badge badge-secondary mr-1">' . ucfirst($role) . '</span>' ;
+                   break;
+           }
+        }
+
+        return $html;
+    }
+
+    protected function getCreatedAtHtmlAttribute()
+    {
+        return $this->created_at->format('d/m/Y H:i:s');
+    }
+
+    protected function getActiveHtmlAttribute()
+    {
+        if ($this->attributes['active'] == 1) {
+            return '<span class="badge badge-success">Actif<span>';
+        } else {
+            return '<span class="badge badge-default">Inactif<span>';
+        }
+    }
+
+    protected function getNameAttribute()
+    {
+        return $this->attributes['firstname'] . ' ' .  $this->attributes['lastname'];
+    }
+
+    public function scopeSearch(Builder $query, $search)
+    {
+        return $query->where('lastname', 'LIKE','%' . $search . '%')
+            ->orWhere('firstname', 'LIKE','%' . $search . '%')
+            ->orWhere('email', 'LIKE','%' . $search . '%')
+            ->orWhere('comment', 'LIKE','%' . $search . '%');
+    }
+
+    public function isActive()
+    {
+        return $this->attributes['active'] == 1;
+    }
+
+    public function isValidated()
+    {
+        return $this->attributes['validated'] == 1;
+    }
+
+    public function scopeActive($request)
+    {
+        return $request->where('active', 1);
+    }
+}

src/app/Notifications/PasswordReset.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Notifications;
+
+use Illuminate\Bus\Queueable;
+use Illuminate\Notifications\Notification;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Notifications\Messages\MailMessage;
+
+class PasswordReset extends Notification
+{
+    use Queueable;
+
+    /**
+     * Create a new notification instance.
+     *
+     * @return void
+     */
+    public function __construct()
+    {
+        //
+    }
+
+    /**
+     * Get the notification's delivery channels.
+     *
+     * @param  mixed  $notifiable
+     * @return array
+     */
+    public function via($notifiable)
+    {
+        return ['mail'];
+    }
+
+    /**
+     * Get the mail representation of the notification.
+     *
+     * @param  mixed  $notifiable
+     * @return \Illuminate\Notifications\Messages\MailMessage
+     */
+    public function toMail($notifiable)
+    {
+        return (new MailMessage)
+                    ->line('The introduction to the notification.')
+                    ->action('Notification Action', url('/'))
+                    ->line('Thank you for using our application!');
+    }
+
+    /**
+     * Get the array representation of the notification.
+     *
+     * @param  mixed  $notifiable
+     * @return array
+     */
+    public function toArray($notifiable)
+    {
+        return [
+            //
+        ];
+    }
+}

src/app/Providers/ModulusServiceProvider.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Providers;
+
+use Carbon\Carbon;
+
+use Illuminate\Support\Facades\App;
+use Illuminate\Support\Facades\URL;
+use Illuminate\Support\Facades\View;
+use Illuminate\Foundation\AliasLoader;
+use Illuminate\Support\ServiceProvider;
+use Goldenscarab\Modulus\App\Http\Services\Module\Facade\ModuleService;
+
+class ModulusServiceProvider extends ServiceProvider
+{
+    /**
+     * Bootstrap any application services.
+     *
+     * @return void
+     */
+    public function boot()
+    {
+        // Si execution console alors on quitte
+        if (App::runningInConsole()) {
+            return true;
+        }
+
+        // Configuration de Carbon dans la langue locale
+        Carbon::setLocale(config('app.locale'));
+        date_default_timezone_set('Europe/Paris');
+
+        View::composer('*back*', function($view){
+            $view->with('modules_menu', ModuleService::getModulesConfig());
+            //$view->with('route_param', \Request::getQueryString());
+        });
+    }
+
+    /**
+     * Register any application services.
+     *
+     * @return void
+     */
+    public function register()
+    {
+        // Déclaration des services
+        $this->app->bind('AppService', 'Goldenscarab\Modulus\App\Http\Services\App\AppService');
+        $this->app->bind('LogService', 'Goldenscarab\Modulus\App\Http\Services\Log\LogService');
+        $this->app->bind('UserService', 'Goldenscarab\Modulus\App\Http\Services\User\UserService');
+        $this->app->bind('ModuleService', 'Goldenscarab\Modulus\App\Http\Services\Module\ModuleService');
+        $this->app->bind('PermissionService', 'Goldenscarab\Modulus\App\Http\Services\Permission\PermissionService');
+
+        // Déclaration des facades des services
+        $loader = AliasLoader::getInstance();
+        $loader->alias('AppService', 'Goldenscarab\Modulus\App\Http\Services\App\Facade\AppService');
+        $loader->alias('LogService', 'Goldenscarab\Modulus\App\Http\Services\Log\Facade\LogService');
+        $loader->alias('UserService', 'Goldenscarab\Modulus\App\Http\Services\User\Facade\UserService');
+        $loader->alias('ModuleService', 'Goldenscarab\Modulus\App\Http\Services\Module\Facade\ModuleService');
+        $loader->alias('PermissionService', 'Goldenscarab\Modulus\App\Http\Services\Permission\Facade\PermissionService');
+    }
+}

src/app/Providers/RouteServiceProvider.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Providers;
+
+
+use Illuminate\Support\Facades\Route;
+use Illuminate\Foundation\Support\Providers\RouteServiceProvider as ServiceProvider;
+
+class RouteServiceProvider extends ServiceProvider
+{
+    public const HOME = '/backend';
+
+    private $base_namespace = 'Goldenscarab\\Modulus\\App\\Http\\Controllers';
+
+    /**
+     * Bootstrap any application services.
+     *
+     * @return void
+     */
+    public function boot()
+    {
+        $this->routes(function () {
+            Route::prefix('api')
+                ->middleware('api')
+                ->namespace($this->base_namespace)
+                ->group(__DIR__ . '../routes/api.php');
+
+            Route::middleware(['web', 'compiler'])
+                ->namespace($this->base_namespace)
+                ->group(__DIR__ . '../routes/web.php');
+        });
+    }
+
+    /**
+     * Register any application services.
+     *
+     * @return void
+     */
+    public function register()
+    {
+
+    }
+}

src/app/Rules/AntiRobotName.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Rules;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class AntiRobotName implements Rule
+{
+    /**
+     * Create a new rule instance.
+     *
+     * @return void
+     */
+    public function __construct()
+    {
+        //
+    }
+
+    /**
+     * Determine if the validation rule passes.
+     *
+     * @param  string  $attribute
+     * @param  mixed  $value
+     * @return bool
+     */
+    public function passes($attribute, $value)
+    {
+        // On controle que le champs est bien null
+		return  preg_match('/^$/', $value) == 1;
+    }
+
+    /**
+     * Get the validation error message.
+     *
+     * @return string
+     */
+    public function message()
+    {
+        return '<i class="fa fa-android mr-1" aria-hidden="true"></i>L\'application vous à détecté comme étant un robot';
+    }
+}

src/app/Rules/AntiRobotTime.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Rules;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class AntiRobotTime implements Rule
+{
+    private $time;
+
+    /**
+     * Create a new rule instance.
+     *
+     * @return void
+     */
+    public function __construct($time)
+    {
+        $this->time = $time;
+    }
+
+    /**
+     * Determine if the validation rule passes.
+     *
+     * @param  string  $attribute
+     * @param  mixed  $value
+     * @return bool
+     */
+    public function passes($attribute, $value)
+    {
+        // Calcul du temps entre la construction du formulaire et du post
+		$timestamp_form = decrypt($value);
+		$timestamp_post = time();
+
+		$delay_limit    = intVal($this->time);
+		$delay_post     = ($timestamp_post - $timestamp_form);
+
+		// Si le delta temps est inférieur à la limite, alors il s'agit d'un robot
+		return $delay_post > $delay_limit;
+    }
+
+    /**
+     * Get the validation error message.
+     *
+     * @return string
+     */
+    public function message()
+    {
+        return '<i class="fa fa-android mr-1" aria-hidden="true"></i>L\'application vous à détecté comme étant un robot';
+    }
+}

src/app/Rules/GPSCoordinate.php

+<?php
+
+namespace Goldenscarab\Modulus\App\Rules;
+
+use Illuminate\Contracts\Validation\Rule;
+
+class GPSCoordinate implements Rule
+{
+    /**
+     * Create a new rule instance.
+     *
+     * @return void
+     */
+    public function __construct()
+    {
+        //
+    }
+
+    /**
+     * Determine if the validation rule passes.
+     *
+     * @param  string  $attribute
+     * @param  mixed  $value
+     * @return bool
+     */
+    public function passes($attribute, $value)
+    {
+        return preg_match('#^(-?\d{1,3}\.\d{6,7})$#', $value) === 1;
+    }
+
+    /**
+     * Get the validation error message.
+     *
+     * @return string
+     */
+    public function message()
+    {
+        return 'Le champs :attribute doit être une coordonnée GPS valide. ex : 43.897312';
+    }
+}

Helpers @ e36af6a1

+Subproject commit e36af6a11300e71d364fe8fabdfa731ee9aff7da

components @ d6fef3bf

+Subproject commit d6fef3bf4390bf332d336043f7e82397b84edc37

src/resources/lang/vendor/cookieConsent/ar/texts.php

+<?php
+
+return [
+    'message' => 'سيتم تحسين تجربتنا على هذا الموقع من خلال السماح بملفات تعريف الارتباط',
+    'agree' => 'السماح',
+];