Added base app

Has basic login UI, has methods to run speedtests

app/Auth/EmailVerification.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace App\Auth;
+
+use Illuminate\Database\Eloquent\Model;
+
+class EmailVerification extends Model
+{
+    protected $fillable = [
+        'user_id',
+        'token',
+        'expires'
+    ];
+}

app/Auth/LoginSession.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Auth;
+
+use Illuminate\Database\Eloquent\Model;
+
+class LoginSession extends Model
+{
+    protected $fillable = [
+        'id',
+        'token',
+        'active',
+        'user_id',
+        'expires',
+        'ip'
+    ];
+
+    protected $table = 'active_sessions';
+
+    public $incrementing = false;
+}

app/Console/Commands/SpeedtestCommand.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Helpers\SpeedtestHelper;
+use Illuminate\Console\Command;
+
+class SpeedtestCommand extends Command
+{
+    /**
+     * The name and signature of the console command.
+     *
+     * @var string
+     */
+    protected $signature = 'speedtest:run';
+
+    /**
+     * The console command description.
+     *
+     * @var string
+     */
+    protected $description = 'Performs a new speedtest';
+
+    /**
+     * Create a new command instance.
+     *
+     * @return void
+     */
+    public function __construct()
+    {
+        parent::__construct();
+    }
+
+    /**
+     * Execute the console command.
+     *
+     * @return mixed
+     */
+    public function handle()
+    {
+        $this->info('Running speedtest, this might take a while...');
+
+        $results = SpeedtestHelper::runSpeedtest();
+
+        $this->info('Ping: ' . $results->ping . ' ms');
+        $this->info('Download: ' . $results->download . ' Mbit/s');
+        $this->info('Upload: ' . $results->upload . ' Mbit/s');
+    }
+}

app/Console/Commands/SpeedtestLatestCommand.php

@@ -0,0 +1,61 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Helpers\SpeedtestHelper;
+use Illuminate\Console\Command;
+use Illuminate\Support\Facades\Artisan;
+
+class SpeedtestLatestCommand extends Command
+{
+    /**
+     * The name and signature of the console command.
+     *
+     * @var string
+     */
+    protected $signature = 'speedtest:latest';
+
+    /**
+     * The console command description.
+     *
+     * @var string
+     */
+    protected $description = 'Returns the latest speedtest result';
+
+    /**
+     * Create a new command instance.
+     *
+     * @return void
+     */
+    public function __construct()
+    {
+        parent::__construct();
+    }
+
+    /**
+     * Execute the console command.
+     *
+     * @return mixed
+     */
+    public function handle()
+    {
+        $latest = SpeedtestHelper::latest();
+
+        if($latest) {
+            $this->info('Last speedtest run at: ' . $latest->created_at);
+            $this->info('Ping: ' . $latest->ping . ' ms');
+            $this->info('Download: ' . $latest->download . ' Mbit/s');
+            $this->info('Upload: ' . $latest->upload . ' Mbit/s');
+        } else {
+            $this->info('No speedtests have been run yet.');
+
+            $this->info('Running speedtest, this might take a while...');
+
+            $results = SpeedtestHelper::runSpeedtest();
+
+            $this->info('Ping: ' . $results->ping . ' ms');
+            $this->info('Download: ' . $results->download . ' Mbit/s');
+            $this->info('Upload: ' . $results->upload . ' Mbit/s');
+        }
+    }
+}

app/Console/Kernel.php

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

app/Exceptions/Handler.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace App\Exceptions;
+
+use Illuminate\Foundation\Exceptions\Handler as ExceptionHandler;
+use Throwable;
+
+class Handler extends ExceptionHandler
+{
+    /**
+     * A list of the exception types that are not reported.
+     *
+     * @var array
+     */
+    protected $dontReport = [
+        //
+    ];
+
+    /**
+     * A list of the inputs that are never flashed for validation exceptions.
+     *
+     * @var array
+     */
+    protected $dontFlash = [
+        'password',
+        'password_confirmation',
+    ];
+
+    /**
+     * Report or log an exception.
+     *
+     * @param  \Throwable  $exception
+     * @return void
+     *
+     * @throws \Exception
+     */
+    public function report(Throwable $exception)
+    {
+        parent::report($exception);
+    }
+
+    /**
+     * Render an exception into an HTTP response.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @param  \Throwable  $exception
+     * @return \Symfony\Component\HttpFoundation\Response
+     *
+     * @throws \Throwable
+     */
+    public function render($request, Throwable $exception)
+    {
+        return parent::render($request, $exception);
+    }
+}

