cleanups

speedtest/volumes/config/www/app/Http/Controllers/AuthController.php

@@ -0,0 +1,253 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Models\Auth\EmailVerification;
+use App\Models\Auth\LoginSession as AuthLoginSession;
+use App\Helpers\EmailVerificationHelper;
+use Illuminate\Support\Facades\Auth;
+use App\Http\Controllers\Controller;
+use App\LoginSession;
+use App\Rules\CurrentPasswordMatches;
+use App\Models\User;
+use DateTime;
+use Hash;
+use Illuminate\Support\Facades\Request as RequestFacade;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Validator;
+use Log;
+use Ramsey\Uuid\Uuid;
+
+class AuthController extends Controller
+{
+    /**
+     * Create a new AuthController instance.
+     *
+     * @return void
+     */
+    public function __construct()
+    {
+        $this->middleware('auth:api', ['except' => ['login', 'register']]);
+    }
+
+    public function register(Request $request)
+    {
+        $validator = Validator::make($request->all(), User::registerRules());
+
+        if($validator->fails()) {
+            return response()->json([
+                'error' => $validator->errors()
+            ], 422);
+        }
+
+        $user = User::create([
+            'id' => Uuid::uuid4(),
+            'name' => $request->name,
+            'email' => $request->email,
+            'password' => $request->password,
+        ]);
+
+        EmailVerification::create([
+            'user_id' => $user->id,
+            'token' => UUid::uuid4(),
+            'expires' => new DateTime('+ 1 day')
+        ]);
+
+        $token = auth()->login($user);
+
+        return $this->respondWithToken($token);
+    }
+
+    /**
+     * Get a JWT via given credentials.
+     *
+     * @return \Illuminate\Http\JsonResponse
+     */
+    public function login(Request $request)
+    {
+        $validator = Validator::make($request->all(), User::loginRules());
+
+        if($validator->fails()) {
+            return response()->json([
+                'error' => $validator->errors()
+            ], 422);
+        }
+
+        $credentials = request(['email', 'password']);
+
+        $length = 1440 * env('REMEMBER_TOKEN', 30);
+        if (! $token = auth()->setTTL($length)->attempt($credentials)) {
+            return response()->json(['error' => 'Unauthorized'], 401);
+        }
+
+        return $this->respondWithToken($token, $length);
+    }
+
+    /**
+     * Get the authenticated User.
+     *
+     * @return \Illuminate\Http\JsonResponse
+     */
+    public function me()
+    {
+        return response()->json(auth()->user());
+    }
+
+    /**
+     * Log the user out (Invalidate the token).
+     *
+     * @return \Illuminate\Http\JsonResponse
+     */
+    public function logout(Request $request)
+    {
+        $session = auth()->user()->sessions()->where('token', $request->token)->first();
+        $session->active = false;
+        $session->save();
+
+        auth()->logout();
+
+        return response()->json(['message' => 'Successfully logged out']);
+    }
+
+    /**
+     * Refresh a token.
+     *
+     * @return \Illuminate\Http\JsonResponse
+     */
+    public function refresh(Request $request)
+    {
+        $session = auth()->user()->sessions()->where('token', $request->token)->first();
+        $session->active = false;
+        $session->save();
+
+        return $this->respondWithToken(auth()->refresh());
+    }
+
+    /**
+     * Get the token array structure.
+     *
+     * @param  string $token
+     *
+     * @return \Illuminate\Http\JsonResponse
+     */
+    protected function respondWithToken($token, $expiresIn = false)
+    {
+        if(!$expiresIn) {
+            $expiresIn = 1440 * env('REMEMBER_TOKEN', 30);
+        }
+        $expiresTime = date("Y-m-d H:i:s", time() + ($expiresIn * 60));
+
+        $expiresUnix = time() + ($expiresIn * 60);
+
+        $this->storeSession($token, $expiresUnix);
+
+        return response()->json([
+            'access_token' => $token,
+            'expires_in' => $expiresIn,
+            'expires_on' => $expiresUnix,
+            'expires_on_readable' => $expiresTime
+        ]);
+    }
+
+    function storeSession($token, $expires)
+    {
+        AuthLoginSession::create([
+            'id' => Uuid::uuid4(),
+            'token' => $token,
+            'user_id' => auth()->user()->id,
+            'expires' => $expires,
+            'ip' => RequestFacade::ip()
+        ]);
+    }
+
+    public function getSessions()
+    {
+        $sessions = auth()->user()->sessions()->where([
+            [ 'active', true ],
+            [ 'expires', '>', time() ]
+        ])->get();
+
+        $sessions = $sessions->map(function ($item) {
+            return collect($item)->forget(['token']);
+        });
+
+        return response()->json([
+            'method' => 'get auth sessions',
+            'response' => $sessions
+        ], 200);
+    }
+
+    public function deleteSession($id)
+    {
+        $session = AuthLoginSession::where('id', $id)->firstOrFail();
+        $session->delete();
+
+        return response()->json([
+            'method' => 'delete a login sesison',
+            'response' => $session->id
+        ], 200);
+    }
+
+    public function verifyEmail(Request $request)
+    {
+        $rules = [
+            'user_id' => [ 'string', 'required' ],
+            'token' => [ 'string', 'required' ],
+        ];
+
+        $validator = Validator::make($request->all(), $rules);
+        if($validator->fails()) {
+            return response()->json([
+                'error' => $validator->errors()
+            ], 422);
+        }
+
+        $user = EmailVerificationHelper::checkVerificationAttempt($request->user_id, $request->token);
+
+        if(!$user) {
+            return response()->json([
+                'error' => 'token nout found'
+            ], 404);
+        }
+
+        $user->email_verified_at = new DateTime();
+        $user->save();
+
+        return response()->json([
+            'method' => 'verify email address',
+            'success' => true,
+        ], 200);
+    }
+
+    public function changePassword(Request $request)
+    {
+        $rules = [
+            'currentPassword' => [ 'string', 'required', new CurrentPasswordMatches() ],
+            'newPassword' => [ 'required', 'string', 'confirmed', 'min:8' ],
+            'logoutDevices' => [ 'required', 'bool' ]
+        ];
+
+        $validator = Validator::make($request->all(), $rules);
+        if($validator->fails()) {
+            return response()->json([
+                'method' => 'reset password',
+                'success' => false,
+                'error' => $validator->errors()
+            ], 403);
+        }
+
+        $user = Auth::user();
+
+        $user->password = $request->newPassword;
+        $user->save();
+
+        if($request->logoutDevices == true) {
+            AuthLoginSession::where('user_id', $user->id)->update([ 'active' => false ]);
+        }
+
+        return response()->json([
+            'method' => 'reset password',
+            'success' => true
+        ], 200);
+    }
+}

