function it_uploads_all_files_to_gaufrette(Filesystem $filesystem)
 {
     $filesystem->write('myArchive/aaa/a.txt', 'Test Cocoders content 123')->shouldBeCalled();
     $filesystem->write('myArchive/aaa/t.txt', 'Test Cocoders content!')->shouldBeCalled();
     $filesystem->write('myArchive/bbb', 'CDE !')->shouldBeCalled();
     $this->upload('myArchive', [vfsStream::url('tmp/23a/aaa/a.txt'), vfsStream::url('tmp/23a/aaa/t.txt'), vfsStream::url('tmp/23a/bbb')]);
 }
 public function upload($name, $paths)
 {
     $rootParent = $this->fetchRootPath($paths);
     foreach ($paths as $path) {
         $key = $this->generateKey($name, $rootParent, $path);
         $this->filesystem->write($key, file_get_contents($path));
     }
 }
 /**
  * @Given file :name exists
  * @Given dir :name exists
  * @Given file :name exists with content:
  * @Given I write :name with content:
  */
 public function fileExistsWithContent($name, PyStringNode $string = null)
 {
     if (null === $string) {
         $this->filesystem->createFile($name);
     } else {
         $this->filesystem->write($name, $string->__toString(), true);
     }
 }
Exemplo n.º 4
0
 /**
  * Saves an image.
  *
  * @param string $path
  * @param string $image
  *
  * @return string
  */
 public function saveImage($image, $path = null)
 {
     if ($path == null) {
         $path = 'images/' . uniqid() . '.png';
     }
     $this->files->write($path, $image, true);
     return $path;
 }
Exemplo n.º 5
0
 /**
  * @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);
 }
 /**
  * Store a file content.
  *
  * @param  UploadContext $context
  * @param $content
  * @param  array         $metadataMap
  * @return UploadedFile
  */
 public function store(UploadContext $context, $content, array $metadataMap = array())
 {
     $name = $this->namingStrategy->getName($context);
     $directory = $this->storageStrategy->getDirectory($context, $name);
     $path = $directory . '/' . $name;
     $adapter = $this->filesystem->getAdapter();
     if ($adapter instanceof MetadataSupporter) {
         $adapter->setMetadata($path, $this->resolveMetadataMap($context, $metadataMap));
     }
     $this->filesystem->write($path, $content);
     $file = $this->filesystem->get($path);
     return new UploadedFile($this, $file);
 }
