/** * @param Request $request * @param $storageKey * * @return Response */ protected function createFileResponse(Request $request, $storageKey) { $response = new Response(); $parts = explode('/', $storageKey); $file = $this->getFile($parts[0]); if (!$file) { return $response->setContent('File not found.')->setStatusCode(Response::HTTP_NOT_FOUND); } if ($request->get('dl') !== null) { $filename = $file->getFilename(); if (count($parts) > 1) { $filename = $parts[count($parts) - 1]; } $filenameFallback = filter_var($filename, FILTER_SANITIZE_URL); if ($filenameFallback != $filename) { $guesser = ExtensionGuesser::getInstance(); $extension = filter_var($guesser->guess($file->getMimeType()) ?: $file->getExtension(), FILTER_SANITIZE_URL); $filenameFallback = $file->getStorageKey() . ($extension ? '.' . $extension : ''); } $response->headers->set('Content-Disposition', $response->headers->makeDisposition(ResponseHeaderBag::DISPOSITION_ATTACHMENT, $filename, $filenameFallback)); } else { $response->setCache(array('etag' => $file->getStorageKey(), 'last_modified' => $file->getCreatedAt())); if ($response->isNotModified($request)) { return $response; } } $response->setContent($file->getContents()); $response->headers->set('Content-type', $file->getMimeType()); $response->headers->set('Content-length', $file->getSize()); return $response; }
/** * @dataProvider provideLoadCases */ public function testLoad($rootDir, $path) { $loader = new FileSystemLoader(MimeTypeGuesser::getInstance(), ExtensionGuesser::getInstance(), $rootDir); $binary = $loader->find($path); $this->assertInstanceOf('Liip\\ImagineBundle\\Model\\Binary', $binary); $this->assertStringStartsWith('text/', $binary->getMimeType()); }
/** * Returns the extension based on the mime type. * * If the mime type is unknown, returns null. * * @return string|null The guessed extension or null if it cannot be guessed * * @api */ public function guessExtension() { $type = $this->getMimeType(); $guesser = ExtensionGuesser::getInstance(); return $guesser->guess($type); }
private function guessFileExtension($mimeType) { $candidate = ExtensionGuesser::getInstance()->guess($mimeType); if (!isset($candidate)) { return DEFAULT_FILE_EXTENSION; } return $candidate; }
/** * Gets the 'liip_imagine.extension_guesser' service. * * This service is shared. * This method always returns the same instance of the service. * * @return \Symfony\Component\HttpFoundation\File\MimeType\ExtensionGuesserInterface A Symfony\Component\HttpFoundation\File\MimeType\ExtensionGuesserInterface instance */ protected function getLiipImagine_ExtensionGuesserService() { return $this->services['liip_imagine.extension_guesser'] = \Symfony\Component\HttpFoundation\File\MimeType\ExtensionGuesser::getInstance(); }
/** * Set media binary content according to request content. * * @param MediaInterface $media */ protected function generateBinaryFromRequest(MediaInterface $media) { if (php_sapi_name() === 'cli') { throw new \RuntimeException('The current process cannot be executed in cli environment'); } if (!$media->getContentType()) { throw new \RuntimeException('You must provide the content type value for your media before setting the binary content'); } $request = $media->getBinaryContent(); if (!$request instanceof Request) { throw new \RuntimeException('Expected Request in binary content'); } $content = $request->getContent(); // create unique id for media reference $guesser = ExtensionGuesser::getInstance(); $extension = $guesser->guess($media->getContentType()); if (!$extension) { throw new \RuntimeException(sprintf('Unable to guess extension for content type %s', $media->getContentType())); } $handle = tmpfile(); fwrite($handle, $content); $file = new ApiMediaFile($handle); $file->setExtension($extension); $file->setMimetype($media->getContentType()); $media->setBinaryContent($file); }
/** * Returns an archive with the required content. * * @param array $nodes[] the nodes being exported * * @throws ExportResourceException * * @return array */ public function download(array $elements, $forceArchive = false) { $data = []; if (count($elements) === 0) { throw new ExportResourceException('No resources were selected.'); } $archive = new \ZipArchive(); $pathArch = $this->container->get('claroline.config.platform_config_handler')->getParameter('tmp_dir') . DIRECTORY_SEPARATOR . $this->ut->generateGuid() . '.zip'; $archive->open($pathArch, \ZipArchive::CREATE); $nodes = $this->expandResources($elements); if (!$forceArchive && count($nodes) === 1) { $event = $this->dispatcher->dispatch("download_{$nodes[0]->getResourceType()->getName()}", 'DownloadResource', [$this->getResourceFromNode($this->getRealTarget($nodes[0]))]); $extension = $event->getExtension(); $data['name'] = empty($extension) ? $nodes[0]->getName() : $nodes[0]->getName() . '.' . $extension; $data['file'] = $event->getItem(); $guesser = ExtensionGuesser::getInstance(); $data['mimeType'] = $guesser->guess($nodes[0]->getMimeType()) !== null ? $nodes[0]->getMimeType() : null; return $data; } if (isset($elements[0])) { $currentDir = $elements[0]; } else { $archive->addEmptyDir($elements[0]->getName()); } foreach ($nodes as $node) { //we only download is we can... if ($this->container->get('security.context')->isGranted('EXPORT', $node)) { $node = $this->getRealTarget($node); $resource = $this->getResourceFromNode($node); if ($resource) { if (get_class($resource) === 'Claroline\\CoreBundle\\Entity\\Resource\\ResourceShortcut') { $node = $resource->getTarget(); } $filename = $this->getRelativePath($currentDir, $node) . $node->getName(); $resource = $this->getResourceFromNode($node); //if it's a file, we may have to add the extension back in case someone removed it from the name if ($node->getResourceType()->getName() === 'file') { $extension = '.' . pathinfo($resource->getHashName(), PATHINFO_EXTENSION); if (!preg_match("#{$extension}#", $filename)) { $filename .= $extension; } } if ($node->getResourceType()->getName() !== 'directory') { $event = $this->dispatcher->dispatch("download_{$node->getResourceType()->getName()}", 'DownloadResource', [$resource]); $obj = $event->getItem(); if ($obj !== null) { $archive->addFile($obj, iconv(mb_detect_encoding($filename), $this->getEncoding(), $filename)); } else { $archive->addFromString(iconv(mb_detect_encoding($filename), $this->getEncoding(), $filename), ''); } } else { $archive->addEmptyDir(iconv(mb_detect_encoding($filename), $this->getEncoding(), $filename)); } $this->dispatcher->dispatch('log', 'Log\\LogResourceExport', [$node]); } } } $archive->close(); $tmpList = $this->container->getParameter('claroline.param.platform_generated_archive_path'); file_put_contents($tmpList, $pathArch . "\n", FILE_APPEND); $data['name'] = 'archive.zip'; $data['file'] = $pathArch; $data['mimeType'] = 'application/zip'; $this->container->get('claroline.core_bundle.listener.kernel_terminate_listener')->addElementToRemove($pathArch); return $data; }
/** * Validate file extension * * @param string $path * @return void */ protected function validateFileExtension($path) { $extensions = $this->getAllowedUploadExtensions(); // Get file mime type $mime = $this->filesystem->mimeType($path); $extensionGuesser = ExtensionGuesser::getInstance(); $extension = $extensionGuesser->guess($mime); $meta = ['extension' => $extension]; if (!in_array($extension, $extensions)) { throw new UnallowedFileExtensionException([$path], $meta, "Uploading [.{$extension}] file is prohibited"); } }
public function __construct() { $this->mimeTypeGuesser = MimeTypeGuesser::getInstance(); $this->extensionGuesserFromMimeType = ExtensionGuesserFromMimetype::getInstance(); }
/** * Process inline images. Convert it to embedded attachments and update message body. * * @param \Swift_Message $message * @param EmailModel $model */ protected function processEmbeddedImages(\Swift_Message $message, EmailModel $model) { if ($model->getType() === 'html') { $guesser = ExtensionGuesser::getInstance(); $body = $message->getBody(); $body = preg_replace_callback('/<img(.*)src(\\s*)=(\\s*)["\'](.*)["\']/U', function ($matches) use($message, $guesser, $model) { if (count($matches) === 5) { // 1st match contains any data between '<img' and 'src' parts (e.g. 'width=100') $imgConfig = $matches[1]; // 4th match contains src attribute value $srcData = $matches[4]; if (strpos($srcData, 'data:image') === 0) { list($mime, $content) = explode(';', $srcData); list($encoding, $file) = explode(',', $content); $mime = str_replace('data:', '', $mime); $fileName = sprintf('%s.%s', uniqid(), $guesser->guess($mime)); $swiftAttachment = \Swift_Image::newInstance(ContentDecoder::decode($file, $encoding), $fileName, $mime); /** @var $message \Swift_Message */ $id = $message->embed($swiftAttachment); $attachmentContent = new EmailAttachmentContent(); $attachmentContent->setContent($file); $attachmentContent->setContentTransferEncoding($encoding); $emailAttachment = new EmailAttachment(); $emailAttachment->setEmbeddedContentId($swiftAttachment->getId()); $emailAttachment->setFileName($fileName); $emailAttachment->setContentType($mime); $attachmentContent->setEmailAttachment($emailAttachment); $emailAttachment->setContent($attachmentContent); $emailAttachmentModel = new EmailAttachmentModel(); $emailAttachmentModel->setEmailAttachment($emailAttachment); $model->addAttachment($emailAttachmentModel); return sprintf('<img%ssrc="%s"', $imgConfig, $id); } } }, $body); $message->setBody($body, 'text/html'); } }
protected function getExtension($contentNode) { if ($contentNode->hasProperty('jcr:mimeType')) { $mimeType = $contentNode->getPropertyValue('jcr:mimeType'); $extension = ExtensionGuesser::getInstance()->guess($mimeType); if (null !== $extension) { return '.' . $extension; } } return ''; }
public function __construct() { $this->extensionGuesser = ExtensionGuesser::getInstance(); }
/** * Convert mime type to extension * * @param array $mimeTypes Mime types to conversation * * @return array */ protected function mimeTypesToExtensions($mimeTypes) { return array_filter(array_map(function ($mimeType) { return ExtensionGuesser::getInstance()->guess($mimeType); }, $mimeTypes), 'strlen'); }
public function testCouldBeConstructedWithExpectedArguments() { return new FlysystemLoader(ExtensionGuesser::getInstance(), $this->flyFilesystem); }
/** * Sets file metadata. * * @ORM\PrePersist() * * @return $this */ public function setFileMetadata() { $httpFile = $this->createHttpFile(); $this->mimeType = $httpFile->getMimeType(); $extensionGuesser = ExtensionGuesser::getInstance(); $this->extension = $extensionGuesser->guess($this->mimeType); return $this; }
/** * Should return an extension guesser instance, used for file uploads * * NOTE: If you override this, you'll probably still have to register the SVGExtensionGuesser as last guesser... * * @return ExtensionGuesserInterface */ public function get() { $guesser = ExtensionGuesser::getInstance(); $guesser->register(new SVGExtensionGuesser()); return $guesser; }
/** * @param Media $media * * @return \Gaufrette\File */ public function getOriginalFile(Media $media) { $relativePath = sprintf('/%s.%s', $media->getUuid(), ExtensionGuesser::getInstance()->guess($media->getContentType())); return $this->fileSystem->get($relativePath, true); }
/** * Guess extension . * * @param Image $image * @return string */ protected function guessExtension(Image $image) { $guesser = ExtensionGuesser::getInstance(); return $guesser->guess($image->mime()); }