}
 
    /**
     * This request handler is instantiated automatically in App::__construct()
     * It is at the very tip of the middleware queue meaning it will be executed
     * last and it detects whether or not routing has been performed in the user
     * defined middleware stack. In the event that the user did not perform routing
     * it is done here
     *
     * @param ServerRequestInterface $request
     * @return ResponseInterface
     * @throws HttpNotFoundException
     * @throws HttpMethodNotAllowedException
     */
    public function handle(ServerRequestInterface $request): ResponseInterface
    {
        // If routing hasn't been done, then do it now so we can dispatch
        if ($request->getAttribute(RouteContext::ROUTING_RESULTS) === null) {
            $routingMiddleware = new RoutingMiddleware($this->routeResolver, $this->routeParser);
            $request = $routingMiddleware->performRouting($request);
        }
 
        if ($this->routeCollectorProxy !== null) {
            $request = $request->withAttribute(
                RouteContext::BASE_PATH,
                $this->routeCollectorProxy->getBasePath()
            );
        }
 
        /** @var Route $route */
        $route = $request->getAttribute(RouteContext::ROUTE);
        return $route->run($request);
    }
}
 

<?php
 
namespace App\Http\Middlewares;
 
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Message\ServerRequestInterface as Request;
use Psr\Http\Server\RequestHandlerInterface as RequestHandler;
use Psr\Http\Message\ResponseInterface as Response;
use App\Support\Session;
 
