Handler::context() - Code Metrics - GCTC-NTGC/TalentCloud - Measure and Improve Code Quality continuously with Scrutinizer

Handler::context() A
last analyzed 2022-08-11 13:57 UTC

↳ Parent: Handler
Complexity

Conditions	2
Paths	2
Size

Total Lines	11
Code Lines	8
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	6
CRAP Score	2
Importance

Changes
Metric	Value
eloc	8
c	0
b	0
f	0
dl	0
loc	11
ccs	6
cts	6
cp	1
rs	10
cc	2
nc	2
nop	0
crap	2
<?php

namespace App\Exceptions;

use Illuminate\Auth\Access\AuthorizationException;
use Illuminate\Auth\AuthenticationException;
use Illuminate\Database\Eloquent\ModelNotFoundException;
use Illuminate\Foundation\Exceptions\Handler as ExceptionHandler;
use Illuminate\Http\Exceptions\HttpResponseException;
use Illuminate\Session\TokenMismatchException;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Lang;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Request;
use Illuminate\Validation\ValidationException;
use Symfony\Component\HttpKernel\Exception\HttpException;
use Symfony\Component\HttpKernel\Exception\HttpExceptionInterface;
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',
        'current_password',
        'new_password',
        'new_password_confirmation',
    ];

    /**
     * OVERRIDE
     * A list of the internal exception types that should not be reported.
     *
     * @var array
     */
    protected $internalDontReport = [
        AuthenticationException::class,
        AuthorizationException::class,
        HttpResponseException::class,
        ModelNotFoundException::class,
        ValidationException::class,
    ];

    /**
     * Report or log an exception.
     *
     * This is a great spot to send exceptions to Flare, Sentry, Bugsnag, etc.
     *
     * @param  \Throwable  $exception
     * @return void
     */
    public function report(Throwable $exception)
    {
        if ($exception instanceof TokenMismatchException) {
            $logData = [
                'requestToken' => request()->header('x-csrf-token'),
                'requestToken' => /** @scrutinizer ignore-call */ request()->header('x-csrf-token'),
                'sessionToken' => session()->token(),
                'sessionToken' => /** @scrutinizer ignore-call */ session()->token(),
                'session' => session()->all(),
                'user' => request()->user(),
                'requestUrl' => request()->url()
            ];
            $message = '419 CSRF Token Mismatch. ' . collect($logData)->toJson();
            $message = '419 CSRF Token Mismatch. ' . /** @scrutinizer ignore-call */ collect($logData)->toJson();
            Log::debug($message);
        }

        parent::report($exception);
    }

    /**
     * OVERRIDE
     * Get the default context variables for logging.
     *
     * @return array
     */
    protected function context()
    {
        try {
            return array_filter([
                'userId' => Auth::id(),
                'url' => Request::path(),
                'method' => Request::method(),
                'referer' => Request::header('referer', '')
            ]);
        } catch (\Throwable $e) {
            return [];
        }
    }

    /**
     * Render an exception into an HTTP response.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  Throwable  $exception
     * @return \Illuminate\Http\Response
     *
     * @throws Throwable
     */
    public function render($request, Throwable $exception)
    {
        // Redirect upper case URLs to lower case route.
        $url = $request->url();
        $loweredCaseUrl = strtolower($url);
        if ($exception instanceof \Symfony\Component\HttpKernel\Exception\NotFoundHttpException && $url !== $loweredCaseUrl) {
            return redirect($loweredCaseUrl);
            return /** @scrutinizer ignore-call */ redirect($loweredCaseUrl);
        }

        // Laravel will render out the error page by default even for JSON
        // requests... this will return a standardized JSON response with a 403
        // if unauthorized.
        if ($exception instanceof AuthorizationException && $request->wantsJson()) {
            return response()->json(['message' => $exception->getMessage()], 403);
            return /** @scrutinizer ignore-call */ response()->json(['message' => $exception->getMessage()], 403);
        }
        if ($exception instanceof AdminException) {
            return $exception->render($request);
        }
        if ($exception instanceof TwoFactorRequiredException) {
            return $exception->render($request);
        }
        if ($exception instanceof TokenMismatchException) {
            $newMessage = $exception->getMessage() . ' ' . Lang::get('errors.refresh_page');
            $modifiedException = new TokenMismatchException($newMessage, $exception->getCode(), $exception);
            return parent::render($request, $modifiedException);
        }
        if ($exception instanceof StateMachineException) {
            return parent::render($request, new HttpException(400, $exception->getMessage()));
        }
        if ($exception instanceof SendEmailException) {
            return parent::render($request, new HttpException(400, $exception->getMessage()));
        }
        return parent::render($request, $exception);
    }

    /**
     * Convert an authentication exception into an unauthenticated response.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Illuminate\Auth\AuthenticationException  $exception
     * @return \Illuminate\Http\Response
     */
    protected function unauthenticated($request, AuthenticationException $exception)
    {
        if ($request->expectsJson()) {
            return response()->json(['error' => 'Unauthenticated.'], 401);
            return /** @scrutinizer ignore-call */ response()->json(['error' => 'Unauthenticated.'], 401);
        }
        $loginRoute = ($exception->redirectTo() !== null && $exception->redirectTo() !== '')
            ? $exception->redirectTo()
            : route('login');
            : /** @scrutinizer ignore-call */ route('login');
        return redirect()->guest($loginRoute);
        return /** @scrutinizer ignore-call */ redirect()->guest($loginRoute);
    }

    /**
     * OVERRIDE
     * Render the given HttpException.
     *
     * @param  \Symfony\Component\HttpKernel\Exception\HttpExceptionInterface  $e
     * @return \Symfony\Component\HttpFoundation\Response
     */
    protected function renderHttpException(HttpExceptionInterface $e)
    {
        if (!view()->exists("errors.{$e->getStatusCode()}")) {
        if (!/** @scrutinizer ignore-call */ view()->exists("errors.{$e->getStatusCode()}")) {
            return response()->view('errors.default', [
            return /** @scrutinizer ignore-call */ response()->view('errors.default', [
                'exception' => $e,
                'goc' => Lang::get('common/goc'),
                'alert' => Lang::get('common/alert'),
                'error' => Lang::get('errors')['default'],
            ], $e->getStatusCode(), $e->getHeaders());
        }
        return parent::renderHttpException($e);
    }
}

GCTC-NTGC / TalentCloud

Handler::context() A last analyzed 2022-08-11 13:57 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Handler::context() A
last analyzed 2022-08-11 13:57 UTC
