e.g getMimeType('pdf'); // returns 'application/pdf'
public getMimeType ( string $alias ) : mixed | ||
$alias | string | the content type alias to map |
Результат | mixed | String mapped mime type or false if $alias is not mapped |
/** * Checks if the response can be considered different according to the request * headers, and the caching response headers. If it was not modified, then the * render process is skipped. And the client will get a blank response with a * "304 Not Modified" header. * * - If Router::extensions() is enabled, the layout and template type are * switched based on the parsed extension or Accept-Type header. For example, * if `controller/action.xml` is requested, the view path becomes * `app/View/Controller/xml/action.ctp`. Also if `controller/action` is * requested with `Accept-Type: application/xml` in the headers the view * path will become `app/View/Controller/xml/action.ctp`. Layout and template * types will only switch to mime-types recognized by Cake\Network\Response. * If you need to declare additional mime-types, you can do so using * Cake\Network\Response::type() in your controller's beforeFilter() method. * - If a helper with the same name as the extension exists, it is added to * the controller. * - If the extension is of a type that RequestHandler understands, it will * set that Content-type in the response header. * * @param Event $event The Controller.beforeRender event. * @return bool false if the render process should be aborted */ public function beforeRender(Event $event) { $isRecognized = !in_array($this->ext, ['html', 'htm']) && $this->response->getMimeType($this->ext); if (!empty($this->ext) && $isRecognized) { $this->renderAs($event->subject(), $this->ext); } elseif (empty($this->ext) || in_array($this->ext, ['html', 'htm'])) { $this->respondAs('html', ['charset' => Configure::read('App.encoding')]); } if ($this->_config['checkHttpCache'] && $this->response->checkNotModified($this->request)) { return false; } }
/** * The startup method of the RequestHandler enables several automatic behaviors * related to the detection of certain properties of the HTTP request, including: * * - If Router::extensions() is enabled, the layout and template type are * switched based on the parsed extension or Accept-Type header. For example, if `controller/action.xml` * is requested, the view path becomes `app/View/Controller/xml/action.ctp`. Also if * `controller/action` is requested with `Accept-Type: application/xml` in the headers * the view path will become `app/View/Controller/xml/action.ctp`. Layout and template * types will only switch to mime-types recognized by Cake\Network\Response. If you need to declare * additional mime-types, you can do so using Cake\Network\Response::type() in your controller's beforeFilter() * method. * - If a helper with the same name as the extension exists, it is added to the controller. * - If the extension is of a type that RequestHandler understands, it will set that * Content-type in the response header. * - If the XML data is POSTed, the data is parsed into an XML object, which is assigned * to the $data property of the controller, which can then be saved to a model object. * * @param Event $event The startup event that was fired. * @return void */ public function startup(Event $event) { $controller = $event->subject(); $request = $controller->request; if (isset($request->params['_ext'])) { $this->ext = $request->params['_ext']; } if (empty($this->ext) || in_array($this->ext, ['html', 'htm'])) { $this->_setExtension($request, $this->response); } if (empty($this->ext) && $request->is('ajax')) { $this->ext = 'ajax'; } $request->params['isAjax'] = $this->request->is('ajax'); $isRecognized = !in_array($this->ext, ['html', 'htm']) && $this->response->getMimeType($this->ext); if (!empty($this->ext) && $isRecognized) { $this->renderAs($controller, $this->ext); } elseif (empty($this->ext) || in_array($this->ext, ['html', 'htm'])) { $this->respondAs('html', ['charset' => Configure::read('App.encoding')]); } foreach ($this->_inputTypeMap as $type => $handler) { if ($this->requestedWith($type)) { $input = call_user_func_array([$request, 'input'], $handler); $request->data = (array) $input; } } }
/** * Asserts content type * * @param string $type The content-type to check for. * @param string $message The failure message that will be appended to the generated message. * @return void */ public function assertContentType($type, $message = '') { if (!$this->_response) { $this->fail('No response set, cannot assert content-type. ' . $message); } $alias = $this->_response->getMimeType($type); if ($alias !== false) { $type = $alias; } $result = $this->_response->type(); $this->assertEquals($type, $result, $message); }
/** * Returns an audio/video element * * ### Usage * * Using an audio file: * * ``` * echo $this->Html->media('audio.mp3', ['fullBase' => true]); * ``` * * Outputs: * * `<video src="http://www.somehost.com/files/audio.mp3">Fallback text</video>` * * Using a video file: * * ``` * echo $this->Html->media('video.mp4', ['text' => 'Fallback text']); * ``` * * Outputs: * * `<video src="/files/video.mp4">Fallback text</video>` * * Using multiple video files: * * ``` * echo $this->Html->media( * ['video.mp4', ['src' => 'video.ogv', 'type' => "video/ogg; codecs='theora, vorbis'"]], * ['tag' => 'video', 'autoplay'] * ); * ``` * * Outputs: * * ``` * <video autoplay="autoplay"> * <source src="/files/video.mp4" type="video/mp4"/> * <source src="/files/video.ogv" type="video/ogv; codecs='theora, vorbis'"/> * </video> * ``` * * ### Options * * - `tag` Type of media element to generate, either "audio" or "video". * If tag is not provided it's guessed based on file's mime type. * - `text` Text to include inside the audio/video tag * - `pathPrefix` Path prefix to use for relative URLs, defaults to 'files/' * - `fullBase` If provided the src attribute will get a full address including domain name * * @param string|array $path Path to the video file, relative to the webroot/{$options['pathPrefix']} directory. * Or an array where each item itself can be a path string or an associate array containing keys `src` and `type` * @param array $options Array of HTML attributes, and special options above. * @return string Generated media element */ public function media($path, array $options = []) { $options += ['tag' => null, 'pathPrefix' => 'files/', 'text' => '']; if (!empty($options['tag'])) { $tag = $options['tag']; } else { $tag = null; } if (is_array($path)) { $sourceTags = ''; foreach ($path as &$source) { if (is_string($source)) { $source = ['src' => $source]; } if (!isset($source['type'])) { $ext = pathinfo($source['src'], PATHINFO_EXTENSION); $source['type'] = $this->response->getMimeType($ext); } $source['src'] = $this->Url->assetUrl($source['src'], $options); $sourceTags .= $this->formatTemplate('tagselfclosing', ['tag' => 'source', 'attrs' => $this->templater()->formatAttributes($source)]); } unset($source); $options['text'] = $sourceTags . $options['text']; unset($options['fullBase']); } else { if (empty($path) && !empty($options['src'])) { $path = $options['src']; } $options['src'] = $this->Url->assetUrl($path, $options); } if ($tag === null) { if (is_array($path)) { $mimeType = $path[0]['type']; } else { $mimeType = $this->response->getMimeType(pathinfo($path, PATHINFO_EXTENSION)); } if (preg_match('#^video/#', $mimeType)) { $tag = 'video'; } else { $tag = 'audio'; } } if (isset($options['poster'])) { $options['poster'] = $this->Url->assetUrl($options['poster'], ['pathPrefix' => Configure::read('App.imageBaseUrl')] + $options); } $text = $options['text']; $options = array_diff_key($options, ['tag' => null, 'fullBase' => null, 'pathPrefix' => null, 'text' => null]); return $this->tag($tag, $text, $options); }
/** * The startup method of the RequestHandler enables several automatic behaviors * related to the detection of certain properties of the HTTP request, including: * * - If Router::extensions() is enabled, the layout and template type are * switched based on the parsed extension or Accept-Type header. For example, if `controller/action.xml` * is requested, the view path becomes `app/View/Controller/xml/action.ctp`. Also if * `controller/action` is requested with `Accept-Type: application/xml` in the headers * the view path will become `app/View/Controller/xml/action.ctp`. Layout and template * types will only switch to mime-types recognized by Cake\Network\Response. If you need to declare * additional mime-types, you can do so using Cake\Network\Response::type() in your controllers beforeFilter() * method. * - If a helper with the same name as the extension exists, it is added to the controller. * - If the extension is of a type that RequestHandler understands, it will set that * Content-type in the response header. * - If the XML data is POSTed, the data is parsed into an XML object, which is assigned * to the $data property of the controller, which can then be saved to a model object. * * @param Event $event The startup event that was fired. * @return void */ public function startup(Event $event) { $controller = $event->subject(); $controller->request->params['isAjax'] = $this->request->is('ajax'); $isRecognized = !in_array($this->ext, array('html', 'htm')) && $this->response->getMimeType($this->ext); if (!empty($this->ext) && $isRecognized) { $this->renderAs($controller, $this->ext); } elseif (empty($this->ext) || in_array($this->ext, array('html', 'htm'))) { $this->respondAs('html', array('charset' => Configure::read('App.encoding'))); } foreach ($this->_inputTypeMap as $type => $handler) { if ($this->requestedWith($type)) { $input = call_user_func_array(array($controller->request, 'input'), $handler); $controller->request->data = $input; } } }
/** * Tests the request object constructor * * @return void */ public function testConstruct() { $response = new Response(); $this->assertNull($response->body()); $this->assertEquals('UTF-8', $response->charset()); $this->assertEquals('text/html', $response->type()); $this->assertEquals(200, $response->statusCode()); $options = ['body' => 'This is the body', 'charset' => 'my-custom-charset', 'type' => 'mp3', 'status' => '203']; $response = new Response($options); $this->assertEquals('This is the body', $response->body()); $this->assertEquals('my-custom-charset', $response->charset()); $this->assertEquals('audio/mpeg', $response->type()); $this->assertEquals(203, $response->statusCode()); $options = ['body' => 'This is the body', 'charset' => 'my-custom-charset', 'type' => 'mp3', 'status' => '422', 'statusCodes' => [422 => 'Unprocessable Entity']]; $response = new Response($options); $this->assertEquals($options['body'], $response->body()); $this->assertEquals($options['charset'], $response->charset()); $this->assertEquals($response->getMimeType($options['type']), $response->type()); $this->assertEquals($options['status'], $response->statusCode()); }
/** * Maps a content type alias back to its mime-type(s) * * @param string|array $alias String alias to convert back into a content type. Or an array of aliases to map. * @return string Null on an undefined alias. String value of the mapped alias type. If an * alias maps to more than one content type, the first one will be returned. */ public function mapAlias($alias) { if (is_array($alias)) { return array_map(array($this, 'mapAlias'), $alias); } $type = $this->response->getMimeType($alias); if ($type) { if (is_array($type)) { return $type[0]; } return $type; } return null; }