Codexshaper / wpb-framework

src/Exceptions/Handler.php

<?php
/**
 * The file handle the errors.
 *
 * @link       https://github.com/maab16
 * @since      1.0.0
 */

namespace WPB\Exceptions;

use Exception;
use Illuminate\Auth\Access\AuthorizationException;

The type Illuminate\Auth\Access\AuthorizationException was not found. Maybe you did not declare it correctly or list all dependencies?

use Illuminate\Auth\AuthenticationException;

The type Illuminate\Auth\AuthenticationException was not found. Maybe you did not declare it correctly or list all dependencies?

use Illuminate\Contracts\Container\BindingResolutionException;
use Illuminate\Contracts\Container\Container;
use Illuminate\Contracts\Support\Responsable;
use Illuminate\Database\Eloquent\ModelNotFoundException;
use Illuminate\Http\Exceptions\HttpResponseException;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Response;
use Illuminate\Routing\Router;
use Illuminate\Session\TokenMismatchException;
use Illuminate\Support\Arr;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\View;
use Illuminate\Support\ViewErrorBag;
use Illuminate\Validation\ValidationException;

The type Illuminate\Validation\ValidationException was not found. Maybe you did not declare it correctly or list all dependencies?

use Psr\Log\LoggerInterface;
use Symfony\Component\Console\Application as ConsoleApplication;
use Symfony\Component\ErrorHandler\ErrorRenderer\HtmlErrorRenderer;
use Symfony\Component\HttpFoundation\Exception\SuspiciousOperationException;
use Symfony\Component\HttpFoundation\RedirectResponse as SymfonyRedirectResponse;
use Symfony\Component\HttpFoundation\Response as SymfonyResponse;
use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
use Symfony\Component\HttpKernel\Exception\HttpException;
use Symfony\Component\HttpKernel\Exception\HttpExceptionInterface;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use Throwable;
use Whoops\Handler\HandlerInterface;

The type Whoops\Handler\HandlerInterface was not found. Maybe you did not declare it correctly or list all dependencies?

use Whoops\Run as Whoops;

The type Whoops\Run was not found. Maybe you did not declare it correctly or list all dependencies?

use WPB\Contracts\ExceptionHandler as ExceptionHandlerContract;

/**
 * The exception handler.
 *
 * @since      1.0.0
 *
 * @author     Md Abu Ahsan basir <maab.career@gmail.com>
 */
class Handler implements ExceptionHandlerContract
{
    /**
     * The container implementation.
     *
     * @var \Illuminate\Contracts\Container\Container
     */
    protected $container;

    /**
     * A list of the exception types that are not reported.
     *
     * @var array
     */
    protected $dont_report = [];

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

    /**
     * A list of the inputs that are never flashed for validation exceptions.
     *
     * @var array
     */
    protected $dont_flash = [
        'password',
        'password_confirmation',
    ];

    /**
     * Create a new exception handler instance.
     *
     * @param \Illuminate\Contracts\Container\Container $container The app container.
     *
     * @return void
     */
    public function __construct(Container $container)
    {
        $this->container = $container;
    }

    /**
     * Report or log an exception.
     *
     * @param \Throwable $e The throwable exception.
     *
     * @throws \Exception Throw the exception.
     *
     * @return void
     */
    public function report(Throwable $e)
    {
        if ($this->shouldnt_report($e)) {
            return;
        }

        $report_callable = [$e, 'report'];

        if (is_callable($report_callable)) {
            $this->container->call($report_callable);

            return;
        }

        try {
            $logger = $this->container->make(LoggerInterface::class);
        } catch (Exception $ex) {
            throw $e;
        }

        $logger->error(
            $e->getMessage(),
            array_merge(
                $this->exception_context($e),
                $this->context(),
                ['exception' => $e]
            )
        );
    }

    /**
     * Determine if the exception should be reported.
     *
     * @param \Throwable $e The throwable exception.
     *
     * @return bool
     */
    public function should_report(Throwable $e)
    {
        return !$this->shouldnt_report($e);
    }

    /**
     * Determine if the exception is in the "do not report" list.
     *
     * @param \Throwable $e The throwable exception.
     *
     * @return bool
     */
    protected function shouldnt_report(Throwable $e)
    {
        $dont_report = array_merge($this->dont_report, $this->internal_dont_report);

        return !is_null(
            Arr::first(
                $dont_report,
                function ($type) use ($e) {
                    return $e instanceof $type;
                }
            )
        );
    }

