<div class="col-md-3 "> <span class="titulo-topo-dados-ato">Data de Publicação:</span> </div> <div class="col-md-9"> <?= date("d/m/Y", strtotime($this->infoMateria["dt_previsao_publicacao"])) ?> </div> </div> <div class="row"> <div class="col-md-3 "> <span class="titulo-topo-dados-ato">Fonte:</span> </div> <div class="col-md-9"> <?php $ano = date("ymd", strtotime($this->infoMateria['dt_previsao_publicacao'])); ?> <?php $tpJornal = [29 => "EX", 30 => "SU", 31 => "NO", 32 => "ES"]; ?> <?php $nuJornal = str_pad($this->infoMateria['nu_numero'], 3, "0", STR_PAD_LEFT); ?> <?php $linkJornal = sprintf( "https://dodf.df.gov.br/%s%s%s%s", $ano, $tpJornal[$this->infoMateria["co_regra_jornal_tipo"]], $nuJornal, ($this->infoMateria["ds_letra"] ?? "")) ?> <a href="https://dodf.df.gov.br/?dt=1" target="_blank"> DODF <?= $nuJornal ?> - <?= $this->infoMateria["ds_secao"] ?> </a> </div> </div> <div class="row"> <div class="col-md-3 "> <span class="titulo-topo-dados-ato">Referenda:</span> </div> <div class="col-md-9"> <?= $this->infoData["lstItensAto"][0]["tx_referenda"] ?? "---" ?> </div> </div> <div class="row"> <div class="col-md-3 "> <span class="titulo-topo-dados-ato">Alteração:</span>

 if (array_key_exists('this', $__vars)) { unset($__vars['this']); } extract($__vars); unset($__vars); // remove $__vars from local scope // @codingStandardsIgnoreEnd $this->__content = ''; while ($this->__template = array_pop($this->__templates)) { $this->__file = $this->resolver($this->__template); if (! is_string($this->__file)) { throw new Exception\RuntimeException(sprintf( '%s: Unable to render template "%s"; resolver could not resolve to a file', __METHOD__, $this->__template )); } try { ob_start(); $includeReturn = include $this->__file; $this->__content = ob_get_clean(); } catch (Throwable $ex) { ob_end_clean(); throw $ex; } if ($includeReturn === false && $this->__content === '') { throw new Exception\UnexpectedValueException(sprintf( '%s: Unable to render template "%s"; file include failed', __METHOD__, $this->__file )); } } $this->setVars(array_pop($this->__varsCache)); if ($this->__filterChain instanceof FilterChain) { return $this->__filterChain->filter($this->__content); // filter output }

 $child = $this->mergeViewModel($child->getTemplate(), $child); if ($child !== $root) { $viewModelHelper = $renderer->plugin(Helper\ViewModel::class); $viewModelHelper->setRoot($root); } $result = $this->renderModel($child, $renderer, $root); if ($child->isAppend()) { $oldResult = $model->{$capture}; $model->setVariable($capture, $oldResult . $result); continue; } $model->setVariable($capture, $result); } return $renderer->render($model); } /** * Returns a PhpRenderer object */ private function createRenderer(): PhpRenderer { $renderer = new PhpRenderer(); $renderer->setResolver($this->getDefaultResolver()); return $renderer; } /** * Get the default resolver */ private function getDefaultResolver(): AggregateResolver { $resolver = new AggregateResolver(); $this->injectNamespacedResolver($resolver); return $resolver;

 } foreach ($model as $child) { if ($child->terminate()) { throw new Exception\RenderingException('Cannot render; encountered a child marked terminal'); } $capture = $child->captureTo(); if (empty($capture)) { continue; } $child = $this->mergeViewModel($child->getTemplate(), $child); if ($child !== $root) { $viewModelHelper = $renderer->plugin(Helper\ViewModel::class); $viewModelHelper->setRoot($root); } $result = $this->renderModel($child, $renderer, $root); if ($child->isAppend()) { $oldResult = $model->{$capture}; $model->setVariable($capture, $oldResult . $result); continue; } $model->setVariable($capture, $result); } return $renderer->render($model); } /** * Returns a PhpRenderer object */ private function createRenderer(): PhpRenderer { $renderer = new PhpRenderer(); $renderer->setResolver($this->getDefaultResolver());

 * * - a string layout template name * - a Laminas\View\Model\ModelInterface instance * * Layouts specified with $params take precedence over layouts passed to * * @param array|ModelInterface|object $params */ public function render(string $name, $params = []): string { $viewModel = $params instanceof ModelInterface ? $this->mergeViewModel($name, $params) : $this->createModel($name, $params); $useLayout = false !== $viewModel->getVariable('layout', null); if ($useLayout) { $viewModel = $this->prepareLayout($viewModel); } return $this->renderModel($viewModel, $this->renderer); } /** * Add a path for templates. */ public function addPath(string $path, ?string $namespace = null): void { $this->resolver->addPath($path, $namespace); } /** * Get the template directories * * @return TemplatePath[] */ public function getPaths(): array { $paths = []; /**

 $coAto = (int)$infoAto["lstItensAto"][0]["co_ato"]; $view["coData"] = $coAto; $view["infoData"] = $infoAto; $view["infoMateria"] = $this->modelMateria->infoMateria((int)$infoAto["lstItensAto"][0]["co_materia"]); $view["statusRevogacao"] = $this->modelAto->verificarStatusRevogacao([$coAto]); $view["atosVinculados"] = $this->modelAto->listarAtosItemVinculados($coAto); $view["lstAssuntos"] = $this->modelAto->listarAssuntos($coAto); $view["lstOrgaosEnvolvidos"] = $this->modelAto->listarOrgaosEnvolvidos($coAto); $view["lstClassificacaoDireito"] = $this->modelAto->listarClassificacaoDireito($coAto); $view["lstMensagensVinculadas"] = $this->modelMensagem->listarMensagensVinculadas($coAto); $view["urlMensagem"] = $_SERVER["APP_ENV"] === "development" ? "/analise/index/mensagem?co_data=" . $coAto . "&co_mensagem=" : "/ato.php?co_data=" . $coAto . "&tipo=mensagem&p=" . $dsSlug . "&co_mensagem="; } } if ($request->getMethod() != "GET") { return new JsonResponse($view); } $view["layout"] = "AnaliseLayout::basico"; return new HtmlResponse($this->template->render($this->url["render"], $view), 202); } } 

 public function __construct(RequestHandlerInterface $handler) { $this->handler = $handler; } /** * Proxies to decorated handler to handle the request. */ public function handle(ServerRequestInterface $request): ResponseInterface { return $this->handler->handle($request); } /** * Proxies to decorated handler to handle the request. */ public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface { return $this->handler->handle($request); } } 

use Mezzio\Exception\InvalidMiddlewareException; use Mezzio\MiddlewareContainer; use Psr\Http\Message\ResponseInterface; use Psr\Http\Message\ServerRequestInterface; use Psr\Http\Server\MiddlewareInterface; use Psr\Http\Server\RequestHandlerInterface; class LazyLoadingMiddleware implements MiddlewareInterface { public function __construct(private MiddlewareContainer $container, public readonly string $middlewareName) { } /** * @throws InvalidMiddlewareException For invalid middleware types pulled * from the container. */ public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface { return $this->container->get($this->middlewareName)->process($request, $handler); } } 

 private MiddlewareInterface $middleware, ?array $methods = self::HTTP_METHOD_ANY, ?string $name = null ) { $this->methods = is_array($methods) ? $this->validateHttpMethods($methods) : $methods; if ($name === null || $name === '') { $name = $this->methods === self::HTTP_METHOD_ANY ? $path : $path . '^' . implode(self::HTTP_METHOD_SEPARATOR, $this->methods); } $this->name = $name; } /** * Proxies to the middleware composed during instantiation. */ public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface { return $this->middleware->process($request, $handler); } /** @return non-empty-string */ public function getPath(): string { return $this->path; } /** * Set the route name. * * @param non-empty-string $name */ public function setName(string $name): void { $this->name = $name; } /** @return non-empty-string */ public function getName(): string

 } /** * Process the result as middleware. * * If the result represents a failure, it passes handling to the handler. * * Otherwise, it processes the composed middleware using the provided request * and handler. */ public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface { if ($this->isFailure()) { return $handler->handle($request); } $route = $this->getMatchedRoute(); assert($route instanceof MiddlewareInterface); return $route->process($request, $handler); } /** * Does the result represent successful routing? */ public function isSuccess(): bool { return $this->success; } /** * Retrieve the route that resulted in the route match. * * @return false|Route false if representing a routing failure; Route instance otherwise. */ public function getMatchedRoute() { return $this->route ?? false; } 