app/Helpers/EmailVerificationHelper.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace App\Helpers;
+
+use App\Auth\EmailVerification;
+use App\User;
+
+class EmailVerificationHelper {
+    public static function checkVerificationAttempt($userID, $token)
+    {
+        $verification = EmailVerification::where('user_id', $userID)
+                                         ->where('token', $token)
+                                         ->first();
+
+        if(!$verification) {
+            return false;
+        }
+
+        return User::where('id', $userID)->first();
+    }
+
+    public static function verifyUser(User $user)
+    {
+
+    }
+
+    public static function userIsVerified()
+    {
+        if(auth()->user()->email_verified_at == null) {
+            return false;
+        }
+
+        return true;
+    }
+}

app/Helpers/SpeedtestHelper.php

@@ -0,0 +1,68 @@
+<?php
+
+namespace App\Helpers;
+
+use App\Speedtest;
+
+class SpeedtestHelper {
+    public static function runSpeedtest()
+    {
+        $output = shell_exec('speedtest-cli');
+        $output = preg_replace("/\r|\n/", "", $output);
+
+        $pattern = '/([0-9\.]{1,}) ms.*Download: ([0-9\.]{1,} [A-Za-z]{1,}\/s).*Upload: ([0-9\.]{1,} [A-Za-z]{1,}\/s)/';
+        $matches = [];
+        preg_match_all($pattern, $output, $matches);
+
+        $ping = $matches[1][0];
+        $down = SpeedtestHelper::parseUnits($matches[2][0]);
+        $up = SpeedtestHelper::parseUnits($matches[3][0]);
+
+        $test = Speedtest::create([
+            'ping' => $ping,
+            'download' => $down['val'],
+            'upload' => $up['val']
+        ]);
+
+        return $test;
+    }
+
+    public static function latest()
+    {
+        $data = Speedtest::latest()->get();
+
+        if($data->isEmpty()) {
+            return false;
+        }
+
+        return $data->first();
+    }
+
+    public static function parseUnits($input)
+    {
+        $input = explode(' ', $input);
+
+        $val = $input[0];
+        $unit = explode('/', $input[1])[0];
+
+        switch($unit) {
+            case 'Mbyte':
+                $val = $val * 8;
+                break;
+            case 'Kbit':
+                $val = $val / 1000;
+                break;
+            case 'Kbyte':
+                $val = $val / 125;
+                break;
+            case 'Mbit':
+            default:
+                break;
+        }
+
+        return [
+            'val' => $val,
+            'unit' => 'Mbit/s'
+        ];
+    }
+}

app/Http/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 = [
+        //
+    ];
+}

app/Http/Controllers/AuthController.php

@@ -0,0 +1,214 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Auth\EmailVerification;
+use App\Auth\LoginSession as AuthLoginSession;
+use App\Helpers\EmailVerificationHelper;
+use Illuminate\Support\Facades\Auth;
+use App\Http\Controllers\Controller;
+use App\LoginSession;
+use App\User;
+use DateTime;
+use Illuminate\Support\Facades\Request as RequestFacade;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Validator;
+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();
+
+        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);
+    }
+}

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;
+}

