AbstractProvider::setFileLocator() - Code Metrics - Inspection of "Create new compatible phpvcr fixtures" - mediamonks/symfony-sonata-media-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 769352...7db90d )

unknown

created 2017-10-30 09:19 UTC

AbstractProvider::setFileLocator() A

↳ Parent: AbstractProvider

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	0
cts	3
cp	0
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	1
crap	2

<?php

namespace MediaMonks\SonataMediaBundle\Provider;

use League\Flysystem\FilesystemInterface;
use League\Glide\Filesystem\FilesystemException;
use MediaMonks\SonataMediaBundle\Client\HttpClientInterface;
use MediaMonks\SonataMediaBundle\ErrorHandlerTrait;
use MediaMonks\SonataMediaBundle\Model\AbstractMedia;
use MediaMonks\SonataMediaBundle\Form\Type\MediaFocalPointType;
use Sonata\AdminBundle\Form\FormMapper;
use Sonata\CoreBundle\Validator\ErrorElement;
use Symfony\Component\Form\Extension\Core\Type\FileType;
use Symfony\Component\Form\Extension\Core\Type\HiddenType;
use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\HttpFoundation\File\UploadedFile;
use Symfony\Component\HttpKernel\Config\FileLocator;
use Symfony\Component\Translation\TranslatorInterface;
use Symfony\Component\Validator\Constraints as Constraint;

abstract class AbstractProvider implements ProviderInterface
{
    use ErrorHandlerTrait;

    const SUPPORT_EMBED = 'embed';
    const SUPPORT_IMAGE = 'image';
    const SUPPORT_DOWNLOAD = 'download';

    const TYPE_AUDIO = 'audio';
    const TYPE_IMAGE = 'image';
    const TYPE_FILE = 'file';
    const TYPE_VIDEO = 'video';

    /**
     * @var FilesystemInterface
     */
    protected $filesystem;

    /**
     * @var TranslatorInterface
     */
    private $translator;

    /**
     * @var array
     */
    private $imageConstraintOptions = [];

    /**
     * @var HttpClientInterface
     */
    private $httpClient;

    /**
     * @var FileLocator
     */
    private $fileLocator;

    /**
     * @var AbstractMedia
     */
    private $media;

    /**
     * @param FilesystemInterface $filesystem
     */
    public function setFilesystem(FilesystemInterface $filesystem)
    {
        $this->filesystem = $filesystem;
    }

    /**
     * @param TranslatorInterface $translator
     */
    public function setTranslator(TranslatorInterface $translator)
    {
        $this->translator = $translator;
    }

    /**
     * @return \Symfony\Component\Translation\TranslatorInterface
     */
    public function getTranslator()
    {
        return $this->translator;
    }

    /**
     * @param array $options
     */
    public function setImageConstraintOptions(array $options)
    {
        $this->imageConstraintOptions = $options;
    }

    /**
     * @param HttpClientInterface $httpClient
     */
    public function setHttpClient(HttpClientInterface $httpClient)
    {
        $this->httpClient = $httpClient;
    }

    /**
     * @return FileLocator
     */
    public function getFileLocator()
    {
        return $this->fileLocator;
    }

    /**
     * @param FileLocator $fileLocator
     */
    public function setFileLocator(FileLocator $fileLocator)
    {
        $this->fileLocator = $fileLocator;
    }

    /**
     * @return HttpClientInterface
     */
    public function getHttpClient()
    {
        return $this->httpClient;
    }

    /**
     * @return FilesystemInterface
     */
    public function getFilesystem()
    {
        return $this->filesystem;
    }

    /**
     * @param AbstractMedia $media
     * @return AbstractProvider
     */
    public function setMedia($media)
    {
        $this->media = $media;

        return $this;
    }

    /**
     * @param AbstractMedia $media
     * @param $providerReferenceUpdated
     */
    public function update(AbstractMedia $media, $providerReferenceUpdated)
    {
        $this->updateImage($media);
    }

    /**
     * @param FormMapper $formMapper
     */
    public function buildCreateForm(FormMapper $formMapper)
    {
        $formMapper
            ->add('provider', 'hidden');

        $this->buildProviderCreateForm($formMapper);
    }