    /**
     * Get the default exception context variables for logging.
     *
     * @param \Throwable $e The throwable exception.
     *
     * @return array
     */
    protected function exception_context(Throwable $e)

The parameter $e is not used and could be removed.

    {
        return [];
    }

    /**
     * Get the default context variables for logging.
     *
     * @return array
     */
    protected function context()
    {
        try {
            return array_filter(
                [
                    'userId' => Auth::id(),
                    // 'email' => optional(Auth::user())->email,
                ]
            );
        } catch (Throwable $e) {
            return [];
        }
    }

    /**
     * Render an exception into an HTTP response.
     *
     * @param \Illuminate\Http\Request $request The app request.
     * @param \Throwable               $e       The throwable exception.
     *
     * @throws \Throwable Throw the exception.
     *
     * @return \Symfony\Component\HttpFoundation\Response
     */
    public function render($request, Throwable $e)
    {
        $response = $e->render($request);

The method render() does not exist on Throwable.

        if (method_exists($e, 'render') && $response) {
            return Router::toResponse($request, $response);
        } elseif ($e instanceof Responsable) {
            return $e->toResponse($request);
        }

        $e = $this->prepare_exception($e);

        if ($e instanceof HttpResponseException) {
            return $e->getResponse();
        } elseif ($e instanceof AuthenticationException) {
            return $this->unauthenticated($request, $e);
        } elseif ($e instanceof ValidationException) {
            return $this->convert_validation_exception_to_response($e, $request);
        }

        return $request->expectsJson()
                    ? $this->prepare_json_response($request, $e)
                    : $this->prepare_response($request, $e);
    }

    /**
     * Prepare exception for rendering.
     *
     * @param \Throwable $e The throwable exception.
     *
     * @return \Throwable
     */
    protected function prepare_exception(Throwable $e)
    {
        if ($e instanceof ModelNotFoundException) {
            $e = new NotFoundHttpException($e->getMessage(), $e);
        } elseif ($e instanceof AuthorizationException) {
            $e = new AccessDeniedHttpException($e->getMessage(), $e);
        } elseif ($e instanceof TokenMismatchException) {
            $e = new HttpException(419, $e->getMessage(), $e);
        } elseif ($e instanceof SuspiciousOperationException) {
            $e = new NotFoundHttpException('Bad hostname provided.', $e);
        }

        return $e;
    }

    /**
     * Convert an authentication exception into a response.
     *
     * @param \Illuminate\Http\Request                 $request   The app request.
     * @param \Illuminate\Auth\AuthenticationException $exception The authenticated exception.
     *
     * @return \Symfony\Component\HttpFoundation\Response
     */
    protected function unauthenticated($request, AuthenticationException $exception)
    {
        return $request->expectsJson()
                    ? response()->json(['message' => $exception->getMessage()], 401)

The function response was not found. Maybe you did not declare it correctly or list all dependencies?

                    : redirect()->guest($exception->redirectTo() ?? route('login'));

The function route was not found. Maybe you did not declare it correctly or list all dependencies?

The function redirect was not found. Maybe you did not declare it correctly or list all dependencies?

    }

    /**
     * Create a response object from the given validation exception.
     *
     * @param \Illuminate\Validation\ValidationException $e       The validation exception.
     * @param \Illuminate\Http\Request                   $request The app request.
     *
     * @return \Symfony\Component\HttpFoundation\Response
     */
    protected function convert_validation_exception_to_response(ValidationException $e, $request)
    {
        if ($e->response) {
            return $e->response;
        }

        return $request->expectsJson()
                    ? $this->invalid_json($request, $e)
                    : $this->invalid($request, $e);
    }

    /**
     * Convert a validation exception into a response.
     *
     * @param \Illuminate\Http\Request                   $request   The app request.
     * @param \Illuminate\Validation\ValidationException $exception The validation exception.
     *
     * @return \Illuminate\Http\Response
     */
    protected function invalid($request, ValidationException $exception)
    {
        return redirect($exception->redirectTo ?? url()->previous())

The function url was not found. Maybe you did not declare it correctly or list all dependencies?

The function redirect was not found. Maybe you did not declare it correctly or list all dependencies?

                    ->withInput(Arr::except($request->input(), $this->dont_flash))
                    ->withErrors($exception->errors(), $exception->errorBag);
    }