Exemplo n.º 7
0
 /**
  * {@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()));
 }
Exemplo n.º 8
0
 public function testWriteThrowsAnExceptionIfTheFileAlreadyExistsAndIsNotAllowedToOverwrite()
 {
     $adapter = new InMemory(array('myFile' => array()));
     $fs = new Filesystem($adapter);
     $this->setExpectedException('InvalidArgumentException');
     $fs->write('myFile', 'some text');
 }
Exemplo n.º 9
0
 /**
  * @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;
 }
Exemplo n.º 10
0
 function it_duplicates_product_media($filesystem, ProductMediaInterface $source, ProductMediaInterface $target, File $newFile)
 {
     $target->setFile(Argument::any())->shouldBeCalled();
     $source->getOriginalFilename()->willReturn('akeneo.jpg');
     $target->getOriginalFilename()->willReturn('akeneo.jpg');
     // upload
     $target->getFile()->willReturn($newFile);
     $newFile->getPathname()->willReturn('/tmp/tmp-phpspec');
     // write a fake file in tmp
     $adapter = new LocalAdapter('/tmp');
     $fs = new Filesystem($adapter);
     $fs->write('tmp-phpspec', '', true);
     $source->getFilename()->willReturn('akeneo.jpg');
     $newFile->getFilename()->willReturn('akeneo.jpg');
     $filesystem->write('prefix-akeneo.jpg', '', false)->shouldBeCalled();
     $target->setOriginalFilename('akeneo.jpg')->shouldBeCalled();
     $target->setFilename('prefix-akeneo.jpg')->shouldBeCalled();
     $filesystem->has('akeneo.jpg')->willReturn(true);
     $target->getFilename()->willReturn('akeneo.jpg');
     $newFile->getMimeType()->willReturn('jpg');
     $target->setMimeType('jpg')->shouldBeCalled();
     // update original file name
     $source->getOriginalFilename()->willReturn('akeneo.jpg');
     $target->setOriginalFilename('akeneo.jpg')->shouldBeCalled();
     $this->duplicate($source, $target, 'prefix');
 }
 /**
  * @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'));
 }
Exemplo n.º 12
0
 /**
  * Retrieve information about artist (TopAlbum and track of album)
  */
 public function run()
 {
     $result = $this->serviceArtistInfo->setArtist($this->artistName)->getResults();
     if (!isset($result->error)) {
         $artist = new Artist();
         $artist->setName($this->artistName)->setInfo($result->artist->bio->summary);
         if (!is_array($result->artist->tags->tag)) {
             $tags = array($result->artist->tags->tag);
         } else {
             $tags = $result->artist->tags->tag;
         }
         foreach ($tags as $tagResult) {
             $tag = new ArtistTagDocument();
             $tag->setName($tagResult->name);
             $artist->addTag($tag);
         }
         $albumResult = $this->serviceArtistAlbum->setArtist($this->artistName)->getResults();
         if (!isset($albumResult->error)) {
             if (!is_array($albumResult->topalbums->album)) {
                 $albums = array($albumResult->topalbums->album);
             } else {
                 $albums = $albumResult->topalbums->album;
             }
             foreach ($albums as $albumResult) {
                 $album = new ArtistAlbumDocument();
                 $album->setName($albumResult->name)->setMbid($albumResult->mbid);
                 if (is_array($albumResult->image)) {
                     $image = $albumResult->image[count($albumResult->image) - 1];
                     $var = '#text';
                     if ('' !== $image->{$var}) {
                         $fileName = substr($image->{$var}, strrpos($image->{$var}, '/'));
                         $this->fileSystem->write($fileName, file_get_contents($image->{$var}));
                         $album->setImage($fileName);
                     }
                 }
                 if ($albumResult->mbid) {
                     $albumInfoResult = $this->serviceAlbumInfo->setArtist($this->artistName)->setMbid($albumResult->mbid)->getResults();
                     if (!isset($albumInfoResult->error)) {
                         if (!is_array($albumInfoResult->album->tracks->track)) {
                             $tracks = array($albumInfoResult->album->tracks->track);
                         } else {
                             $tracks = $albumInfoResult->album->tracks->track;
                         }
                         foreach ($tracks as $trackResult) {
                             $track = new ArtistTrackDocument();
                             $track->setName($trackResult->name)->setDuration($trackResult->duration);
                             $album->addTrack($track);
                         }
                     }
                     $artist->addAlbum($album);
                 }
             }
         }
         $this->artistQuery->persist($artist);
     }
 }
Exemplo n.º 13
0
 /**
  * {@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()));
     }
 }
Exemplo n.º 14
0
 public function execute(InputInterface $input, OutputInterface $output)
 {
     $file = $input->getArgument('file');
     $filesystem = new Filesystem(new Local('/'));
     $titlerator = new Titlerator(new Transliterator(Settings::LANG_SR), $filesystem->read($file));
     $titlerator->fixEncoding();
     if ($input->getOption('transliterate')) {
         $titlerator->transliterate();
     }
     $filesystem->write($file, $titlerator->getText(), true);
 }
 /**
  * @test
  * @group functional
  */
 public function shouldFetchKeys()
 {
     $this->assertEquals(array(), $this->filesystem->keys());
     $this->filesystem->write('foo', 'Some content');
     $this->filesystem->write('bar', 'Some content');
     $this->filesystem->write('baz', 'Some content');
     $actualKeys = $this->filesystem->keys();
     $this->assertEquals(3, count($actualKeys));
     foreach (array('foo', 'bar', 'baz') as $key) {
         $this->assertContains($key, $actualKeys);
     }
 }