class StartSession implements MiddlewareInterface {
    public function process(Request $request, RequestHandler $handler): Response {
        Session::start();
        return $handler->handle($request);
    }
}
 

        $this->tip = new class ($middleware, $next) implements RequestHandlerInterface {
            /**
             * @var MiddlewareInterface
             */
            private $middleware;
 
            /**
             * @var RequestHandlerInterface
             */
            private $next;
 
            public function __construct(MiddlewareInterface $middleware, RequestHandlerInterface $next)
            {
                $this->middleware = $middleware;
                $this->next = $next;
            }
 
            public function handle(ServerRequestInterface $request): ResponseInterface
            {
                return $this->middleware->process($request, $this->next);
            }
        };
 
        return $this;
    }
 
    /**
     * Add a new middleware by class name
     *
     * Middleware are organized as a stack. That means middleware
     * that have been added before will be executed after the newly
     * added one (last in, first out).
     *
     * @param string $middleware
     * @return self
     */
    public function addDeferred(string $middleware): self
    {
        $next = $this->tip;
        $this->tip = new class (

        $whoops->sendHttpCode(false);
 
        //Catch errors means register whoops globally
        if ($this->catchErrors) {
            $whoops->register();
 
            $shutdown = function () use ($whoops) {
                $whoops->allowQuit(true);
                $whoops->writeToOutput(true);
                $whoops->sendHttpCode(true);
 
                $method = Run::SHUTDOWN_HANDLER;
                $whoops->$method();
            };
 
            register_shutdown_function($shutdown);
        }
 
        try {
            $response = $handler->handle($request);
        } catch (\Throwable $exception) {
            $response = $this->responseFactory->createResponse(500);
            $response->getBody()->write($whoops->$method($exception));
            $response = self::updateResponseContentType($response, $whoops);
        } finally {
            while (ob_get_level() >= $level) {
                ob_end_clean();
            }
        }
 
        if ($this->catchErrors) {
            $whoops->unregister();
        }
 
        return $response;
    }
 
    /**
     * Returns the whoops instance or create one.
     */

        $this->tip = new class ($middleware, $next) implements RequestHandlerInterface {
            /**
             * @var MiddlewareInterface
             */
            private $middleware;
 
            /**
             * @var RequestHandlerInterface
             */
            private $next;
 
            public function __construct(MiddlewareInterface $middleware, RequestHandlerInterface $next)
            {
                $this->middleware = $middleware;
                $this->next = $next;
            }
 
            public function handle(ServerRequestInterface $request): ResponseInterface
            {
                return $this->middleware->process($request, $this->next);
            }
        };
 
        return $this;
    }
 
    /**
     * Add a new middleware by class name
     *
     * Middleware are organized as a stack. That means middleware
     * that have been added before will be executed after the newly
     * added one (last in, first out).
     *
     * @param string $middleware
     * @return self
     */
    public function addDeferred(string $middleware): self
    {
        $next = $this->tip;
        $this->tip = new class (

        $this->container = $container;
    }
 
    /**
     * {@inheritdoc}
     */
    public function seedMiddlewareStack(RequestHandlerInterface $kernel): void
    {
        $this->tip = $kernel;
    }
 
    /**
     * Invoke the middleware stack
     *
     * @param ServerRequestInterface $request
     * @return ResponseInterface
     */
    public function handle(ServerRequestInterface $request): ResponseInterface
    {
        return $this->tip->handle($request);
    }
 
    /**
     * Add a new middleware to the stack
     *
     * Middleware are organized as a stack. That means middleware
     * that have been added before will be executed after the newly
     * added one (last in, first out).
     *
     * @param MiddlewareInterface|string|callable $middleware
     * @return MiddlewareDispatcherInterface
     */
    public function add($middleware): MiddlewareDispatcherInterface
    {
        if ($middleware instanceof MiddlewareInterface) {
            return $this->addMiddleware($middleware);
        }
 
        if (is_string($middleware)) {
            return $this->addDeferred($middleware);

            $request = $serverRequestCreator->createServerRequestFromGlobals();
        }
 
        $response = $this->handle($request);
        $responseEmitter = new ResponseEmitter();
        $responseEmitter->emit($response);
    }
 
    /**
     * Handle a request
     *
     * This method traverses the application middleware stack and then returns the
     * resultant Response object.
     *
     * @param ServerRequestInterface $request
     * @return ResponseInterface
     */
    public function handle(ServerRequestInterface $request): ResponseInterface
    {
        $response = $this->middlewareDispatcher->handle($request);
 
        /**
         * This is to be in compliance with RFC 2616, Section 9.
         * If the incoming request method is HEAD, we need to ensure that the response body
         * is empty as the request may fall back on a GET route handler due to FastRoute's
         * routing logic which could potentially append content to the response body
         * https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.4
         */
        $method = strtoupper($request->getMethod());
        if ($method === 'HEAD') {
            $emptyBody = $this->responseFactory->createResponse()->getBody();
            return $response->withBody($emptyBody);
        }
 
        return $response;
    }
}
 

        return $bodyParsingMiddleware;
    }
 
    /**
     * Run application
     *
     * This method traverses the application middleware stack and then sends the
     * resultant Response object to the HTTP client.
     *
     * @param ServerRequestInterface|null $request
     * @return void
     */
    public function run(?ServerRequestInterface $request = null): void
    {
        if (!$request) {
            $serverRequestCreator = ServerRequestCreatorFactory::create();
            $request = $serverRequestCreator->createServerRequestFromGlobals();
        }
 
        $response = $this->handle($request);
        $responseEmitter = new ResponseEmitter();
        $responseEmitter->emit($response);
    }
 
    /**
     * Handle a request
     *
     * This method traverses the application middleware stack and then returns the
     * resultant Response object.
     *
     * @param ServerRequestInterface $request
     * @return ResponseInterface
     */
    public function handle(ServerRequestInterface $request): ResponseInterface
    {
        $response = $this->middlewareDispatcher->handle($request);
 
        /**
         * This is to be in compliance with RFC 2616, Section 9.
         * If the incoming request method is HEAD, we need to ensure that the response body

$app->get('/Admin/actors', AdminProfileController::class .':actors');
$app->get('/Admin/models', AdminProfileController::class .':models');
$app->get('/Admin/photographers', AdminProfileController::class .':photographers');
$app->get('/Admin/verification', AdminProfileController::class .':verification');
 
$app->get('/Admin', AdminStaticPageController::class .':index');
$app->get('/Admin/showprofile', AdminStaticPageController::class .':showprofile');
$app->get('/Admin/showprofileEdit', AdminStaticPageController::class .':showprofileEdit');
$app->get('/Admin/successMessage', AdminStaticPageController::class .':successMessage');
$app->get('/Admin/thank-you-profile', AdminStaticPageController::class .':thankYouProfile');
$app->get('/Admin/thank-you-publication', AdminStaticPageController::class .':thankYouPublication');
$app->get('/Admin/banned', AdminStaticPageController::class .':banned');
 
$app->get('/Admin/PHP/banProfile', ActionController::class .':banProfile');
$app->post('/Admin/PHP/deleteProfile', ActionController::class .':deleteProfile');
$app->get('/Admin/PHP/noticeBanProfile', ActionController::class .':noticeBanProfile');
$app->get('/Admin/PHP/submitProfileEdit', ActionController::class .':submitProfileEdit');
$app->get('/Admin/PHP/ajax/countFilteredUsers', ActionController::class .':countFilteredUsers');
 
$app->run();