app/Http/Controllers/SpeedtestController.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Helpers\SpeedtestHelper;
+use Exception;
+use Illuminate\Http\Request;
+
+class SpeedtestController extends Controller
+{
+    public function latest()
+    {
+        $data = SpeedtestHelper::latest();
+
+        if($data) {
+            return response()->json([
+                'method' => 'get latest speedtest',
+                'data' => $data
+            ], 200);
+        } else {
+            return response()->json([
+                'method' => 'get latest speedtest',
+                'error' => 'no speedtests have been run'
+            ], 404);
+        }
+    }
+
+    public function run()
+    {
+        try {
+            $data = SpeedtestHelper::runSpeedtest();
+            return response()->json([
+                'method' => 'run speedtest',
+                'data' => $data
+            ], 200);
+        } catch(Exception $e) {
+            return response()->json([
+                'method' => 'run speedtest',
+                'error' => $e
+            ], 500);
+        }
+    }
+}

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:60,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,
+    ];
+}

app/Http/Middleware/Authenticate.php

@@ -0,0 +1,21 @@
+<?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');
+        }
+    }
+}

app/Http/Middleware/CheckActiveSession.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace App\Http\Middleware;
+
+use App\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);
+    }
+}

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);
+    }
+}

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 = [
+        //
+    ];
+}

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);
+    }
+}

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',
+    ];
+}

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;
+}

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 = [
+        //
+    ];
+}

app/Providers/AppServiceProvider.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Providers;
+
+use Illuminate\Support\ServiceProvider;
+
+class AppServiceProvider extends ServiceProvider
+{
+    /**
+     * Register any application services.
+     *
+     * @return void
+     */
+    public function register()
+    {
+        //
+    }
+
+    /**
+     * Bootstrap any application services.
+     *
+     * @return void
+     */
+    public function boot()
+    {
+        //
+    }
+}

app/Providers/AuthServiceProvider.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace App\Providers;
+
+use Illuminate\Foundation\Support\Providers\AuthServiceProvider as ServiceProvider;
+use Illuminate\Support\Facades\Gate;
+
+class AuthServiceProvider extends ServiceProvider
+{
+    /**
+     * The policy mappings for the application.
+     *
+     * @var array
+     */
+    protected $policies = [
+        // 'App\Model' => 'App\Policies\ModelPolicy',
+    ];
+
+    /**
+     * Register any authentication / authorization services.
+     *
+     * @return void
+     */
+    public function boot()
+    {
+        $this->registerPolicies();
+
+        //
+    }
+}

app/Providers/BroadcastServiceProvider.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Providers;
+
+use Illuminate\Support\Facades\Broadcast;
+use Illuminate\Support\ServiceProvider;
+
+class BroadcastServiceProvider extends ServiceProvider
+{
+    /**
+     * Bootstrap any application services.
+     *
+     * @return void
+     */
+    public function boot()
+    {
+        Broadcast::routes();
+
+        require base_path('routes/channels.php');
+    }
+}

app/Providers/EventServiceProvider.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace App\Providers;
+
+use Illuminate\Auth\Events\Registered;
+use Illuminate\Auth\Listeners\SendEmailVerificationNotification;
+use Illuminate\Foundation\Support\Providers\EventServiceProvider as ServiceProvider;
+use Illuminate\Support\Facades\Event;
+
+class EventServiceProvider extends ServiceProvider
+{
+    /**
+     * The event listener mappings for the application.
+     *
+     * @var array
+     */
+    protected $listen = [
+        Registered::class => [
+            SendEmailVerificationNotification::class,
+        ],
+    ];
+
+    /**
+     * Register any events for your application.
+     *
+     * @return void
+     */
+    public function boot()
+    {
+        parent::boot();
+
+        //
+    }
+}

app/Providers/RouteServiceProvider.php