speedtest/volumes/config/www/app/Http/Controllers/BackupController.php

@@ -0,0 +1,75 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Helpers\BackupHelper;
+use App\Helpers\SettingsHelper;
+use DateTime;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Storage;
+use Illuminate\Support\Facades\Validator;
+use Illuminate\Http\JsonResponse;
+
+class BackupController extends Controller
+{
+
+    public function __construct()
+    {
+        if((bool)SettingsHelper::get('auth')->value === true) {
+            $this->middleware('auth:api');
+        }
+    }
+
+    /**
+     * Get backup of speedtests
+     *
+     * @param   Request $request
+     * @return  mixed|JsonResponse
+     */
+    public function backup(Request $request)
+    {
+        $validator = Validator::make($request->all(), [ 'format' => 'in:json,csv' ]);
+        if($validator->fails()) {
+            return response()->json([
+                'method' => 'backup data',
+                'error' => $validator->errors(),
+            ], 422);
+        }
+
+        $filename = BackupHelper::backup($request->format);
+
+        return Storage::disk('local')->download($filename);
+    }
+
+    /**
+     * Retore from a backup
+     *
+     * @param   Request $request
+     * @return  JsonResponse
+     */
+    public function restore(Request $request)
+    {
+        $rule = [
+            'data' => [ 'required' ],
+            'format' => [ 'required', 'in:json,csv' ]
+        ];
+
+        $validator = Validator::make($request->all(), $rule);
+
+        if($validator->fails()) {
+            return response()->json([
+                'error' => $validator->errors()
+            ], 422);
+        }
+
+        if(BackupHelper::restore($request->data, $request->format) != false) {
+            return response()->json([
+                'method' => 'restore data from backup',
+            ], 200);
+        } else {
+            return response()->json([
+                'method' => 'incorrect backup format',
+            ], 422);
+        }
+    }
+}

speedtest/volumes/config/www/app/Http/Controllers/Controller.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
+use Illuminate\Foundation\Bus\DispatchesJobs;
+use Illuminate\Foundation\Validation\ValidatesRequests;
+use Illuminate\Routing\Controller as BaseController;
+
+class Controller extends BaseController
+{
+    use AuthorizesRequests, DispatchesJobs, ValidatesRequests;
+}