Exemplo n.º 16
0
 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);
 }
Exemplo n.º 17
0
 /**
  * @param string $targetPath
  * @param array $replacePatterns
  * @return mixed|void
  */
 public function execute($targetPath = '', array $replacePatterns = array())
 {
     $adapter = new LocalAdapter($targetPath);
     $filesystem = new Filesystem($adapter);
     $listKeys = $filesystem->listKeys();
     if (count($replacePatterns) > 0) {
         foreach ($listKeys['keys'] as $file) {
             if (!@strstr(mime_content_type($targetPath . $file), 'image') && !@strstr($file, '.git') && !@strstr($file, '.svn')) {
                 $filesystem->write($file, $this->replaceContent($replacePatterns, $filesystem->read($file)), TRUE);
             }
         }
     }
 }
 function it_archives_unvalid_items(InvalidItemsCollector $collector, CsvWriter $writer, JobExecution $jobExecution, JobInstance $jobInstance, Filesystem $filesystem)
 {
     $collector->getInvalidItems()->willReturn(['items']);
     $jobExecution->getId()->willReturn('id');
     $jobExecution->getJobInstance()->willReturn($jobInstance);
     $jobInstance->getType()->willReturn('type');
     $jobInstance->getAlias()->willReturn('alias');
     $filesystem->write('type/alias/id/invalid/invalid_items.csv', '', true)->shouldBeCalled();
     $writer->setFilePath('/root/type/alias/id/invalid/invalid_items.csv')->shouldBeCalled();
     $writer->initialize()->shouldBeCalled();
     $writer->write(['items'])->shouldBeCalled();
     $writer->flush()->shouldBeCalled();
     $this->archive($jobExecution);
 }
Exemplo n.º 19
0
 /**
  * @param EmailAttachment $emailAttachment
  *
  * @return File|null
  */
 protected function copyEmailAttachmentToFileSystem(EmailAttachment $emailAttachment)
 {
     $file = new File();
     $file->setExtension($emailAttachment->getExtension());
     $file->setOriginalFilename($emailAttachment->getFileName());
     $file->setMimeType($emailAttachment->getContentType());
     $file->setFilename(uniqid() . '.' . $file->getExtension());
     $content = ContentDecoder::decode($emailAttachment->getContent()->getContent(), $emailAttachment->getContent()->getContentTransferEncoding());
     $this->filesystem->write($file->getFilename(), $content);
     $f = new ComponentFile($this->getAttachmentFullPath($file->getFilename()));
     $file->setFile($f);
     $file->setFileSize($f->getSize());
     $file->setUploaded(false);
     $file->setOwner($this->securityFacadeLink->getService()->getLoggedUser());
     return $file;
 }
 function it_create_a_file_when_reader_is_valid(CsvReader $reader, JobExecution $jobExecution, JobInstance $jobInstance, Job $job, ItemStep $step, $filesystem)
 {
     $jobExecution->getJobInstance()->willReturn($jobInstance);
     $jobExecution->getId()->willReturn(12);
     $jobInstance->getJob()->willReturn($job);
     $jobInstance->getType()->willReturn('type');
     $jobInstance->getAlias()->willReturn('alias');
     $job->getSteps()->willReturn([$step]);
     $step->getReader()->willReturn($reader);
     $reader->getFilePath()->willReturn('/tmp/tmp');
     $adapter = new LocalAdapter('/tmp');
     $fs = new Filesystem($adapter);
     $fs->write('tmp', '', true);
     $filesystem->write("type/alias/12/input/tmp", "", true)->shouldBeCalled();
     $this->archive($jobExecution);
 }
