AbstractProvider - Code Metrics - Inspection of "Improved some SensioLabs Insights violations" - mediamonks/symfony-sonata-media-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 9f73c5...5f3db3 )

unknown

created 2017-06-19 12:48 UTC

AbstractProvider B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	466
Duplicated Lines	7.73 %

Coupling/Cohesion

Components	4
Dependencies	10

Test Coverage

Coverage

94.32%

Importance

Changes

Metric	Value
wmc	41
lcom	4
cbo	10
dl	36
loc	466
ccs	166
cts	176
cp	0.9432
rs	8.2769
c	0
b	0
f	0

26 Methods

Rating	Name	Duplication	Size	Complexity
A	buildCreateForm()	0	7	1
A	buildProviderEditFormBefore()	0	3	1
A	buildProviderEditFormAfter()	0	3	1
A	buildEditForm()	0	47	1
B	handleFileUpload()	0	38	5
A	setFilesystem()	0	4	1
A	setTranslator()	0	4	1
A	getTranslator()	0	4	1
A	setImageConstraintOptions()	0	4	1
A	setHttpClient()	0	4	1
A	getFileLocator()	0	4	1
A	setFileLocator()	0	4	1
A	getHttpClient()	0	4	1
A	getFilesystem()	0	4	1
A	setMedia()	0	6	1
A	update()	0	4	1
B	getFileMetaData()	0	28	6
A	updateImage()	0	16	2
B	doAddFileField()	0	30	2
A	addImageField()	18	18	1
A	addRequiredImageField()	18	18	1
A	getFilenameByFile()	0	9	1
A	writeToFilesystem()	0	12	2
A	supports()	0	14	4
A	validate()	0	3	1
A	getEmbedTemplate()	0	7	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like AbstractProvider often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use AbstractProvider, and based on these observations, apply Extract Interface, too.

<?php

namespace MediaMonks\SonataMediaBundle\Provider;