speedtest/volumes/config/www/app/Http/Controllers/HomepageDataController.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Actions\GetFailedSpeedtestData;
+use App\Actions\GetLatestSpeedtestData;
+use App\Actions\GetSpeedtestTimeData;
+use App\Helpers\SettingsHelper;
+use Illuminate\Http\Request;
+use Validator;
+
+class HomepageDataController extends Controller
+{
+    public function __invoke($days)
+    {
+        $validator = Validator::make(
+            ['days' => $days],
+            ['days' => ['required', 'numeric']],
+        );
+
+        if ($validator->fails()) {
+            return response()->json([
+                'method' => 'get speedtests in last x days',
+                'error' => $validator->errors(),
+            ], 422);
+        }
+
+        return [
+            'latest' => run(GetLatestSpeedtestData::class),
+            'time' => run(GetSpeedtestTimeData::class),
+            'fail' => run(GetFailedSpeedtestData::class),
+            'config' => SettingsHelper::getConfig(),
+        ];
+    }
+}

speedtest/volumes/config/www/app/Http/Controllers/IntegrationsController.php

@@ -0,0 +1,84 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Helpers\SettingsHelper;
+use Exception;
+use Healthcheck;
+use Henrywhitaker3\Healthchecks\Exceptions\HealthchecksUuidNotFoundException;
+use Henrywhitaker3\Healthchecks\Healthchecks;
+use Illuminate\Http\Request;
+use Illuminate\Http\JsonResponse;
+use Ramsey\Uuid\Exception\InvalidUuidStringException;
+
+class IntegrationsController extends Controller
+{
+    public function __construct()
+    {
+        if((bool)SettingsHelper::get('auth')->value === true) {
+            $this->middleware('auth:api');
+        }
+    }
+
+    /**
+     * Test the healthchecks config
+     *
+     * @return JsonResponse
+     */
+    public function testHealthchecks(String $method)
+    {
+        $methodResp = 'test healthchecks \'' . $method . '\' endpoint';
+
+        try {
+            // SettingsHelper::loadIntegrationConfig();
+            if($method == 'success') {
+                Healthcheck::success();
+            }
+
+            if($method == 'fail') {
+                Healthcheck::fail();
+            }
+
+            if($method == 'start') {
+                Healthcheck::start();
+            }
+
+            return response()->json([
+                'method' => $methodResp,
+                'success' => true
+            ], 200);
+        } catch(InvalidUuidStringException $e) {
+            return response()->json([
+                'method' => $methodResp,
+                'success' => false,
+                'error' => 'Invalid UUID'
+            ], 422);
+        } catch(HealthchecksUuidNotFoundException $e) {
+            return response()->json([
+                'method' => $methodResp,
+                'success' => false,
+                'error' => 'UUID not found'
+            ], 404);
+        } catch(Exception $e) {
+            return response()->json([
+                'method' => $methodResp,
+                'success' => false,
+                'error' => $e->getMessage()
+            ], 422);
+        }
+    }
+
+    /**
+     * Trigger a test of all notification agents
+     *
+     * @return JsonResponse
+     */
+    public function testNotification()
+    {
+        SettingsHelper::testNotification();
+
+        return response()->json([
+            'method' => 'test notification agents'
+        ], 200);
+    }
+}

speedtest/volumes/config/www/app/Http/Controllers/SettingsController.php

