Protonemedia\LaravelTracer\Middleware\TraceUser

Complexity

Total Complexity

17

Size/Duplication

Total Lines	129
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	handle()	0	16	4
A	traceUserRequest()	0	17	3
A	qualify()	0	15	3
A	tooManyAttempts()	0	18	4
A	shouldTraceUser()	0	8	2

<?php

namespace Protonemedia\LaravelTracer\Middleware;

use Closure;
use Illuminate\Cache\RateLimiter;
use Illuminate\Contracts\Auth\Authenticatable as UserContract;
use Illuminate\Http\Request;
use Illuminate\Routing\Route;
use Illuminate\Support\Arr;
use Illuminate\Support\Collection;
use Protonemedia\LaravelTracer\UserRequest;
use Symfony\Component\HttpFoundation\Response;

class TraceUser
{
    /**
     * Rate Limiter
     *
     * @var \Illuminate\Cache\RateLimiter
     */
    private $limiter;

    /**
     * Sets the Rate Limiter.
     *
     * @param \Illuminate\Cache\RateLimiter $limiter
     */
    public function __construct(RateLimiter $limiter)
    {
        $this->limiter = $limiter;
    }

    /**
     * Handle an incoming request and trace the user
     * if the current user is authenticated.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @return mixed
     */
    public function handle($request, Closure $next)
    {
        $response = $next($request);

        if (!$user = $request->user()) {
            return $response;
        }

        if ($response->getStatusCode() < 200 || $response->getStatusCode() >= 300) {
            return $response;
        }

        $this->traceUserRequest($user, $request, $response);

        return $response;
    }

    /**
     * Stores the user request in the database.
     *
     * @param  \Illuminate\Contracts\Auth\Authenticatable  $user
     * @param  \Illuminate\Http\Request  $request
     * @param  \Symfony\Component\HttpFoundation\Response  $response
     *
     * @return \Protonemedia\LaravelTracer\UserRequest|null
     */
    private function traceUserRequest(UserContract $user, Request $request, Response $response):  ? UserRequest
    {
        $qualified = $this->qualify($request, $request->route());

$request->route() is of type object|string, but the function expects a object<Illuminate\Routing\Route>.

        if ($this->tooManyAttempts($qualified)) {
            return null;
        }

        if (!$this->shouldTraceUser($request, $response)) {
            return null;
        }

        return UserRequest::create([
            'user_id'         => $user->getAuthIdentifier(),
            'qualified_route' => $qualified['name'],
        ]);
    }

    /**
     * Returns the qualified name for the given request and route data.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Illuminate\Routing\Route   $route
     * @return mixed
     */
    private function qualify(Request $request, Route $route) : array
    {
        if (!$qualified = QualifyRoute::getByUri($route->uri())) {
            return [
                'name'                 => $route->getName() ?: $request->path(),
                'seconds_between_logs' => null,
            ];
        }

        Collection::make($route->parameters())->map(function ($value, $parameter) use (&$qualified) {
            $qualified['name'] = str_replace("{{$parameter}}", $value, $qualified['name']);
        });

        return $qualified;
    }

    /**
     * Returns a boolean wether this request has been attemped to
     * trace too many times.
     *
     * @param  array  $qualified
     * @return boolean
     */
    private function tooManyAttempts(array $qualified): bool
    {
        if (is_null($qualified['seconds_between_logs'])) {
            $qualified['seconds_between_logs'] = config('laravel-tracer.seconds_between_logs');
        }

        if (!$qualified['seconds_between_logs']) {
            return false;
        }

        if ($this->limiter->tooManyAttempts($qualified['name'], 1)) {
            return true;
        }

        $this->limiter->hit($qualified['name'], $qualified['seconds_between_logs']);

        return false;
    }

    private function shouldTraceUser(Request $request, Response $response): bool
    {
        if (!$callable = config('laravel-tracer.should_trace_user')) {
            return true;
        }

        return app()->call($callable, [$request, $response]);
    }
}