    /**
     * @param FormMapper $formMapper
     */
    public function buildEditForm(FormMapper $formMapper)
    {
        $formMapper
            ->tab('general')
            ->add('provider', HiddenType::class);

        $this->buildProviderEditFormBefore($formMapper);

        $formMapper->add(
            'imageContent',
            'file',
            [
                'required'    => false,
                'constraints' => [
                    new Constraint\File(),
                ],
                'label'       => 'form.replacement_image',
            ]
        )
            ->add('title', TextType::class, ['label' => 'form.title'])
            ->add(
                'description',
                TextType::class,
                ['label' => 'form.description', 'required' => false]
            )
            ->add(
                'authorName',
                TextType::class,
                ['label' => 'form.authorName', 'required' => false]
            )
            ->add(
                'copyright',
                TextType::class,
                ['label' => 'form.copyright', 'required' => false]
            )
            ->end()
            ->end()
            ->tab('image')
            ->add('focalPoint', MediaFocalPointType::class, [
                'media' => $this->media
            ])
            ->end()
            ->end()
        ;

        $this->buildProviderEditFormAfter($formMapper);
    }

    /**
     * @param FormMapper $formMapper
     * @codeCoverageIgnore
     */
    public function buildProviderEditFormBefore(FormMapper $formMapper)
    {
    }

    /**
     * @param FormMapper $formMapper
     * @codeCoverageIgnore
     */
    public function buildProviderEditFormAfter(FormMapper $formMapper)
    {
    }

    /**
     * @param AbstractMedia $media
     * @param bool $useAsImage
     * @return string|void
     */
    protected function handleFileUpload(AbstractMedia $media, $useAsImage = false)
    {
        /**
         * @var UploadedFile $file
         */
        $file = $media->getBinaryContent();

        if (empty($file)) {
            return;
        }

        $filename = $this->getFilenameByFile($file);
        $this->writeToFilesystem($file, $filename);

        $media->setProviderMetadata(
            array_merge(
                $media->getProviderMetaData(),
                $this->getFileMetaData($file)
            )
        );

        if (empty($media->getImage()) && $useAsImage) {
            $media->setImage($filename);
            $media->setImageMetaData($media->getProviderMetaData());
        }

        if (empty($media->getTitle())) {
            $media->setTitle(
                str_replace(
                    '_',
                    ' ',
                    pathinfo($file->getClientOriginalName(), PATHINFO_FILENAME)
                )
            );
        }

        return $filename;
    }

    /**
     * @param UploadedFile $file
     * @return array
     */
    protected function getFileMetaData(UploadedFile $file)
    {
        $fileData = [
            'originalName'      => $file->getClientOriginalName(),
            'originalExtension' => $file->getClientOriginalExtension(),
            'mimeType'          => $file->getClientMimeType(),
            'size'              => $file->getSize(),
        ];


        $this->disableErrorHandler();
        $imageSize = getimagesize($file->getRealPath());
        if (is_array($imageSize)) {
            if (is_int($imageSize[0]) && is_int($imageSize[1])) {
                $fileData['height'] = $imageSize[0];
                $fileData['width']  = $imageSize[1];
            }
            if (isset($imageSize['bits'])) {
                $fileData['bits'] = $imageSize['bits'];
            }
            if (isset($imageSize['channels'])) {
                $fileData['channels'] = $imageSize['channels'];
            }
        }
        $this->restoreErrorHandler();

        return $fileData;
    }

    /**
     * @param AbstractMedia $media
     */
    public function updateImage(AbstractMedia $media)
    {
        /**
         * @var UploadedFile $file
         */
        $file = $media->getImageContent();
        if (empty($file)) {
            return;
        }

        $filename = $this->getFilenameByFile($file);
        $this->writeToFilesystem($file, $filename);

        $media->setImage($filename);
        $media->setImageMetaData($this->getFileMetaData($file));
    }

    /**
     * @param \Sonata\AdminBundle\Form\FormMapper $formMapper
     * @param $name
     * @param $label
     * @param $required
     * @param array $constraints
     */
    protected function doAddFileField(
        FormMapper $formMapper,
        $name,
        $label,
        $required,
        $constraints = []
    ) {
        if ($required) {
            $constraints = array_merge(
                [
                    new Constraint\NotBlank(),
                    new Constraint\NotNull(),
                ],
                $constraints
            );
        }

        $formMapper
            ->add(
                $name,
                FileType::class,
                [
                    'multiple'    => false,
                    'data_class'  => null,
                    'constraints' => $constraints,
                    'label'       => $label,
                    'required'    => $required,
                ]
            );
    }

    /**
     * @param FormMapper $formMapper
     * @param string $name
     * @param string $label
     * @param array $options
     */
    public function addImageField(

        FormMapper $formMapper,
        $name,
        $label,
        $options = []
    ) {
        $this->doAddFileField(
            $formMapper,
            $name,
            $label,
            false,
            [
                new Constraint\Image(
                    array_merge($this->imageConstraintOptions, $options)
                ),
            ]
        );
    }