Exemplo n.º 21
0
 /**
  * Push a local image/variation to the remote.
  *
  * If it is not hydrated this function will throw an exception
  *
  * @param Image $image
  * @param bool  $overwrite
  *
  * @return $this
  *
  * @throws ImageManagerException
  * @throws ObjectAlreadyExistsException
  * @throws \Exception
  */
 public function push(Image $image, $overwrite = true)
 {
     if (!$image->isHydrated() && $image instanceof ImageVariation) {
         // A pull on a variation will check if the variation exists, if not create it
         $this->pull($image);
     }
     if (!$image->isHydrated()) {
         throw new ImageManagerException(self::ERR_NOT_HYDRATED);
     }
     if (!$overwrite && $this->tagExists($image->getKey()) === true) {
         throw new ObjectAlreadyExistsException(self::ERR_ALREADY_EXISTS);
     }
     $adapter = $this->filesystem->getAdapter();
     if ($adapter instanceof MetadataSupporter) {
         $metadata = [];
         if ($image->getMimeType()) {
             // Set image ContentType on remote filesystem
             $metadata['ContentType'] = $image->getMimeType();
         }
         $adapter->setMetadata($image->getKey(), $metadata);
     }
     // Retrieve source image metadata
     $metadata = null;
     if (!$image instanceof ImageVariation) {
         $image_manipulation = new ImageInspector();
         $metadata = $image_manipulation->getImageMetadata($image);
     }
     try {
         $this->filesystem->write($image->getKey(), $image->getData(), $overwrite);
         $image->__friendSet('persistent', true);
         $this->tag($image->getKey(), $metadata);
     } catch (FileAlreadyExists $e) {
         $this->tag($image->getKey(), $metadata);
         throw new ObjectAlreadyExistsException(self::ERR_ALREADY_EXISTS);
     }
     return $this;
 }
 /**
  * Display the list of entities handled by Doctrine and their fields
  *
  * @param array           $metadata
  * @param InputInterface  $input
  * @param OutputInterface $output
  */
 private function dumpMetadata(array $metadata, InputInterface $input, OutputInterface $output)
 {
     foreach ($metadata as $name => $meta) {
         $output->writeln(sprintf('<info>%s</info>', $name));
         foreach ($meta['fields'] as $fieldName => $columnName) {
             $output->writeln(sprintf('  <comment>></comment> %s <info>=></info> %s', $fieldName, $columnName));
         }
     }
     $output->writeln('---------------');
     $output->writeln('----  END  ----');
     $output->writeln('---------------');
     $output->writeln('');
     if ($input->getOption('filename')) {
         $directory = dirname($input->getOption('filename'));
         $filename = basename($input->getOption('filename'));
         if (empty($directory) || $directory == '.') {
             $directory = getcwd();
         }
         $adapter = new LocalAdapter($directory, true);
         $fileSystem = new Filesystem($adapter);
         $success = $fileSystem->write($filename, json_encode($metadata), true);
         if ($success) {
             $output->writeLn(sprintf('<info>File %s/%s successfully created</info>', $directory, $filename));
         } else {
             $output->writeLn(sprintf('<error>File %s/%s could not be created</error>', $directory, $filename));
         }
     }
 }
Exemplo n.º 23
0
 /**
  * {@inheritdoc}
  */
 public function set($id, Response $response)
 {
     $this->filesystem->write($id, serialize($response), true);
     $this->filesystem->write($id . '.etag', $response->getHeader('ETag'), true);
 }
Exemplo n.º 24
0
 /** @inheritDoc */
 public function putContents($path, $content)
 {
     $this->gaufrette->write($this->getGaufrettePath($path), $content, true);
 }
Exemplo n.º 25
0
 /**
  * @param \Gaufrette\Filesystem $filesystem
  */
 function it_sets_size_for_new_file($filesystem)
 {
     $filesystem->write('filename', 'some content', true)->shouldBeCalled()->willReturn(21);
     $this->setContent('some content');
     $this->getSize()->shouldReturn(21);
 }