@@ -0,0 +1,145 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Helpers\SettingsHelper;
+use App\Rules\Cron;
+use App\Models\Setting;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Log;
+use Illuminate\Support\Facades\Validator;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Support\Collection;
+
+class SettingsController extends Controller
+{
+    public function __construct()
+    {
+        if ((bool)SettingsHelper::get('auth')->value === true) {
+            $this->middleware('auth:api')
+                ->except(['config']);
+        }
+    }
+
+    /**
+     * Return all settings
+     *
+     * @return  Collection
+     */
+    public function index()
+    {
+        return Setting::get()->keyBy('name');
+    }
+
+    /**
+     * Get setting by id
+     *
+     * @param   Setting $setting
+     * @return  Setting
+     */
+    public function get(Setting $setting)
+    {
+        return $setting;
+    }
+
+    /**
+     * Store/update a setting
+     *
+     * @param   Request $request
+     * @return  JsonResponse
+     */
+    public function store(Request $request)
+    {
+        $rule = [
+            'name' => ['required', 'string', 'min:1'],
+        ];
+        if ($request->name == 'schedule') {
+            $rule['value'] = ['required', new Cron];
+        }
+
+        $validator = Validator::make($request->all(), $rule);
+        if ($validator->fails()) {
+            return response()->json([
+                'method' => 'Store a setting',
+                'error' => $validator->errors()
+            ], 422);
+        }
+
+        if (!isset($request->value)) {
+            $request->value = '';
+        }
+
+        $setting = SettingsHelper::set($request->name, $request->value);
+
+        return response()->json([
+            'method' => 'Store a setting',
+            'data' => $setting
+        ], 200);
+    }
+
+    /**
+     * Bulk store/update a setting
+     *
+     * @param   Request $request
+     * @return  JsonResponse
+     */
+    public function bulkStore(Request $request)
+    {
+        $rule = [
+            'data' => ['array', 'required'],
+            'data.*.name' => ['string', 'required'],
+        ];
+
+        $validator = Validator::make($request->all(), $rule);
+        if ($validator->fails()) {
+            return response()->json([
+                'method' => 'Bulk store a setting',
+                'error' => $validator->errors()
+            ], 422);
+        }
+
+        $settings = [];
+        foreach ($request->data as $d) {
+            if (!isset($d['value']) || $d['value'] == null) {
+                $d['value'] = '';
+            }
+
+            if ($d['name'] == 'speedtest_overview_time') {
+                $ok = ['00', '01', '02', '03', '04', '05', '06', '07', '08', '09', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '21', '22', '23'];
+                if (!in_array($d['value'], $ok)) {
+                    return response()->json([
+                        'method' => 'Bulk store a setting',
+                        'error' => 'Invalid speedtest_overview_time value'
+                    ], 422);
+                }
+            }
+
+            $setting = SettingsHelper::get($d['name']);
+
+            if ($setting == false) {
+                $setting = SettingsHelper::set($d['name'], $d['value']);
+            } else if (SettingsHelper::settingIsEditable($setting->name)) {
+                $setting = SettingsHelper::set($d['name'], $d['value']);
+            } else {
+                continue;
+            }
+
+            array_push($settings, $setting);
+        }
+
+        return response()->json([
+            'method' => 'Bulk store a setting',
+            'data' => $settings,
+        ], 200);
+    }
+
+    /**
+     * Returns instance config
+     *
+     * @return  array
+     */
+    public function config()
+    {
+        return SettingsHelper::getConfig();
+    }
+}

speedtest/volumes/config/www/app/Http/Controllers/SpeedtestController.php