/** * Default dispatch middleware. * * Checks for a composed route result in the request. If none is provided, * delegates request processing to the handler. * * Otherwise, it delegates processing to the route result. * * @final */ class DispatchMiddleware implements MiddlewareInterface { public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface { $routeResult = $request->getAttribute(RouteResult::class, false); if (! $routeResult instanceof RouteResult) { return $handler->handle($request); } return $routeResult->process($request, $handler); } } 

use Mezzio\Exception\InvalidMiddlewareException; use Mezzio\MiddlewareContainer; use Psr\Http\Message\ResponseInterface; use Psr\Http\Message\ServerRequestInterface; use Psr\Http\Server\MiddlewareInterface; use Psr\Http\Server\RequestHandlerInterface; class LazyLoadingMiddleware implements MiddlewareInterface { public function __construct(private MiddlewareContainer $container, public readonly string $middlewareName) { } /** * @throws InvalidMiddlewareException For invalid middleware types pulled * from the container. */ public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface { return $this->container->get($this->middlewareName)->process($request, $handler); } } 

 $this->queue = clone $queue; $this->fallbackHandler = $fallbackHandler; } public function handle(ServerRequestInterface $request): ResponseInterface { if ($this->queue === null) { throw MiddlewarePipeNextHandlerAlreadyCalledException::create(); } if ($this->queue->isEmpty()) { $this->queue = null; return $this->fallbackHandler->handle($request); } $middleware = $this->queue->dequeue(); $next = clone $this; // deep clone is not used intentionally $this->queue = null; // mark queue as processed at this nesting level return $middleware->process($request, $next); } } 

 { } /** * Inject the helper with the request instance. * * Inject the UrlHelper instance with a RouteResult, if present as a request attribute. * Injects the helper, and then dispatches the next middleware. */ public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface { $this->helper->setRequest($request); $result = $request->getAttribute(RouteResult::class, false); if ($result instanceof RouteResult) { $this->helper->setRouteResult($result); } return $handler->handle($request); } } 