Exemplo n.º 26
0
 /**
  * @param Config $config
  */
 public function persist(Config $config)
 {
     $this->filesystem->write($this->configFile, json_encode($config), true);
 }
Exemplo n.º 27
0
 /**
  * Write file in filesystem
  *
  * @param string  $filename  Filename
  * @param string  $content   File content
  * @param boolean $overwrite Overwrite file or not
  */
 protected function write($filename, $content, $overwrite = false)
 {
     $this->filesystem->write($filename, $content, $overwrite);
 }
 function it_returns_true_for_the_supported_job($writer, $jobExecution, $jobInstance, $job, $step)
 {
     $jobExecution->getJobInstance()->willReturn($jobInstance);
     $jobExecution->getId()->willReturn(12);
     $jobInstance->getJob()->willReturn($job);
     $jobInstance->getType()->willReturn('type');
     $jobInstance->getAlias()->willReturn('alias');
     $job->getSteps()->willReturn([$step]);
     $step->getWriter()->willReturn($writer);
     $writer->getWrittenFiles()->willReturn(['path_one']);
     $writer->getPath()->willReturn('/tmp/tmp');
     $adapter = new LocalAdapter('/tmp');
     $fs = new Filesystem($adapter);
     $fs->write('tmp', '', true);
     $this->supports($jobExecution)->shouldReturn(true);
 }
 function it_creates_a_file_if_writer_is_correct(CsvWriter $writer, JobExecution $jobExecution, JobInstance $jobInstance, Job $job, ItemStep $step, $factory, $filesystem)
 {
     $jobExecution->getJobInstance()->willReturn($jobInstance);
     $jobExecution->getId()->willReturn(12);
     $jobInstance->getJob()->willReturn($job);
     $jobInstance->getType()->willReturn('type');
     $jobInstance->getAlias()->willReturn('alias');
     $job->getSteps()->willReturn([$step]);
     $step->getWriter()->willReturn($writer);
     $writer->getWrittenFiles()->willReturn(['/tmp/tmp' => 'tmp', '/tmp/tmp2' => 'tmp2']);
     $writer->getPath()->willReturn('/tmp/tmp');
     $adapter = new LocalAdapter('/tmp');
     $fs = new Filesystem($adapter);
     $fs->write('tmp', '', true);
     $fs->write('tmp2', '', true);
     $factory->createZip(Argument::any())->willReturn($filesystem);
     $filesystem->write('tmp', '', true)->shouldBeCalled();
     $filesystem->write('tmp2', '', true)->shouldBeCalled();
     $this->archive($jobExecution);
 }
Exemplo n.º 30
0
 /**
  * Steps necessary to store an image
  *
  * @param ObjectManager             $imageObjectManager        Image ObjectManager
  * @param ImageManager              $imageManager              ImageManager
  * @param Filesystem                $filesystem                Filesystem
  * @param fileIdentifierTransformer $fileIdentifierTransformer fileIdentifierTransformer
  * @param ProductInterface          $product                   Product
  * @param string                    $imageName                 Image name
  *
  * @return $this Self object
  */
 protected function storeImage(ObjectManager $imageObjectManager, ImageManager $imageManager, Filesystem $filesystem, FileIdentifierTransformerInterface $fileIdentifierTransformer, ProductInterface $product, $imageName)
 {
     $imagePath = realpath(dirname(__FILE__) . '/images/' . $imageName);
     $image = $imageManager->createImage(new File($imagePath));
     $image->setPath('products');
     $imageObjectManager->persist($image);
     $imageObjectManager->flush($image);
     $filesystem->write($fileIdentifierTransformer->transform($image), file_get_contents($imagePath), true);
     $product->addImage($image);
     $product->setPrincipalImage($image);
     return $this;
 }