@@ -0,0 +1,188 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Actions\GetFailedSpeedtestData;
+use App\Actions\GetLatestSpeedtestData;
+use App\Actions\GetSpeedtestTimeData;
+use App\Actions\QueueSpeedtest;
+use App\Helpers\SettingsHelper;
+use App\Helpers\SpeedtestHelper;
+use App\Jobs\SpeedtestJob;
+use App\Models\Speedtest;
+use Carbon\Carbon;
+use Exception;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Validator;
+use Illuminate\Http\JsonResponse;
+
+class SpeedtestController extends Controller
+{
+    public function __construct()
+    {
+        if ((bool)SettingsHelper::get('auth')->value === true) {
+            $this->middleware('auth:api')
+                ->only(['run', 'delete', 'deleteAll']);
+        }
+    }
+
+    /**
+     * Returns paginated list of speedtests
+     *
+     * @return  JsonResponse
+     */
+    public function index()
+    {
+        $data = Speedtest::orderBy('created_at', 'desc')
+            ->paginate();
+
+        return response()->json([
+            'method' => 'index of speedtests',
+            'data' => $data,
+        ], 200);
+    }
+
+    /**
+     * Returns speedtest going back 'x' days
+     *
+     * @param   int     $days
+     * @return  JsonResponse
+     */
+    public function time($days)
+    {
+        $rule = [
+            'days' => ['required', 'integer'],
+        ];
+
+        $validator = Validator::make(['days' => $days], $rule);
+
+        if ($validator->fails()) {
+            return response()->json([
+                'method' => 'get speedtests in last x days',
+                'error' => $validator->errors(),
+            ], 422);
+        }
+
+        $data = run(GetSpeedtestTimeData::class, $days);
+
+        return response()->json([
+            'method' => 'get speedtests in last x days',
+            'days' => $days,
+            'data' => $data
+        ], 200);
+    }
+
+    /**
+     * Returns speedtest failure rate going back 'x' days
+     *
+     * @param   int     $days
+     * @return  JsonResponse
+     */
+    public function fail($days)
+    {
+        $rule = [
+            'days' => ['required', 'integer'],
+        ];
+
+        $validator = Validator::make(['days' => $days], $rule);
+
+        if ($validator->fails()) {
+            return response()->json([
+                'method' => 'get speedtests in last x days',
+                'error' => $validator->errors(),
+            ], 422);
+        }
+
+        $data = run(GetFailedSpeedtestData::class, $days);
+
+        return response()->json([
+            'method' => 'get speedtests in last x days',
+            'days' => $days,
+            'data' => $data
+        ], 200);
+    }
+
+    /**
+     * Return latest speedtest
+     *
+     * @return  JsonResponse
+     */
+    public function latest()
+    {
+        $data = run(GetLatestSpeedtestData::class);
+
+        if ($data['data']) {
+            return response()->json($data, 200);
+        } else {
+            return response()->json([
+                'method' => 'get latest speedtest',
+                'error' => 'no speedtests have been run'
+            ], 404);
+        }
+    }
+
+    /**
+     * Queue a new speedtest
+     *
+     * @return JsonResponse
+     */
+    public function run()
+    {
+        try {
+            run(QueueSpeedtest::class);
+
+            return response()->json([
+                'method' => 'run speedtest',
+                'data' => 'a new speedtest has been added to the queue'
+            ], 200);
+        } catch (Exception $e) {
+            return response()->json([
+                'method' => 'run speedtest',
+                'error' => $e
+            ], 500);
+        }
+    }
+
+    /**
+     * Delete all speedtests from db
+     *
+     * @return JsonResponse
+     */
+    public function deleteAll()
+    {
+        $ret = SpeedtestHelper::deleteAll();
+
+        if ($ret['success']) {
+            return response()->json([
+                'method' => 'delete all speedtests from the database',
+                'success' => true
+            ], 200);
+        }
+
+        return response()->json([
+            'method' => 'delete all speedtests from the database',
+            'success' => false,
+            'error' => $ret['msg'],
+        ], 500);
+    }
+
+    /**
+     * Delete a specific speedtest from the database
+     *
+     * @param Speedtest $speedtest
+     * @return JsonResponse
+     */
+    public function delete(Speedtest $speedtest)
+    {
+        $speedtest->delete();
+
+        Cache::flush();
+
+        return response()->json([
+            'method' => 'delete a speedtest from the database',
+            'success' => true,
+        ], 200);
+    }
+}

speedtest/volumes/config/www/app/Http/Controllers/UpdateController.php

@@ -0,0 +1,112 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Helpers\SettingsHelper;
+use Exception;
+use Updater;
+use Illuminate\Http\Request;
+use Illuminate\Http\JsonResponse;
+
+class UpdateController extends Controller
+{
+    public function __construct()
+    {
+        if((bool)SettingsHelper::get('auth')->value === true) {
+            $this->middleware('auth:api');
+        }
+    }
+
+    /**
+     * Check for new update
+     *
+     * @return  JsonResponse
+     */
+    public function checkForUpdate()
+    {
+        return response()->json([
+            'method' => 'check for updates',
+            'update' => Updater::check(),
+        ], 200);
+    }
+
+    /**
+     * Download new update
+     *
+     * @return  JsonResponse
+     */
+    public function downloadUpdate()
+    {
+        $dl = Updater::downloadLatest();
+
+        if($dl) {
+            return response()->json([
+                'method' => 'download latest version',
+                'success' => true,
+            ], 200);
+        } else {
+            return response()->json([
+                'method' => 'download latest version',
+                'success' => false,
+            ], 500);
+        }
+    }
+
+    /**
+     * Trigger update extraction
+     *
+     * @return  JsonResponse
+     */
+    public function extractUpdate()
+    {
+        $ex = Updater::extractFiles();
+
+        if($ex) {
+            return response()->json([
+                'method' => 'extract latest version',
+                'success' => true,
+            ], 200);
+        } else {
+            return response()->json([
+                'method' => 'extract latest version',
+                'success' => false,
+            ], 500);
+        }
+    }
+
+    /**
+     * Trigger update file move
+     *
+     * @return  JsonResponse
+     */
+    public function moveUpdate()
+    {
+        Updater::updateFiles();
+
+        return response()->json([
+            'method' => 'copy latest version',
+            'success' => null,
+        ], 200);
+    }
+
+    /**
+     * Get local changelog
+     *
+     * @return  JsonResponse
+     */
+    public function changelog()
+    {
+        $url = base_path() . '/changelog.json';
+
+        try {
+            $changelog = json_decode(file_get_contents($url), true);
+        } catch(Exception $e) {
+            $changelog = [];
+        }
+
+        return response()->json([
+            'method' => 'get changelog',
+            'data' => $changelog
+        ], 200);
+    }
+}

