/** * @param string $fileKey * @param string $fileKeyWithFormat * @param Format $format * * @return */ protected function generateThumbnail($fileKey, $fileKeyWithFormat, Format $format) { // check if has original picture try { $has = $this->fileSystem->has($fileKey); } catch (\OutOfBoundsException $e) { $has = false; } if (!$has) { throw new Exception\ImageDoesNotExistException(); } // create thumbnail try { $blobOriginal = $this->fileSystem->read($fileKey); } catch (FileNotFound $e) { throw new Exception\ImageDoesNotExistException(); } $imagine = new Imagine(); $image = $imagine->load($blobOriginal); $resizedImage = Manipulator::resize($image, $format); $extension = $this->getExtension($fileKey); $blobResizedImage = $resizedImage->get($extension, array('jpeg_quality' => 90, 'png_compression_level' => 9)); $this->fileSystem->write($fileKeyWithFormat, $blobResizedImage, true); return $blobResizedImage; }
/** * @param Request $request * @param string $filename * * @throws NotFoundHttpException If media is not found * * @return Response */ public function showAction(Request $request, $filename) { if (!$this->filesystem->has($filename)) { throw new NotFoundHttpException(sprintf('Media "%s" not found', $filename)); } $response = new Response($content = $this->filesystem->read($filename)); $mime = $this->filesystem->mimeType($filename); if (($filter = $request->query->get('filter')) && null !== $mime && 0 === strpos($mime, 'image')) { try { $cachePath = $this->cacheManager->resolve($request, $filename, $filter); if ($cachePath instanceof Response) { $response = $cachePath; } else { $image = $this->imagine->load($content); $response = $this->filterManager->get($request, $filter, $image, $filename); $response = $this->cacheManager->store($response, $cachePath, $filter); } } catch (\RuntimeException $e) { if (0 === strpos($e->getMessage(), 'Filter not defined')) { throw new HttpException(404, sprintf('The filter "%s" cannot be found', $filter), $e); } throw $e; } } if ($mime) { $response->headers->set('Content-Type', $mime); } return $response; }
/** * Update attachment entity before upload * * @param File $entity */ public function preUpload(File $entity) { if ($entity->isEmptyFile()) { if ($this->filesystem->has($entity->getFilename())) { $this->filesystem->delete($entity->getFilename()); } $entity->setFilename(null); $entity->setExtension(null); $entity->setOriginalFilename(null); } if ($entity->getFile() !== null && $entity->getFile()->isFile()) { $entity->setOwner($this->securityFacadeLink->getService()->getLoggedUser()); $file = $entity->getFile(); if ($entity->getFilename() !== null && $this->filesystem->has($entity->getFilename())) { $this->filesystem->delete($entity->getFilename()); } $entity->setExtension($file->guessExtension()); if ($file instanceof UploadedFile) { $entity->setOriginalFilename($file->getClientOriginalName()); $entity->setMimeType($file->getClientMimeType()); $entity->setFileSize($file->getClientSize()); } else { $entity->setOriginalFilename($file->getFileName()); $entity->setMimeType($file->getMimeType()); $entity->setFileSize($file->getSize()); } $entity->setFilename(uniqid() . '.' . $entity->getExtension()); if ($this->filesystem->getAdapter() instanceof MetadataSupporter) { $this->filesystem->getAdapter()->setMetadata($entity->getFilename(), ['contentType' => $entity->getMimeType()]); } } }
/** * delete the given file * * @param string $file */ public function deleteFile($file) { if (!$this->filesystem->has($file)) { return; } $this->filesystem->delete($file); $this->cacheManager->remove($file); }
/** * @param mixed $data * @param int $mode * @return int */ public function write($data, $mode = 0) { if ($mode & FILE_APPEND) { $data = $this->read() . $data; } if (!$this->gaufrette->has($this->filePath)) { $this->gaufrette->createFile($this->filePath); } return $this->gaufrette->write($this->filePath, $data, true); }
/** * {@inheritdoc} */ public function upload(ImageInterface $image) { if (!$image->hasFile()) { return; } if (null !== $image->getPath()) { $this->remove($image->getPath()); } do { $hash = md5(uniqid(mt_rand(), true)); $path = $this->expandPath($hash . '.' . $image->getFile()->guessExtension()); } while ($this->filesystem->has($path)); $image->setPath($path); $this->filesystem->write($image->getPath(), file_get_contents($image->getFile()->getPathname())); }
function let(Filesystem $filesystem, ImageInterface $image) { $filesystem->has(Argument::any())->willReturn(false); $file = new File(__FILE__, 'img.jpg'); $image->getFile()->willReturn($file); $this->beConstructedWith($filesystem); }
/** * @test * @group functional */ public function shouldDeleteFile() { $this->filesystem->write('foo', 'Some content'); $this->assertTrue($this->filesystem->has('foo')); $this->filesystem->delete('foo'); $this->assertFalse($this->filesystem->has('foo')); }
/** * Predicate to know if file exists physically * * @param ProductMediaInterface $media * * @return bool */ protected function fileExists(ProductMediaInterface $media) { if (null === $media->getFilename()) { return false; } return $this->filesystem->has($media->getFilename()); }
private function read(Filesystem $fs) { $profileFilename = Application::PROFILE_FILENAME; if ($fs->has($profileFilename)) { $this->processProfileContent($fs->read($profileFilename)); } }
/** * @test * @group functional */ public function shouldWorkWithHiddenFiles() { $this->filesystem->write('.foo', 'hidden'); $this->assertTrue($this->filesystem->has('.foo')); $this->assertContains('.foo', $this->filesystem->keys()); $this->filesystem->delete('.foo'); $this->assertFalse($this->filesystem->has('.foo')); }
/** * {@inheritdoc} */ public function upload(MediaInterface $media, $name = null, $test = false) { if (!$media->hasMedia()) { return; } if (null !== $media->getName()) { $this->remove($media->getName()); } do { $hash = md5(uniqid(mt_rand(), true)); if ($test === false) { $name = $hash . '.' . $media->getMedia()->guessExtension(); } } while ($this->filesystem->has($name)); $media->setName($name); if ($test === false) { $this->filesystem->write($media->getName(), file_get_contents($media->getMedia()->getPathname())); } }
function it_uploads_without_removing(MediaInterface $media, Filesystem $filesystem, UploadedFile $file) { $media->hasMedia()->shouldBeCalled()->willReturn(true); $media->getName()->shouldBeCalled()->willReturn(null); $media->getMedia()->shouldBeCalled()->willReturn($file); $file->guessExtension()->shouldBeCalled()->willReturn('md'); $filesystem->has(Argument::containingString('.md'))->shouldBeCalled()->willReturn(false); $media->setName(Argument::any())->shouldBeCalled()->willReturn($media); $media->getMedia()->shouldBeCalled()->willReturn($file); $file->getPathname()->shouldBeCalled()->willReturn(__DIR__ . '/../../../../../README.md'); $filesystem->write(Argument::any(), file_get_contents(__DIR__ . '/../../../../../README.md'))->shouldBeCalled()->willReturn(Argument::type('int')); $this->upload($media); }
public function cleanup(UserProfile $prop) { if ($prop->getProperty()->getFieldType() === ProfileProperty::TYPE_FILE) { /*$fileName = str_replace($this->getBaseFileUrl() . '/', '', $prop->getPropertyValue()); if ( is_file($this->getBaseFilePath() . '/' . $fileName) ) { echo 'maybe removing ' . $this->getBaseFilePath() . '/' . $fileName; @unlink($this->getBaseFilePath() . '/' . $fileName); }*/ $fileKey = AbstractUploader::extractKey($prop->getPropertyValue(), $this->awsBucket); if ($fileKey && $this->filesystem->has($fileKey)) { $this->filesystem->delete($fileKey); } } }
public function has($id) { return $this->filesystem->has($id); }
/** * @param \Gaufrette\Filesystem $filesystem */ function it_check_if_file_with_key_exists_in_filesystem($filesystem) { $filesystem->has('filename')->willReturn(true); $this->exists()->shouldReturn(true); $filesystem->has('filename')->willReturn(false); $this->exists()->shouldReturn(false); }
/** * @return string */ public function getJson() { return $this->filesystem->has($this->configFile) ? $this->filesystem->get($this->configFile, true)->getContent() : '{}'; }
/** * Get Virtual Files Action * * @param string $file * * @throws NotFoundHttpException * @return Response */ public function fileAction($file = null) { if (null == $file) { return $this->redirect($this->generateUrl('vfs_files', array('file' => '/'))); } $cacheDirectory = $this->getParameter('adapter_cache_dir'); $local = new LocalAdapter($cacheDirectory, true); $localadapter = new LocalAdapter($this->getParameter('adapter_files')); $adapter = new CacheAdapter($localadapter, $local, 3600); $fsAvatar = new Filesystem($adapter); if ($this->endswith($file, '/')) { if ($fsAvatar->has($file)) { $this->gvars['title'] = $this->translate('indexof', array('%dir%' => $this->generateUrl('vfs_files', array('file' => $file)))); $this->gvars['pagetitle'] = $this->translate('indexof_raw', array('%dir%' => $this->generateUrl('vfs_files', array('file' => $file)))); $path = substr($file, 1); $fs = $fsAvatar->listKeys($path); $listfiles = array(); foreach ($fs['dirs'] as $key) { $fulldir = $key . '/'; $dirname = $key; if (substr($key, 0, strlen($path)) == $path) { $dirname = substr($dirname, strlen($path)); } if (!strstr($dirname, '/')) { $listfiles[$fulldir] = $dirname; } } foreach ($fs['keys'] as $key) { $fullfile = $key; $filename = $key; if (substr($key, 0, strlen($path)) == $path) { $filename = substr($filename, strlen($path)); } if (!strstr($filename, '/')) { $listfiles[$fullfile] = $filename; } } $this->gvars['fs'] = $listfiles; return $this->renderResponse('AcfResBundle:Vfs:list_files.html.twig', $this->gvars); } else { throw new NotFoundHttpException(); } } if ($fsAvatar->has($file)) { if ($fsAvatar->getAdapter()->isDirectory($file)) { $file .= '/'; return $this->redirect($this->generateUrl('vfs_files', array('file' => $file))); } $reqFile = $fsAvatar->get($file); $response = new Response(); $response->headers->set('Content-Type', 'binary'); $response->setContent($reqFile->getContent()); return $response; } else { throw new NotFoundHttpException(); } }
/** * Predicate to know if file exists physically * * @param AbstractProductMedia $media * * @return boolean */ protected function fileExists(AbstractProductMedia $media) { return $this->filesystem->has($media->getFilename()); }
/** * Whether there is a file or directory at the given path. * * @param string $path Filesystem-relative path to check for existence. * * @return boolean */ private function exists($path) { return $this->gaufrette->has($this->getGaufrettePath($path)); }
/** * Check with the filesystem if the image exists and update the image key cache. * * @param Image $image * * @return bool */ protected function validateTag(Image $image) { $exists = $this->filesystem->has($image->getKey()); $this->setImageExists($image, $exists); return $exists; }
/** * @param Filesystem $localFilesyste * @param Filesystem $remoteFilesyste * * @throws \RuntimeException */ private function validateFilesytems(Filesystem $localFilesyste, Filesystem $remoteFilesyste) { if (!$remoteFilesyste->has('shopware.php')) { throw new \RuntimeException("shopware.php not found in remote filesystem"); } if (!$localFilesyste->has('shopware.php')) { throw new \RuntimeException("shopware.php not found in local filesystem"); } if ($localFilesyste->checksum('shopware.php') != $remoteFilesyste->checksum('shopware.php')) { throw new \RuntimeException("Filesytems does not seem to match"); } }
/** @inheritDoc */ public function isFile($path) { return !$this->isDirectory($path) && $this->gaufrette->has($this->getGaufrettePath($path)); }
/** * @inheritdoc */ public function has($path) { return $this->filesystem->has($path); }
/** * Algorithm to transform names from name.txt to name_i.txt and name_i.txt into name_{i++}.txt * when given key already exists and can't be reused. * * @param \FSi\DoctrineExtensions\Uploadable\Keymaker\KeymakerInterface $keymaker * @param object $object * @param string $property * @param mixed $id * @param string $fileName * @param integer $keyLength * @param string $keyPattern * @param \FSi\DoctrineExtensions\Uploadable\Filesystem $filesystem * @throws \FSi\DoctrineExtensions\Uploadable\Exception\RuntimeException * @return string */ private function generateNewKey(KeymakerInterface $keymaker, $object, $property, $id, $fileName, $keyLength, $keyPattern, Filesystem $filesystem) { while ($filesystem->has($newKey = $keymaker->createKey($object, $property, $id, $fileName, $keyPattern))) { if ($match = preg_match('/(.*)_(\\d+)(\\.[^\\.]*)?$/', $fileName, $matches)) { $fileName = sprintf('%s_%s%s', $matches[1], strval($matches[2] + 1), isset($matches[3]) ? $matches[3] : ''); } else { $fileParts = explode('.', $fileName); if (count($fileParts) > 1) { $fileParts[count($fileParts) - 1] .= '_1'; $fileName = implode('.', $fileParts); } else { $fileName .= '_1'; } } } if (mb_strlen($newKey) > $keyLength) { throw new RuntimeException(sprintf('Generated key exceeded limit of %d characters (had %d characters).', $keyLength, mb_strlen($newKey))); } return $newKey; }
public function getETag($id) { if ($this->filesystem->has($id)) { return $this->filesystem->read($id . '.etag'); } }
/** * {@inheritdoc} */ public function childExists($name) { return $this->filesystem->has($this->prefix . $name); }