d2/d3a/NotAllowed_8php_source.html

 <?php
 namespace Slim\Handlers;

 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\ResponseInterface;
 use Slim\Http\Body;
 use UnexpectedValueException;

 class NotAllowed extends AbstractHandler
 {
     public function __invoke(ServerRequestInterface $request, ResponseInterface $response, array $methods)
     {
         if ($request->getMethod() === 'OPTIONS') {
             $status = 200;
             $contentType = 'text/plain';
             $output = $this->renderPlainOptionsMessage($methods);
         } else {
             $status = 405;
             $contentType = $this->determineContentType($request);
             switch ($contentType) {
                 case 'application/json':
                     $output = $this->renderJsonNotAllowedMessage($methods);
                     break;

                 case 'text/xml':
                 case 'application/xml':
                     $output = $this->renderXmlNotAllowedMessage($methods);
                     break;

                 case 'text/html':
                     $output = $this->renderHtmlNotAllowedMessage($methods);
                     break;
                 default:
                     throw new UnexpectedValueException('Cannot render unknown content type ' . $contentType);
             }
         }

         $body = new Body(fopen('php://temp', 'r+'));
         $body->write($output);
         $allow = implode(', ', $methods);

         return $response
                 ->withStatus($status)
                 ->withHeader('Content-type', $contentType)
                 ->withHeader('Allow', $allow)
                 ->withBody($body);
     }

     protected function renderPlainOptionsMessage($methods)
     {
         $allow = implode(', ', $methods);

         return 'Allowed methods: ' . $allow;
     }

     protected function renderJsonNotAllowedMessage($methods)
     {
         $allow = implode(', ', $methods);

         return '{"message":"Method not allowed. Must be one of: ' . $allow . '"}';
     }

     protected function renderXmlNotAllowedMessage($methods)
     {
         $allow = implode(', ', $methods);

         return "<root><message>Method not allowed. Must be one of: $allow</message></root>";
     }

     protected function renderHtmlNotAllowedMessage($methods)
     {
         $allow = implode(', ', $methods);
         $output = <<<END
 <html>
     <head>
         <title>Method not allowed</title>
         <style>
             body{
                 margin:0;
                 padding:30px;
                 font:12px/1.5 Helvetica,Arial,Verdana,sans-serif;
             }
             h1{
                 margin:0;
                 font-size:48px;
                 font-weight:normal;
                 line-height:48px;
             }
         </style>
     </head>
     <body>
         <h1>Method not allowed</h1>
         <p>Method not allowed. Must be one of: <strong>$allow</strong></p>
     </body>
 </html>
 END;

         return $output;
     }
 }
Psr\Http\Message\RequestInterface\getMethod
getMethod()
Retrieves the HTTP method of the request.

Psr\Http\Message\ServerRequestInterface
Representation of an incoming, server-side HTTP request.
Definition: ServerRequestInterface.php:43

$request
foreach($paths as $path) $request
Definition: asyncclient.php:32

Symfony\Polyfill\Mbstring
Definition: Mbstring.php:12

Slim\Handlers\NotAllowed\renderXmlNotAllowedMessage
renderXmlNotAllowedMessage($methods)
Render XML not allowed message.
Definition: NotAllowed.php:104

Sabre\VObject\$output
$output
Definition: mergeduplicates.php:36

Psr\Http\Message\ResponseInterface\withStatus
withStatus($code, $reasonPhrase='')
Return an instance with the specified status code and, optionally, reason phrase. ...

Slim\Handlers\NotAllowed\renderPlainOptionsMessage
renderPlainOptionsMessage($methods)
Render PLAIN message for OPTIONS response.
Definition: NotAllowed.php:78

style
"color:#CC0000 style
Definition: example_001.php:92

strong

fopen

UnexpectedValueException

ServerRequestInterface

Slim\Handlers\AbstractHandler\determineContentType
determineContentType(ServerRequestInterface $request)
Determine which content type we know about is wanted using Accept header.
Definition: AbstractHandler.php:40

Slim\Handlers\NotAllowed\renderHtmlNotAllowedMessage
renderHtmlNotAllowedMessage($methods)
Render HTML not allowed message.
Definition: NotAllowed.php:117

Method
$sc Method
Definition: attributeserver.php:75

Slim\Handlers\NotAllowed\__invoke
__invoke(ServerRequestInterface $request, ResponseInterface $response, array $methods)
Invoke error handler.
Definition: NotAllowed.php:34

Psr\Http\Message\ResponseInterface
Representation of an outgoing, server-side response.
Definition: ResponseInterface.php:20

Body

size
font size
Definition: langcheck.php:162

Slim\Handlers\NotAllowed\renderJsonNotAllowedMessage
renderJsonNotAllowedMessage($methods)
Render JSON not allowed message.
Definition: NotAllowed.php:91

ResponseInterface

html
html()
Definition: IntegrationTest.php:14

Slim\Http\Body
Body.
Definition: Body.php:19

php

$contentType
if($path[strlen($path) - 1]==='/') if(is_dir($path)) if(!file_exists($path)) if(preg_match('#\.php$#D', mb_strtolower($path, 'UTF-8'))) $contentType
Definition: module.php:144

Slim\Handlers
Slim Framework (https://slimframework.com)
Definition: AbstractError.php:9

Slim\Handlers\NotAllowed
Default Slim application not allowed handler.
Definition: NotAllowed.php:22

$response
$response
Definition: proxy_ylocal.php:39

of

Slim\Handlers\AbstractHandler
Abstract Slim application handler.
Definition: AbstractHandler.php:16