    /**
     * @param FormMapper $formMapper
     * @param $name
     * @param $label
     * @param array $options
     */
    public function addRequiredImageField(

        FormMapper $formMapper,
        $name,
        $label,
        $options = []
    ) {
        $this->doAddFileField(
            $formMapper,
            $name,
            $label,
            true,
            [
                new Constraint\Image(
                    array_merge($this->imageConstraintOptions, $options)
                ),
            ]
        );
    }

    /**
     * @param UploadedFile $file
     * @return string
     */
    protected function getFilenameByFile(UploadedFile $file)
    {
        return sprintf(
            '%s_%d.%s',
            sha1($file->getClientOriginalName()),
            time(),
            $file->getClientOriginalExtension()
        );
    }

    /**
     * @param UploadedFile $file
     * @param $filename
     * @throws FilesystemException
     */
    protected function writeToFilesystem(UploadedFile $file, $filename)
    {
        $this->disableErrorHandler();
        $stream = fopen($file->getRealPath(), 'r+');
        $written = $this->getFilesystem()->writeStream($filename, $stream);
        fclose($stream); // this sometime messes up
        $this->restoreErrorHandler();

        if (!$written) {
            throw new FilesystemException('Could not write to file system');
        }
    }

    /**
     * @param ErrorElement $errorElement
     * @param AbstractMedia $media
     */
    public function validate(ErrorElement $errorElement, AbstractMedia $media)
    {
    }

    /**
     * @return string
     */
    public function getEmbedTemplate()
    {
        return sprintf(
            'MediaMonksSonataMediaBundle:Provider:%s_embed.html.twig',
            $this->getName()
        );
    }
}