use League\Flysystem\Filesystem;
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 Filesystem
     */
    protected $filesystem;

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

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

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

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

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

    /**
     * @param Filesystem $filesystem
     */
    public function setFilesystem(Filesystem $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 Filesystem
     */
    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
     */
    public function buildProviderEditFormBefore(FormMapper $formMapper)
    {
    }

    /**
     * @param FormMapper $formMapper
     */
    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 $renderType
     * @return boolean
     */
    public function supports($renderType)
    {
        if ($renderType === self::SUPPORT_EMBED) {
            return $this->supportsEmbed();
        }
        if ($renderType === self::SUPPORT_IMAGE) {
            return $this->supportsImage();
        }
        if ($renderType === self::SUPPORT_DOWNLOAD) {
            return $this->supportsDownload();
        }

        return false;
    }

    /**
     * @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\Filesystem;
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 Filesystem
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 Filesystem $filesystem
66			*/
67	14		public function setFilesystem(Filesystem $filesystem)
68			{
69	14		$this->filesystem = $filesystem;
70	14		}
71
72			/**
73			* @param TranslatorInterface $translator
74			*/
75	13		public function setTranslator(TranslatorInterface $translator)
76			{
77	13		$this->translator = $translator;
78	13		}
79
80			/**
81			* @return \Symfony\Component\Translation\TranslatorInterface
82			*/
83	1		public function getTranslator()
84			{
85	1		return $this->translator;
86			}
87
88			/**
89			* @param array $options
90			*/
91	13		public function setImageConstraintOptions(array $options)
92			{
93	13		$this->imageConstraintOptions = $options;
94	13		}
95
96			/**
97			* @param HttpClientInterface $httpClient
98			*/
99	13		public function setHttpClient(HttpClientInterface $httpClient)
100			{
101	13		$this->httpClient = $httpClient;
102	13		}
103
104			/**
105			* @return FileLocator
106			*/
107	2		public function getFileLocator()
108			{
109	2		return $this->fileLocator;
110			}
111
112			/**
113			* @param FileLocator $fileLocator
114			*/
115	13		public function setFileLocator(FileLocator $fileLocator)
116			{
117	13		$this->fileLocator = $fileLocator;
118	13		}
119
120			/**
121			* @return HttpClientInterface
122			*/
123	4		public function getHttpClient()
124			{
125	4		return $this->httpClient;
126			}
127
128			/**
129			* @return Filesystem
130			*/
131	8		public function getFilesystem()
132			{
133	8		return $this->filesystem;
134			}
135
136			/**
137			* @param AbstractMedia $media
138			* @return AbstractProvider
139			*/
140	11		public function setMedia($media)
141			{
142	11		$this->media = $media;
143
144	11		return $this;
145			}
146
147			/**
148			* @param AbstractMedia $media
149			* @param $providerReferenceUpdated
150			*/
151	7		public function update(AbstractMedia $media, $providerReferenceUpdated)
152			{
153	7		$this->updateImage($media);
154	7		}
155
156			/**
157			* @param FormMapper $formMapper
158			*/
159	11		public function buildCreateForm(FormMapper $formMapper)
160			{
161			$formMapper
162	11		->add('provider', 'hidden');
163
164	11		$this->buildProviderCreateForm($formMapper);
165	11		}
166
167			/**
168			* @param FormMapper $formMapper
169			*/
170	7		public function buildEditForm(FormMapper $formMapper)
171			{
172			$formMapper
173	7		->tab('general')
174	7		->add('provider', HiddenType::class);
175
176	7		$this->buildProviderEditFormBefore($formMapper);
177
178	7		$formMapper->add(
179	7		'imageContent',
180	7		'file',
181			[
182	7		'required' => false,
183			'constraints' => [
184	7		new Constraint\File(),
185			],
186	7		'label' => 'form.replacement_image',
187			]
188			)
189	7		->add('title', TextType::class, ['label' => 'form.title'])
190	7		->add(
191	7		'description',
192	7		TextType::class,
193	7		['label' => 'form.description', 'required' => false]
194			)
195	7		->add(
196	7		'authorName',
197	7		TextType::class,
198	7		['label' => 'form.authorName', 'required' => false]
199			)
200	7		->add(
201	7		'copyright',
202	7		TextType::class,
203	7		['label' => 'form.copyright', 'required' => false]
204			)
205	7		->end()
206	7		->end()
207	7		->tab('image')
208	7		->add('focalPoint', MediaFocalPointType::class, [
209	7		'media' => $this->media
210			])
211	7		->end()
212	7		->end()
213			;
214
215	7		$this->buildProviderEditFormAfter($formMapper);
216	7		}
217
218			/**
219			* @param FormMapper $formMapper
220			*/
221			public function buildProviderEditFormBefore(FormMapper $formMapper)
222			{
223			}
224
225			/**
226			* @param FormMapper $formMapper
227			*/
228	6		public function buildProviderEditFormAfter(FormMapper $formMapper)
229			{
230	6		}
231
232			/**
233			* @param AbstractMedia $media
234			* @param bool $useAsImage
235			* @return string\|void
236			*/
237	4		protected function handleFileUpload(AbstractMedia $media, $useAsImage = false)
238			{
239			/**
240			* @var UploadedFile $file
241			*/
242	4		$file = $media->getBinaryContent();
243
244	4		if (empty($file)) {
245			return;
246			}
247
248	4		$filename = $this->getFilenameByFile($file);
249	4		$this->writeToFilesystem($file, $filename);
250
251	4		$media->setProviderMetadata(
252	4		array_merge(
253	4		$media->getProviderMetaData(),
254	4		$this->getFileMetaData($file)
255			)
256			);
257
258	4		if (empty($media->getImage()) && $useAsImage) {
259	2		$media->setImage($filename);
260	2		$media->setImageMetaData($media->getProviderMetaData());
261			}
262
263	4		if (empty($media->getTitle())) {
264	4		$media->setTitle(
265	4		str_replace(
266	4		'_',
267	4		' ',
268	4		pathinfo($file->getClientOriginalName(), PATHINFO_FILENAME)
269			)
270			);
271			}
272
273	4		return $filename;
274			}
275
276			/**
277			* @param UploadedFile $file
278			* @return array
279			*/
280	4		protected function getFileMetaData(UploadedFile $file)
281			{
282			$fileData = [
283	4		'originalName' => $file->getClientOriginalName(),
284	4		'originalExtension' => $file->getClientOriginalExtension(),
285	4		'mimeType' => $file->getClientMimeType(),
286	4		'size' => $file->getSize(),
287			];
288
289
290	4		$this->disableErrorHandler();
291	4		$imageSize = getimagesize($file->getRealPath());
292	4		if (is_array($imageSize)) {
293	4		if (is_int($imageSize[0]) && is_int($imageSize[1])) {
294	4		$fileData['height'] = $imageSize[0];
295	4		$fileData['width'] = $imageSize[1];
296			}
297	4		if (isset($imageSize['bits'])) {
298	4		$fileData['bits'] = $imageSize['bits'];
299			}
300	4		if (isset($imageSize['channels'])) {
301	2		$fileData['channels'] = $imageSize['channels'];
302			}
303			}
304	4		$this->restoreErrorHandler();
305
306	4		return $fileData;
307			}
308
309			/**
310			* @param AbstractMedia $media
311			*/
312	7		public function updateImage(AbstractMedia $media)
313			{
314			/**
315			* @var UploadedFile $file
316			*/
317	7		$file = $media->getImageContent();
318	7		if (empty($file)) {
319	5		return;
320			}
321
322	2		$filename = $this->getFilenameByFile($file);
323	2		$this->writeToFilesystem($file, $filename);
324
325	2		$media->setImage($filename);
326	2		$media->setImageMetaData($this->getFileMetaData($file));
327	2		}
328
329			/**
330			* @param \Sonata\AdminBundle\Form\FormMapper $formMapper
331			* @param $name
332			* @param $label
333			* @param $required
334			* @param array $constraints
335			*/
336	7		protected function doAddFileField(
337			FormMapper $formMapper,
338			$name,
339			$label,
340			$required,
341			$constraints = []
342			) {
343	7		if ($required) {
344	7		$constraints = array_merge(
345			[
346	7		new Constraint\NotBlank(),
347	7		new Constraint\NotNull(),
348			],
349	7		$constraints
350			);
351			}
352
353			$formMapper
354	7		->add(
355			$name,
356	7		FileType::class,
357			[
358	7		'multiple' => false,
359			'data_class' => null,
360	7		'constraints' => $constraints,
361	7		'label' => $label,
362	7		'required' => $required,
363			]
364			);
365	7		}
366
367			/**
368			* @param FormMapper $formMapper
369			* @param string $name
370			* @param string $label
371			* @param array $options
372			*/
373	2	View Code Duplication	public function addImageField(
			0 ignored issues – show Duplication introduced 2017-03-15 08:54 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...
374			FormMapper $formMapper,
375			$name,
376			$label,
377			$options = []
378			) {
379	2		$this->doAddFileField(
380			$formMapper,
381			$name,
382			$label,
383	2		false,
384			[
385	2		new Constraint\Image(
386	2		array_merge($this->imageConstraintOptions, $options)
387			),
388			]
389			);
390	2		}
391
392			/**
393			* @param FormMapper $formMapper
394			* @param $name
395			* @param $label
396			* @param array $options
397			*/
398	3	View Code Duplication	public function addRequiredImageField(
			0 ignored issues – show Duplication introduced 2017-03-15 08:54 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...
399			FormMapper $formMapper,
400			$name,
401			$label,
402			$options = []
403			) {
404	3		$this->doAddFileField(
405			$formMapper,
406			$name,
407			$label,
408	3		true,
409			[
410	3		new Constraint\Image(
411	3		array_merge($this->imageConstraintOptions, $options)
412			),
413			]
414			);
415	3		}
416
417			/**
418			* @param UploadedFile $file
419			* @return string
420			*/
421	4		protected function getFilenameByFile(UploadedFile $file)
422			{
423	4		return sprintf(
424	4		'%s_%d.%s',
425	4		sha1($file->getClientOriginalName()),
426	4		time(),
427	4		$file->getClientOriginalExtension()
428			);
429			}
430
431			/**
432			* @param UploadedFile $file
433			* @param $filename
434			* @throws FilesystemException
435			*/
436	5		protected function writeToFilesystem(UploadedFile $file, $filename)
437			{
438	5		$this->disableErrorHandler();
439	5		$stream = fopen($file->getRealPath(), 'r+');
440	5		$written = $this->getFilesystem()->writeStream($filename, $stream);
441	5		fclose($stream); // this sometime messes up
442	5		$this->restoreErrorHandler();
443
444	5		if (!$written) {
445	1		throw new FilesystemException('Could not write to file system');
446			}
447	4		}
448
449			/**
450			* @param $renderType
451			* @return boolean
452			*/
453	11		public function supports($renderType)
454			{
455	11		if ($renderType === self::SUPPORT_EMBED) {
456	11		return $this->supportsEmbed();
457			}
458	11		if ($renderType === self::SUPPORT_IMAGE) {
459	11		return $this->supportsImage();
460			}
461	11		if ($renderType === self::SUPPORT_DOWNLOAD) {
462	11		return $this->supportsDownload();
463			}
464
465	4		return false;
466			}
467
468			/**
469			* @param ErrorElement $errorElement
470			* @param AbstractMedia $media
471			*/
472	7		public function validate(ErrorElement $errorElement, AbstractMedia $media)
473			{
474	7		}
475
476			/**
477			* @return string
478			*/
479	2		public function getEmbedTemplate()
480			{
481	2		return sprintf(
482	2		'MediaMonksSonataMediaBundle:Provider:%s_embed.html.twig',
483	2		$this->getName()
484			);
485			}
486			}
487

mediamonks / symfony-sonata-media-bundle