    /**
     * Convert a validation exception into a JSON response.
     *
     * @param \Illuminate\Http\Request                   $request   The app request.
     * @param \Illuminate\Validation\ValidationException $exception The validation exception.
     *
     * @return \Illuminate\Http\JsonResponse
     */
    protected function invalid_json($request, ValidationException $exception)

The parameter $request is not used and could be removed.

    {
        return response()->json(

The function response was not found. Maybe you did not declare it correctly or list all dependencies?

            [
                'message' => $exception->getMessage(),
                'errors'  => $exception->errors(),
            ],
            $exception->status
        );
    }

    /**
     * Prepare a response for the given exception.
     *
     * @param \Illuminate\Http\Request $request The app request.
     * @param \Throwable               $e       The throwable exception.
     *
     * @return \Symfony\Component\HttpFoundation\Response
     */
    protected function prepare_response($request, Throwable $e)

The parameter $request is not used and could be removed.

    {
        if (!$this->is_http_exception($e) && $this->container['config']['app.debug']) {
            return $this->to_illuminate_response($this->convert_exception_to_response($e), $e);
        }

        if (!$this->is_http_exception($e)) {
            $e = new HttpException(500, $e->getMessage());
        }

        return $this->to_illuminate_response(
            $this->render_http_exception($e),
            $e
        );
    }

    /**
     * Create a Symfony response for the given exception.
     *
     * @param \Throwable $e The throwable exception.
     *
     * @return \Symfony\Component\HttpFoundation\Response
     */
    protected function convert_exception_to_response(Throwable $e)
    {
        return SymfonyResponse::create(

The function Symfony\Component\HttpFoundation\Response::create() has been deprecated: since Symfony 5.1, use __construct() instead.

            $this->render_exception_content($e),
            $this->is_http_exception($e) ? $e->getStatusCode() : 500,

The method getStatusCode() does not exist on Throwable. It seems like you code against a sub-type of Throwable such as Symfony\Component\HttpKernel\Exception\HttpExceptionInterface or Symfony\Component\HttpKernel\Exception\HttpException.

            $this->is_http_exception($e) ? $e->getHeaders() : []

The method getHeaders() does not exist on Throwable. It seems like you code against a sub-type of Throwable such as Symfony\Component\HttpKernel\Exception\HttpExceptionInterface or Symfony\Component\HttpKernel\Exception\HttpException.

        );
    }

    /**
     * Get the response content for the given exception.
     *
     * @param \Throwable $e The throwable exception.
     *
     * @return string
     */
    protected function render_exception_content(Throwable $e)
    {
        try {
            return $this->container['config']['app.debug'] && class_exists(Whoops::class)
                        ? $this->render_exception_with_whoops($e)
                        : $this->render_exception_with_symfony($e, $this->container['config']['app.debug']);
        } catch (Exception $e) {
            return $this->render_exception_with_symfony($e, $this->container['config']['app.debug']);
        }
    }

    /**
     * Render an exception to a string using "Whoops".
     *
     * @param \Throwable $e The throwable exception.
     *
     * @return string
     */
    protected function render_exception_with_whoops(Throwable $e)
    {
        return tap(
            new Whoops(),
            function ($whoops) {
                $whoops->appendHandler($this->whoops_handler());

                $whoops->writeToOutput(false);

                $whoops->allowQuit(false);
            }
        )->handleException($e);
    }

    /**
     * Get the Whoops handler for the application.
     *
     * @return \Whoops\Handler\Handler

The type Whoops\Handler\Handler was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    protected function whoops_handler()
    {
        try {
            return $this->container(HandlerInterface::class);

The method container() does not exist on WPB\Exceptions\Handler.

        } catch (BindingResolutionException $e) {
            return ( new WhoopsHandler() )->forDebug();

The type WPB\Exceptions\WhoopsHandler was not found. Maybe you did not declare it correctly or list all dependencies?

        }
    }

    /**
     * Render an exception to a string using Symfony.
     *
     * @param \Throwable $e     The throwable exception.
     * @param bool       $debug Enable or disable debug.
     *
     * @return string
     */
    protected function render_exception_with_symfony(Throwable $e, $debug)
    {
        $renderer = new HtmlErrorRenderer($debug);

        return $renderer->getBody($renderer->render($e));
    }