speedtest/volumes/config/www/app/Http/Kernel.php

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

speedtest/volumes/config/www/app/Http/Middleware/Authenticate.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Http\Middleware;
+
+use Illuminate\Auth\Middleware\Authenticate as Middleware;
+
+class Authenticate extends Middleware
+{
+    /**
+     * Get the path the user should be redirected to when they are not authenticated.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return string|null
+     */
+    protected function redirectTo($request)
+    {
+        if (! $request->expectsJson()) {
+            return route('auth.login');
+        }
+
+        return null;
+    }
+}

speedtest/volumes/config/www/app/Http/Middleware/CheckActiveSession.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace App\Http\Middleware;
+
+use App\Models\Auth\LoginSession;
+use Closure;
+use Exception;
+
+class CheckActiveSession
+{
+    /**
+     * Handle an incoming request.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @param  \Closure  $next
+     * @return mixed
+     */
+    public function handle($request, Closure $next)
+    {
+        try {
+            $token = $request->bearerToken();
+            if($token == null) { $token = $request->token; }
+            $session = LoginSession::where('token', $token)
+                                   ->first();
+
+            if(!$session->active) {
+                return response()->json([
+                    'error' => 'token is invalid'
+                ], 401);
+            }
+        } catch(Exception $e) {
+            return response()->json([
+                'error' => 'token not found'
+            ], 401);
+        }
+
+        return $next($request);
+    }
+}

speedtest/volumes/config/www/app/Http/Middleware/CheckEmailVerified.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace App\Http\Middleware;
+
+use App\Helpers\EmailVerificationHelper;
+use Closure;
+use Exception;
+
+class CheckEmailVerified
+{
+    /**
+     * Handle an incoming request.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @param  \Closure  $next
+     * @return mixed
+     */
+    public function handle($request, Closure $next)
+    {
+        try {
+            if(!EmailVerificationHelper::userIsVerified()) {
+                return response()->json([
+                    'error' => 'You need to verify your email address',
+                ], 401);
+            }
+        } catch(Exception $e) {
+            return response()->json([
+                'error' => 'Your account was not found'
+            ], 422);
+        }
+
+        return $next($request);
+    }
+}

speedtest/volumes/config/www/app/Http/Middleware/CheckForMaintenanceMode.php

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

speedtest/volumes/config/www/app/Http/Middleware/EncryptCookies.php

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

speedtest/volumes/config/www/app/Http/Middleware/RedirectIfAuthenticated.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace App\Http\Middleware;
+
+use App\Providers\RouteServiceProvider;
+use Closure;
+use Illuminate\Support\Facades\Auth;
+
+class RedirectIfAuthenticated
+{
+    /**
+     * Handle an incoming request.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @param  \Closure  $next
+     * @param  string|null  $guard
+     * @return mixed
+     */
+    public function handle($request, Closure $next, $guard = null)
+    {
+        if (Auth::guard($guard)->check()) {
+            return redirect(RouteServiceProvider::HOME);
+        }
+
+        return $next($request);
+    }
+}

speedtest/volumes/config/www/app/Http/Middleware/TrimStrings.php

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

speedtest/volumes/config/www/app/Http/Middleware/TrustProxies.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Http\Middleware;
+
+use Fideloper\Proxy\TrustProxies as Middleware;
+use Illuminate\Http\Request;
+
+class TrustProxies extends Middleware
+{
+    /**
+     * The trusted proxies for this application.
+     *
+     * @var array|string
+     */
+    protected $proxies;
+
+    /**
+     * The headers that should be used to detect proxies.
+     *
+     * @var int
+     */
+    protected $headers = Request::HEADER_X_FORWARDED_ALL;
+}

speedtest/volumes/config/www/app/Http/Middleware/VerifyCsrfToken.php

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