@@ -0,0 +1,80 @@
+<?php
+
+namespace App\Providers;
+
+use Illuminate\Foundation\Support\Providers\RouteServiceProvider as ServiceProvider;
+use Illuminate\Support\Facades\Route;
+
+class RouteServiceProvider extends ServiceProvider
+{
+    /**
+     * This namespace is applied to your controller routes.
+     *
+     * In addition, it is set as the URL generator's root namespace.
+     *
+     * @var string
+     */
+    protected $namespace = 'App\Http\Controllers';
+
+    /**
+     * The path to the "home" route for your application.
+     *
+     * @var string
+     */
+    public const HOME = '/home';
+
+    /**
+     * Define your route model bindings, pattern filters, etc.
+     *
+     * @return void
+     */
+    public function boot()
+    {
+        //
+
+        parent::boot();
+    }
+
+    /**
+     * Define the routes for the application.
+     *
+     * @return void
+     */
+    public function map()
+    {
+        $this->mapApiRoutes();
+
+        $this->mapWebRoutes();
+
+        //
+    }
+
+    /**
+     * Define the "web" routes for the application.
+     *
+     * These routes all receive session state, CSRF protection, etc.
+     *
+     * @return void
+     */
+    protected function mapWebRoutes()
+    {
+        Route::middleware('web')
+            ->namespace($this->namespace)
+            ->group(base_path('routes/web.php'));
+    }
+
+    /**
+     * Define the "api" routes for the application.
+     *
+     * These routes are typically stateless.
+     *
+     * @return void
+     */
+    protected function mapApiRoutes()
+    {
+        Route::prefix('api')
+            ->middleware('api')
+            ->namespace($this->namespace)
+            ->group(base_path('routes/api.php'));
+    }
+}

app/Speedtest.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace App;
+
+use Illuminate\Database\Eloquent\Model;
+
+class Speedtest extends Model
+{
+    /**
+     * The attributes that are mass assignable.
+     *
+     * @var array
+     */
+    protected $fillable = [
+        'ping', 'download', 'upload'
+    ];
+
+    protected $table = 'speedtests';
+}

app/User.php

@@ -0,0 +1,109 @@
+<?php
+
+namespace App;
+
+use Illuminate\Contracts\Auth\MustVerifyEmail;
+use Illuminate\Foundation\Auth\User as Authenticatable;
+use Illuminate\Notifications\Notifiable;
+use Illuminate\Support\Facades\Hash;
+use Tymon\JWTAuth\Contracts\JWTSubject;
+
+class User extends Authenticatable implements JWTSubject
+{
+    use Notifiable;
+
+    /**
+     * The attributes that are mass assignable.
+     *
+     * @var array
+     */
+    protected $fillable = [
+        'name', 'email', 'password', 'id', 'email_verified_at'
+    ];
+
+    /**
+     * The attributes that should be hidden for arrays.
+     *
+     * @var array
+     */
+    protected $hidden = [
+        'password',
+    ];
+
+    /**
+     * The attributes that should be cast to native types.
+     *
+     * @var array
+     */
+    protected $casts = [
+        'email_verified_at' => 'datetime',
+    ];
+
+    protected $primaryKey = 'id';
+
+    protected $keyType = 'uuid';
+
+    public $incrementing = false;
+
+    public static function loginRules()
+    {
+        return [
+            'email' => 'required',
+            'password' => 'required'
+        ];
+    }
+
+    public static function registerRules()
+    {
+        return [
+            'name' => ['required', 'string', 'max:255'],
+            'email' => ['required', 'string', 'email', 'max:255', 'unique:users'],
+            'password' => ['required', 'string', 'min:8', 'confirmed']
+        ];
+    }
+
+    public static function updateRules()
+    {
+        return [
+            'name' => ['required', 'string', 'max:255'],
+            'email' => ['required', 'string', 'email', 'max:255', 'unique:users']
+        ];
+    }
+
+    public function verification()
+    {
+        return $this->hasOne('\App\Auth\EmailVerification');
+    }
+
+    public function sessions()
+    {
+        return $this->hasMany('\App\Auth\LoginSession');
+    }
+
+    /**
+     * Get the identifier that will be stored in the subject claim of the JWT.
+     *
+     * @return mixed
+     */
+    public function getJWTIdentifier()
+    {
+        return $this->getKey();
+    }
+
+    /**
+     * Return a key value array, containing any custom claims to be added to the JWT.
+     *
+     * @return array
+     */
+    public function getJWTCustomClaims()
+    {
+        return [];
+    }
+
+    public function setPasswordAttribute($password)
+    {
+        if ( !empty($password) ) {
+            $this->attributes['password'] = Hash::make($password);
+        }
+    }
+}