    /**
     * Render the given HttpException.
     *
     * @param \Symfony\Component\HttpKernel\Exception\HttpExceptionInterface $e The http exception.
     *
     * @return \Symfony\Component\HttpFoundation\Response
     */
    protected function render_http_exception(HttpExceptionInterface $e)
    {
        $this->register_error_view_paths();
        $view = $this->get_http_exception_view($e);

        if (view()->exists($view)) {

The function view was not found. Maybe you did not declare it correctly or list all dependencies?

            return response()->view(

The function response was not found. Maybe you did not declare it correctly or list all dependencies?

                $view,
                [
                    'errors'    => new ViewErrorBag(),
                    'exception' => $e,
                ],
                $e->getStatusCode(),
                $e->getHeaders()
            );
        }

        return $this->convert_exception_to_response($e);
    }

    /**
     * Register the error template hint paths.
     *
     * @return void
     */
    protected function register_error_view_paths()
    {
        $paths = collect($this->container['config']['view.paths']);

        View::replaceNamespace(
            'errors',
            $paths->map(
                function ($path) {
                    return "{$path}/errors";
                }
            )->push(__DIR__.'/views')->all()
        );
    }

    /**
     * Get the view used to render HTTP exceptions.
     *
     * @param \Symfony\Component\HttpKernel\Exception\HttpExceptionInterface $e The http exceptions.
     *
     * @return string
     */
    protected function get_http_exception_view(HttpExceptionInterface $e)
    {
        return "errors::{$e->getStatusCode()}";
    }

    /**
     * Map the given exception into an Illuminate response.
     *
     * @param \Symfony\Component\HttpFoundation\Response $response The app http response.
     * @param \Throwable                                 $e        The throwable exception.
     *
     * @return \Illuminate\Http\Response
     */
    protected function to_illuminate_response($response, Throwable $e)
    {
        if ($response instanceof SymfonyRedirectResponse) {
            $response = new RedirectResponse(
                $response->getTargetUrl(),
                $response->getStatusCode(),
                $response->headers->all()
            );
        } else {
            $response = new Response(
                $response->getContent(),
                $response->getStatusCode(),
                $response->headers->all()
            );
        }

        return $response->withException($e);

The expression return $response->withException($e) also could return the type Illuminate\Http\RedirectResponse which is incompatible with the documented return type Illuminate\Http\Response.

    }

    /**
     * Prepare a JSON response for the given exception.
     *
     * @param \Illuminate\Http\Request $request The app http request.
     * @param \Throwable               $e       The throwable exception.
     *
     * @return \Illuminate\Http\JsonResponse
     */
    protected function prepare_json_response($request, Throwable $e)

The parameter $request is not used and could be removed.

    {
        return new Json_response(

The type WPB\Exceptions\Json_response was not found. Maybe you did not declare it correctly or list all dependencies?

            $this->convert_exception_to_array($e),
            $this->is_http_exception($e) ? $e->getStatusCode() : 500,
            $this->is_http_exception($e) ? $e->getHeaders() : [],
            JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES
        );
    }

    /**
     * Convert the given exception to an array.
     *
     * @param \Throwable $e The throwable exception.
     *
     * @return array
     */
    protected function convert_exception_to_array(Throwable $e)
    {
        return $this->container['config']['app.debug'] ? [
            'message'   => $e->getMessage(),
            'exception' => get_class($e),
            'file'      => $e->getFile(),
            'line'      => $e->getLine(),
            'trace'     => collect($e->getTrace())->map(
                function ($trace) {
                    return Arr::except($trace, ['args']);
                }
            )->all(),
        ] : [
            'message' => $this->is_http_exception($e) ? $e->getMessage() : 'Server Error',
        ];
    }

    /**
     * Render an exception to the console.
     *
     * @param \Symfony\Component\Console\Output\OutputInterface $output The symfony console output.
     * @param \Throwable                                        $e      The throwable exception.
     *
     * @return void
     */
    public function render_for_console($output, Throwable $e)
    {
        ( new ConsoleApplication() )->renderThrowable($e, $output);
    }

    /**
     * Determine if the given exception is an HTTP exception.
     *
     * @param \Throwable $e The throwable exception.
     *
     * @return bool
     */
    protected function is_http_exception(Throwable $e)
    {
        return $e instanceof HttpExceptionInterface;
    }
}