use Mezzio\Exception\InvalidMiddlewareException; use Mezzio\MiddlewareContainer; use Psr\Http\Message\ResponseInterface; use Psr\Http\Message\ServerRequestInterface; use Psr\Http\Server\MiddlewareInterface; use Psr\Http\Server\RequestHandlerInterface; class LazyLoadingMiddleware implements MiddlewareInterface { public function __construct(private MiddlewareContainer $container, public readonly string $middlewareName) { } /** * @throws InvalidMiddlewareException For invalid middleware types pulled * from the container. */ public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface { return $this->container->get($this->middlewareName)->process($request, $handler); } } 

 $this->queue = clone $queue; $this->fallbackHandler = $fallbackHandler; } public function handle(ServerRequestInterface $request): ResponseInterface { if ($this->queue === null) { throw MiddlewarePipeNextHandlerAlreadyCalledException::create(); } if ($this->queue->isEmpty()) { $this->queue = null; return $this->fallbackHandler->handle($request); } $middleware = $this->queue->dequeue(); $next = clone $this; // deep clone is not used intentionally $this->queue = null; // mark queue as processed at this nesting level return $middleware->process($request, $next); } } 

 { if (is_callable($responseFactory)) { // Factories are wrapped in a closure in order to enforce return type safety. $responseFactory = new CallableResponseFactoryDecorator( static function () use ($responseFactory): ResponseInterface { return $responseFactory(); } ); } $this->responseFactory = $responseFactory; } /** * Handle an implicit OPTIONS request. */ public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface { if ($request->getMethod() !== RequestMethod::METHOD_OPTIONS) { return $handler->handle($request); } $result = $request->getAttribute(RouteResult::class); if (! $result instanceof RouteResult) { return $handler->handle($request); } if ($result->isFailure() && ! $result->isMethodFailure()) { return $handler->handle($request); } if ($result->getMatchedRoute()) { return $handler->handle($request); } $allowedMethods = $result->getAllowedMethods(); assert(is_array($allowedMethods)); return $this->responseFactory->createResponse()->withHeader('Allow', implode(',', $allowedMethods)); }

use Mezzio\Exception\InvalidMiddlewareException; use Mezzio\MiddlewareContainer; use Psr\Http\Message\ResponseInterface; use Psr\Http\Message\ServerRequestInterface; use Psr\Http\Server\MiddlewareInterface; use Psr\Http\Server\RequestHandlerInterface; class LazyLoadingMiddleware implements MiddlewareInterface { public function __construct(private MiddlewareContainer $container, public readonly string $middlewareName) { } /** * @throws InvalidMiddlewareException For invalid middleware types pulled * from the container. */ public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface { return $this->container->get($this->middlewareName)->process($request, $handler); } } 

 $this->queue = clone $queue; $this->fallbackHandler = $fallbackHandler; } public function handle(ServerRequestInterface $request): ResponseInterface { if ($this->queue === null) { throw MiddlewarePipeNextHandlerAlreadyCalledException::create(); } if ($this->queue->isEmpty()) { $this->queue = null; return $this->fallbackHandler->handle($request); } $middleware = $this->queue->dequeue(); $next = clone $this; // deep clone is not used intentionally $this->queue = null; // mark queue as processed at this nesting level return $middleware->process($request, $next); } } 

 "result" => false, "flashMsg" => "404 - A página que você procura não foi encontrado em nosso sistema."], 200); } return new HtmlResponse($this->template->render('AcessoError::404', ["layout" => "AcessoLayout::simples"]), 404); } //ERROS DE ACESSO: Tentativa de acesso em locais sem permissão de acesso (401) if (!$this->acl->isAllowed($role, $resource, $privilege)) {//Não possui permissões para acessar if ($request->getMethod() == "POST") { return new JsonResponse([ "type" => "error", "result" => false, "flashMsg" => "401 - Acesso negado! Sua sessão expirou enquanto você estava navegando pelo site."], 401); } return new HtmlResponse($this->template->render('AcessoError::401', ["layout" => "AcessoLayout::simples"]), 401); } return $handler->handle($request);//Se tudo ocorrer bem segue para o próximo handler } /** * Retorna informações do usuário de acordo com o ambiente e outras variáveis * * @return object */ protected function informacoesDoUsuario() { try { $auth = new AuthenticationService(); $headers = function_exists('getallheaders') ? getallheaders() : []; if (!in_array(getenv('APP_ENV'), ['testing']) && !isset($headers['Authorization'])) { return (object)$auth->getIdentity(); } return Acesso::getIdentity(); } catch (\Exception $exc) {