1			<?php
2
3			namespace MediaMonks\SonataMediaBundle\Provider;
4
5			use League\Flysystem\FilesystemInterface;
6			use League\Glide\Filesystem\FilesystemException;
7			use MediaMonks\SonataMediaBundle\Client\HttpClientInterface;
8			use MediaMonks\SonataMediaBundle\ErrorHandlerTrait;
9			use MediaMonks\SonataMediaBundle\Model\AbstractMedia;
10			use MediaMonks\SonataMediaBundle\Form\Type\MediaFocalPointType;
11			use Sonata\AdminBundle\Form\FormMapper;
12			use Sonata\CoreBundle\Validator\ErrorElement;
13			use Symfony\Component\Form\Extension\Core\Type\FileType;
14			use Symfony\Component\Form\Extension\Core\Type\HiddenType;
15			use Symfony\Component\Form\Extension\Core\Type\TextType;
16			use Symfony\Component\HttpFoundation\File\UploadedFile;
17			use Symfony\Component\HttpKernel\Config\FileLocator;
18			use Symfony\Component\Translation\TranslatorInterface;
19			use Symfony\Component\Validator\Constraints as Constraint;
20
21			abstract class AbstractProvider implements ProviderInterface
22			{
23			use ErrorHandlerTrait;
24
25			const SUPPORT_EMBED = 'embed';
26			const SUPPORT_IMAGE = 'image';
27			const SUPPORT_DOWNLOAD = 'download';
28
29			const TYPE_AUDIO = 'audio';
30			const TYPE_IMAGE = 'image';
31			const TYPE_FILE = 'file';
32			const TYPE_VIDEO = 'video';
33
34			/**
35			* @var FilesystemInterface
36			*/
37			protected $filesystem;
38
39			/**
40			* @var TranslatorInterface
41			*/
42			private $translator;
43
44			/**
45			* @var array
46			*/
47			private $imageConstraintOptions = [];
48
49			/**
50			* @var HttpClientInterface
51			*/
52			private $httpClient;
53
54			/**
55			* @var FileLocator
56			*/
57			private $fileLocator;
58
59			/**
60			* @var AbstractMedia
61			*/
62			private $media;
63
64			/**
65			* @param FilesystemInterface $filesystem
66			*/
67	1		public function setFilesystem(FilesystemInterface $filesystem)
68			{
69	1		$this->filesystem = $filesystem;
70	1		}
71
72			/**
73			* @param TranslatorInterface $translator
74			*/
75			public function setTranslator(TranslatorInterface $translator)
76			{
77			$this->translator = $translator;
78			}
79
80			/**
81			* @return \Symfony\Component\Translation\TranslatorInterface
82			*/
83			public function getTranslator()
84			{
85			return $this->translator;
86			}
87
88			/**
89			* @param array $options
90			*/
91			public function setImageConstraintOptions(array $options)
92			{
93			$this->imageConstraintOptions = $options;
94			}
95
96			/**
97			* @param HttpClientInterface $httpClient
98			*/
99	2		public function setHttpClient(HttpClientInterface $httpClient)
100			{
101	2		$this->httpClient = $httpClient;
102	2		}
103
104			/**
105			* @return FileLocator
106			*/
107			public function getFileLocator()
108			{
109			return $this->fileLocator;
110			}
111
112			/**
113			* @param FileLocator $fileLocator
114			*/
115			public function setFileLocator(FileLocator $fileLocator)
116			{
117			$this->fileLocator = $fileLocator;
118			}
119
120			/**
121			* @return HttpClientInterface
122			*/
123	2		public function getHttpClient()
124			{
125	2		return $this->httpClient;
126			}
127
128			/**
129			* @return FilesystemInterface
130			*/
131	1		public function getFilesystem()
132			{
133	1		return $this->filesystem;
134			}
135
136			/**
137			* @param AbstractMedia $media
138			* @return AbstractProvider
139			*/
140			public function setMedia($media)
141			{
142			$this->media = $media;
143
144			return $this;
145			}
146
147			/**
148			* @param AbstractMedia $media
149			* @param $providerReferenceUpdated
150			*/
151			public function update(AbstractMedia $media, $providerReferenceUpdated)
152			{
153			$this->updateImage($media);
154			}
155
156			/**
157			* @param FormMapper $formMapper
158			*/
159			public function buildCreateForm(FormMapper $formMapper)
160			{
161			$formMapper
162			->add('provider', 'hidden');
163
164			$this->buildProviderCreateForm($formMapper);
165			}
166
167			/**
168			* @param FormMapper $formMapper
169			*/
170			public function buildEditForm(FormMapper $formMapper)
171			{
172			$formMapper
173			->tab('general')
174			->add('provider', HiddenType::class);
175
176			$this->buildProviderEditFormBefore($formMapper);
177
178			$formMapper->add(
179			'imageContent',
180			'file',
181			[
182			'required' => false,
183			'constraints' => [
184			new Constraint\File(),
185			],
186			'label' => 'form.replacement_image',
187			]
188			)
189			->add('title', TextType::class, ['label' => 'form.title'])
190			->add(
191			'description',
192			TextType::class,
193			['label' => 'form.description', 'required' => false]
194			)
195			->add(
196			'authorName',
197			TextType::class,
198			['label' => 'form.authorName', 'required' => false]
199			)
200			->add(
201			'copyright',
202			TextType::class,
203			['label' => 'form.copyright', 'required' => false]
204			)
205			->end()
206			->end()
207			->tab('image')
208			->add('focalPoint', MediaFocalPointType::class, [
209			'media' => $this->media
210			])
211			->end()
212			->end()
213			;
214
215			$this->buildProviderEditFormAfter($formMapper);
216			}
217
218			/**
219			* @param FormMapper $formMapper
220			* @codeCoverageIgnore
221			*/
222			public function buildProviderEditFormBefore(FormMapper $formMapper)
223			{
224			}
225
226			/**
227			* @param FormMapper $formMapper
228			* @codeCoverageIgnore
229			*/
230			public function buildProviderEditFormAfter(FormMapper $formMapper)
231			{
232			}
233
234			/**
235			* @param AbstractMedia $media
236			* @param bool $useAsImage
237			* @return string\|void
238			*/
239			protected function handleFileUpload(AbstractMedia $media, $useAsImage = false)
240			{
241			/**
242			* @var UploadedFile $file
243			*/
244			$file = $media->getBinaryContent();
245
246			if (empty($file)) {
247			return;
248			}
249
250			$filename = $this->getFilenameByFile($file);
251			$this->writeToFilesystem($file, $filename);
252
253			$media->setProviderMetadata(
254			array_merge(
255			$media->getProviderMetaData(),
256			$this->getFileMetaData($file)
257			)
258			);
259
260			if (empty($media->getImage()) && $useAsImage) {
261			$media->setImage($filename);
262			$media->setImageMetaData($media->getProviderMetaData());
263			}
264
265			if (empty($media->getTitle())) {
266			$media->setTitle(
267			str_replace(
268			'_',
269			' ',
270			pathinfo($file->getClientOriginalName(), PATHINFO_FILENAME)
271			)
272			);
273			}
274
275			return $filename;
276			}
277
278			/**
279			* @param UploadedFile $file
280			* @return array
281			*/
282			protected function getFileMetaData(UploadedFile $file)
283			{
284			$fileData = [
285			'originalName' => $file->getClientOriginalName(),
286			'originalExtension' => $file->getClientOriginalExtension(),
287			'mimeType' => $file->getClientMimeType(),
288			'size' => $file->getSize(),
289			];
290
291
292			$this->disableErrorHandler();
293			$imageSize = getimagesize($file->getRealPath());
294			if (is_array($imageSize)) {
295			if (is_int($imageSize[0]) && is_int($imageSize[1])) {
296			$fileData['height'] = $imageSize[0];
297			$fileData['width'] = $imageSize[1];
298			}
299			if (isset($imageSize['bits'])) {
300			$fileData['bits'] = $imageSize['bits'];
301			}
302			if (isset($imageSize['channels'])) {
303			$fileData['channels'] = $imageSize['channels'];
304			}
305			}
306			$this->restoreErrorHandler();
307
308			return $fileData;
309			}
310
311			/**
312			* @param AbstractMedia $media
313			*/
314			public function updateImage(AbstractMedia $media)
315			{
316			/**
317			* @var UploadedFile $file
318			*/
319			$file = $media->getImageContent();
320			if (empty($file)) {
321			return;
322			}
323
324			$filename = $this->getFilenameByFile($file);
325			$this->writeToFilesystem($file, $filename);
326
327			$media->setImage($filename);
328			$media->setImageMetaData($this->getFileMetaData($file));
329			}
330
331			/**
332			* @param \Sonata\AdminBundle\Form\FormMapper $formMapper
333			* @param $name
334			* @param $label
335			* @param $required
336			* @param array $constraints
337			*/
338			protected function doAddFileField(
339			FormMapper $formMapper,
340			$name,
341			$label,
342			$required,
343			$constraints = []
344			) {
345			if ($required) {
346			$constraints = array_merge(
347			[
348			new Constraint\NotBlank(),
349			new Constraint\NotNull(),
350			],
351			$constraints
352			);
353			}
354
355			$formMapper
356			->add(
357			$name,
358			FileType::class,
359			[
360			'multiple' => false,
361			'data_class' => null,
362			'constraints' => $constraints,
363			'label' => $label,
364			'required' => $required,
365			]
366			);
367			}
368
369			/**
370			* @param FormMapper $formMapper
371			* @param string $name
372			* @param string $label
373			* @param array $options
374			*/
375		View Code Duplication	public function addImageField(
			0 ignored issues – show Duplication introduced 2017-08-08 08:19 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
376			FormMapper $formMapper,
377			$name,
378			$label,
379			$options = []
380			) {
381			$this->doAddFileField(
382			$formMapper,
383			$name,
384			$label,
385			false,
386			[
387			new Constraint\Image(
388			array_merge($this->imageConstraintOptions, $options)
389			),
390			]
391			);
392			}
393
394			/**
395			* @param FormMapper $formMapper
396			* @param $name
397			* @param $label
398			* @param array $options
399			*/
400		View Code Duplication	public function addRequiredImageField(
			0 ignored issues – show Duplication introduced 2017-08-08 08:19 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
401			FormMapper $formMapper,
402			$name,
403			$label,
404			$options = []
405			) {
406			$this->doAddFileField(
407			$formMapper,
408			$name,
409			$label,
410			true,
411			[
412			new Constraint\Image(
413			array_merge($this->imageConstraintOptions, $options)
414			),
415			]
416			);
417			}
418
419			/**
420			* @param UploadedFile $file
421			* @return string
422			*/
423			protected function getFilenameByFile(UploadedFile $file)
424			{
425			return sprintf(
426			'%s_%d.%s',
427			sha1($file->getClientOriginalName()),
428			time(),
429			$file->getClientOriginalExtension()
430			);
431			}
432
433			/**
434			* @param UploadedFile $file
435			* @param $filename
436			* @throws FilesystemException
437			*/
438	1		protected function writeToFilesystem(UploadedFile $file, $filename)
439			{
440	1		$this->disableErrorHandler();
441	1		$stream = fopen($file->getRealPath(), 'r+');
442	1		$written = $this->getFilesystem()->writeStream($filename, $stream);
443	1		fclose($stream); // this sometime messes up
444	1		$this->restoreErrorHandler();
445
446	1		if (!$written) {
447	1		throw new FilesystemException('Could not write to file system');
448			}
449			}
450
451			/**
452			* @param ErrorElement $errorElement
453			* @param AbstractMedia $media
454			*/
455			public function validate(ErrorElement $errorElement, AbstractMedia $media)
456			{
457			}
458
459			/**
460			* @return string
461			*/
462			public function getEmbedTemplate()
463			{
464			return sprintf(
465			'MediaMonksSonataMediaBundle:Provider:%s_embed.html.twig',
466			$this->getName()
467			);
468			}
469			}
470

mediamonks / symfony-sonata-media-bundle

Push — master ( 769352...7db90d )

AbstractProvider::setFileLocator() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like