use Mezzio\Exception\InvalidMiddlewareException; use Mezzio\MiddlewareContainer; use Psr\Http\Message\ResponseInterface; use Psr\Http\Message\ServerRequestInterface; use Psr\Http\Server\MiddlewareInterface; use Psr\Http\Server\RequestHandlerInterface; class LazyLoadingMiddleware implements MiddlewareInterface { public function __construct(private MiddlewareContainer $container, public readonly string $middlewareName) { } /** * @throws InvalidMiddlewareException For invalid middleware types pulled * from the container. */ public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface { return $this->container->get($this->middlewareName)->process($request, $handler); } } 

 $this->queue = clone $queue; $this->fallbackHandler = $fallbackHandler; } public function handle(ServerRequestInterface $request): ResponseInterface { if ($this->queue === null) { throw MiddlewarePipeNextHandlerAlreadyCalledException::create(); } if ($this->queue->isEmpty()) { $this->queue = null; return $this->fallbackHandler->handle($request); } $middleware = $this->queue->dequeue(); $next = clone $this; // deep clone is not used intentionally $this->queue = null; // mark queue as processed at this nesting level return $middleware->process($request, $next); } } 

 * @var Acesso */ private Acesso $modAcesso; public function __construct( public AdapterInterface $adapter, public Template\TemplateRendererInterface $template, public array $config ) { $this->modAcesso = new Acesso($adapter, $config); } public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface { $authorizationHeader = $request->getHeaderLine('Authorization'); //Verifica se o usuário não enviou bearer como authorization. if (!preg_match('/Bearer\s(\S+)/', $authorizationHeader, $matches)) { return $handler->handle($request); } $result = $this->modAcesso->validarJwtOffline($this->config['login'], $matches[1]); if (!isset($result->iss) || ($result->iss != $this->config['login']['API_TOKEN_URL'])) { return $result; } return $handler->handle($request); } } 

use Mezzio\Exception\InvalidMiddlewareException; use Mezzio\MiddlewareContainer; use Psr\Http\Message\ResponseInterface; use Psr\Http\Message\ServerRequestInterface; use Psr\Http\Server\MiddlewareInterface; use Psr\Http\Server\RequestHandlerInterface; class LazyLoadingMiddleware implements MiddlewareInterface { public function __construct(private MiddlewareContainer $container, public readonly string $middlewareName) { } /** * @throws InvalidMiddlewareException For invalid middleware types pulled * from the container. */ public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface { return $this->container->get($this->middlewareName)->process($request, $handler); } } 

 $this->queue = clone $queue; $this->fallbackHandler = $fallbackHandler; } public function handle(ServerRequestInterface $request): ResponseInterface { if ($this->queue === null) { throw MiddlewarePipeNextHandlerAlreadyCalledException::create(); } if ($this->queue->isEmpty()) { $this->queue = null; return $this->fallbackHandler->handle($request); } $middleware = $this->queue->dequeue(); $next = clone $this; // deep clone is not used intentionally $this->queue = null; // mark queue as processed at this nesting level return $middleware->process($request, $next); } } 

 public function __construct(private RouterInterface $router, callable|StreamFactoryInterface $streamFactory) { if (is_callable($streamFactory)) { $streamFactory = new CallableStreamFactoryDecorator($streamFactory); } $this->streamFactory = $streamFactory; } /** * Handle an implicit HEAD request. * * If the route allows GET requests, dispatches as a GET request and * resets the response body to be empty; otherwise, creates a new empty * response. */ public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface { if ($request->getMethod() !== RequestMethod::METHOD_HEAD) { return $handler->handle($request); } $result = $request->getAttribute(RouteResult::class); if (! $result instanceof RouteResult) { return $handler->handle($request); } if ($result->getMatchedRoute()) { return $handler->handle($request); } $routeResult = $this->router->match($request->withMethod(RequestMethod::METHOD_GET)); if ($routeResult->isFailure()) { return $handler->handle($request); } // Copy matched parameters like RouteMiddleware does /** @var mixed $value */ foreach ($routeResult->getMatchedParams() as $param => $value) { $request = $request->withAttribute($param, $value);

use Mezzio\Exception\InvalidMiddlewareException; use Mezzio\MiddlewareContainer; use Psr\Http\Message\ResponseInterface; use Psr\Http\Message\ServerRequestInterface; use Psr\Http\Server\MiddlewareInterface; use Psr\Http\Server\RequestHandlerInterface; class LazyLoadingMiddleware implements MiddlewareInterface { public function __construct(private MiddlewareContainer $container, public readonly string $middlewareName) { } /** * @throws InvalidMiddlewareException For invalid middleware types pulled * from the container. */ public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface { return $this->container->get($this->middlewareName)->process($request, $handler); } } 

 $this->queue = clone $queue; $this->fallbackHandler = $fallbackHandler; } public function handle(ServerRequestInterface $request): ResponseInterface { if ($this->queue === null) { throw MiddlewarePipeNextHandlerAlreadyCalledException::create(); } if ($this->queue->isEmpty()) { $this->queue = null; return $this->fallbackHandler->handle($request); } $middleware = $this->queue->dequeue(); $next = clone $this; // deep clone is not used intentionally $this->queue = null; // mark queue as processed at this nesting level return $middleware->process($request, $next); } } 

 public function __construct(RouterInterface $router) { $this->router = $router; } public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface { $result = $this->router->match($request); // Inject the actual route result, as well as individual matched parameters. $request = $request->withAttribute(RouteResult::class, $result); if ($result->isSuccess()) { /** @var mixed $value */ foreach ($result->getMatchedParams() as $param => $value) { $request = $request->withAttribute($param, $value); } } return $handler->handle($request); } /** * @internal This should only be used by unit tests. */ public function getRouter(): RouterInterface { return $this->router; } } 

use Mezzio\Exception\InvalidMiddlewareException; use Mezzio\MiddlewareContainer; use Psr\Http\Message\ResponseInterface; use Psr\Http\Message\ServerRequestInterface; use Psr\Http\Server\MiddlewareInterface; use Psr\Http\Server\RequestHandlerInterface; class LazyLoadingMiddleware implements MiddlewareInterface { public function __construct(private MiddlewareContainer $container, public readonly string $middlewareName) { } /** * @throws InvalidMiddlewareException For invalid middleware types pulled * from the container. */ public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface { return $this->container->get($this->middlewareName)->process($request, $handler); } } 

 $this->queue = clone $queue; $this->fallbackHandler = $fallbackHandler; } public function handle(ServerRequestInterface $request): ResponseInterface { if ($this->queue === null) { throw MiddlewarePipeNextHandlerAlreadyCalledException::create(); } if ($this->queue->isEmpty()) { $this->queue = null; return $this->fallbackHandler->handle($request); } $middleware = $this->queue->dequeue(); $next = clone $this; // deep clone is not used intentionally $this->queue = null; // mark queue as processed at this nesting level return $middleware->process($request, $next); } } 

use Psr\Http\Message\ResponseInterface; use Psr\Http\Message\ServerRequestInterface; use Psr\Http\Server\MiddlewareInterface; use Psr\Http\Server\RequestHandlerInterface; class ServerUrlMiddleware implements MiddlewareInterface { public function __construct(private ServerUrlHelper $helper) { } /** * Inject the ServerUrlHelper instance with the request URI. * Injects the ServerUrlHelper with the incoming request URI, and then invoke * the next middleware. */ public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface { $this->helper->setUri($request->getUri()); return $handler->handle($request); } } 

use Mezzio\Exception\InvalidMiddlewareException; use Mezzio\MiddlewareContainer; use Psr\Http\Message\ResponseInterface; use Psr\Http\Message\ServerRequestInterface; use Psr\Http\Server\MiddlewareInterface; use Psr\Http\Server\RequestHandlerInterface; class LazyLoadingMiddleware implements MiddlewareInterface { public function __construct(private MiddlewareContainer $container, public readonly string $middlewareName) { } /** * @throws InvalidMiddlewareException For invalid middleware types pulled * from the container. */ public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface { return $this->container->get($this->middlewareName)->process($request, $handler); } } 

 $this->queue = clone $queue; $this->fallbackHandler = $fallbackHandler; } public function handle(ServerRequestInterface $request): ResponseInterface { if ($this->queue === null) { throw MiddlewarePipeNextHandlerAlreadyCalledException::create(); } if ($this->queue->isEmpty()) { $this->queue = null; return $this->fallbackHandler->handle($request); } $middleware = $this->queue->dequeue(); $next = clone $this; // deep clone is not used intentionally $this->queue = null; // mark queue as processed at this nesting level return $middleware->process($request, $next); } } 

 /** * Middleware to handle errors and exceptions in layers it wraps. * * Adds an error handler that will convert PHP errors to ErrorException * instances. * * Internally, wraps the call to $next() in a try/catch block, catching * all PHP Throwables. * * When an exception is caught, an appropriate error response is created * and returned instead; otherwise, the response returned by $next is * used. */ public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface { set_error_handler($this->createErrorHandler()); try { $response = $handler->handle($request); } catch (Throwable $e) { $response = $this->handleThrowable($e, $request); } restore_error_handler(); return $response; } /** * Handles all throwables, generating and returning a response. * * Passes the error, request, and response prototype to createErrorResponse(), * triggers all listeners with the same arguments (but using the response * returned from createErrorResponse()), and then returns the response. */ private function handleThrowable(Throwable $e, ServerRequestInterface $request): ResponseInterface { $generator = $this->responseGenerator; $response = $generator($e, $request, ($this->responseFactory)());

use Mezzio\Exception\InvalidMiddlewareException; use Mezzio\MiddlewareContainer; use Psr\Http\Message\ResponseInterface; use Psr\Http\Message\ServerRequestInterface; use Psr\Http\Server\MiddlewareInterface; use Psr\Http\Server\RequestHandlerInterface; class LazyLoadingMiddleware implements MiddlewareInterface { public function __construct(private MiddlewareContainer $container, public readonly string $middlewareName) { } /** * @throws InvalidMiddlewareException For invalid middleware types pulled * from the container. */ public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface { return $this->container->get($this->middlewareName)->process($request, $handler); } } 

 $this->queue = clone $queue; $this->fallbackHandler = $fallbackHandler; } public function handle(ServerRequestInterface $request): ResponseInterface { if ($this->queue === null) { throw MiddlewarePipeNextHandlerAlreadyCalledException::create(); } if ($this->queue->isEmpty()) { $this->queue = null; return $this->fallbackHandler->handle($request); } $middleware = $this->queue->dequeue(); $next = clone $this; // deep clone is not used intentionally $this->queue = null; // mark queue as processed at this nesting level return $middleware->process($request, $next); } } 

 * If the pipeline is empty at the time this method is invoked, it will * raise an exception. * * @throws Exception\EmptyPipelineException If no middleware is present in * the instance in order to process the request. */ public function handle(ServerRequestInterface $request): ResponseInterface { return $this->process($request, new EmptyPipelineHandler(self::class)); } /** * PSR-15 middleware invocation. * * Executes the internal pipeline, passing $handler as the "final * handler" in cases when the pipeline exhausts itself. */ public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface { return (new Next($this->pipeline, $handler))->handle($request); } /** * Attach middleware to the pipeline. */ public function pipe(MiddlewareInterface $middleware): void { $this->pipeline->enqueue($middleware); } } 

 } /** * Handle an incoming request. * * Attempts to handle an incoming request by doing the following: * * - Cloning itself, to produce a request handler. * - Dequeuing the first middleware in the cloned handler. * - Processing the first middleware using the request and the cloned handler. * * If the pipeline is empty at the time this method is invoked, it will * raise an exception. * * @throws Exception\EmptyPipelineException If no middleware is present in * the instance in order to process the request. */ public function handle(ServerRequestInterface $request): ResponseInterface { return $this->process($request, new EmptyPipelineHandler(self::class)); } /** * PSR-15 middleware invocation. * * Executes the internal pipeline, passing $handler as the "final * handler" in cases when the pipeline exhausts itself. */ public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface { return (new Next($this->pipeline, $handler))->handle($request); } /** * Attach middleware to the pipeline. */ public function pipe(MiddlewareInterface $middleware): void { $this->pipeline->enqueue($middleware); }

 private RequestHandlerInterface $handler, private EmitterInterface $emitter, callable $serverRequestFactory, callable $serverRequestErrorResponseGenerator ) { $this->serverRequestFactory = $serverRequestFactory; $this->serverRequestErrorResponseGenerator = $serverRequestErrorResponseGenerator; } public function run(): void { try { $request = ($this->serverRequestFactory)(); } catch (Throwable $e) { // Error in generating the request $this->emitMarshalServerRequestException($e); return; } $response = $this->handler->handle($request); $this->emitter->emit($response); } private function emitMarshalServerRequestException(Throwable $exception): void { $response = ($this->serverRequestErrorResponseGenerator)($exception); $this->emitter->emit($response); } } 

 return $this->pipeline->handle($request); } /** * Proxies to composed pipeline to process. * {@inheritDocs} */ public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface { return $this->pipeline->process($request, $handler); } /** * Run the application. * * Proxies to the RequestHandlerRunner::run() method. */ public function run(): void { $this->runner->run(); } /** * Pipe middleware to the pipeline. * * If two arguments are present, they are passed to pipe(), after first * passing the second argument to the factory's prepare() method. * * If only one argument is presented, it is passed to the factory prepare() * method. * * The resulting middleware, in both cases, is piped to the pipeline. * * @param string|array|callable|MiddlewareInterface|RequestHandlerInterface $middlewareOrPath * Either the middleware to pipe, or the path to segregate the $middleware * by, via a PathMiddlewareDecorator. * @param null|string|array|callable|MiddlewareInterface|RequestHandlerInterface $middleware * If present, middleware or request handler to segregate by the path * specified in $middlewareOrPath. * @psalm-param string|MiddlewareParam $middlewareOrPath

chdir(dirname(__DIR__)); require 'vendor/autoload.php'; /** * Self-called anonymous function that creates its own scope and keep the global namespace clean. */ (function () { /** @var \Psr\Container\ContainerInterface $container */ $container = require 'config/container.php'; /** @var \Mezzio\Application $app */ $app = $container->get(\Mezzio\Application::class); $factory = $container->get(\Mezzio\MiddlewareFactory::class); // Execute programmatic/declarative middleware pipeline and routing // configuration statements (require 'config/pipeline.php')($app, $factory, $container); (require 'config/routes.php')($app, $factory, $container); $app->run(); })(); //Retorna a compactação do resultado html if (in_array(APP_ENV, ['production'])) { $html = ob_get_clean(); echo preg_replace('/\s+/', ' ', $html); }

require 'vendor/autoload.php'; /** * Self-called anonymous function that creates its own scope and keep the global namespace clean. */ (function () { /** @var \Psr\Container\ContainerInterface $container */ $container = require 'config/container.php'; /** @var \Mezzio\Application $app */ $app = $container->get(\Mezzio\Application::class); $factory = $container->get(\Mezzio\MiddlewareFactory::class); // Execute programmatic/declarative middleware pipeline and routing // configuration statements (require 'config/pipeline.php')($app, $factory, $container); (require 'config/routes.php')($app, $factory, $container); $app->run(); })(); //Retorna a compactação do resultado html if (in_array(APP_ENV, ['production'])) { $html = ob_get_clean(); echo preg_replace('/\s+/', ' ', $html); }