AbstractProvider::getEmbedTemplate() - Code Metrics - Inspection of "Add category to provider" - mediamonks/symfony-sonata-media-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( eb77f8...53cf26 )

unknown

created 2017-03-14 13:42 UTC

AbstractProvider::getEmbedTemplate() 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	4
cp	0
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	0
crap	2

<?php

namespace MediaMonks\SonataMediaBundle\Provider;

use League\Flysystem\Filesystem;
use MediaMonks\SonataMediaBundle\Entity\Media;
use MediaMonks\SonataMediaBundle\Model\MediaInterface;
use Sonata\AdminBundle\Form\FormMapper;
use Sonata\CoreBundle\Validator\ErrorElement;
use Symfony\Component\Form\Extension\Core\Type\ChoiceType;
use Symfony\Component\Form\Extension\Core\Type\FileType;
use Symfony\Component\Form\Extension\Core\Type\HiddenType;
use Symfony\Component\HttpFoundation\File\UploadedFile;
use Symfony\Component\Validator\Constraints as Constraint;

abstract class AbstractProvider implements ProviderInterface
{
    const TYPE_EMBED = 'embed';
    const TYPE_IMAGE = 'image';
    const TYPE_DOWNLOAD = 'download';

    const CATEGORY_AUDIO = 'audio';
    const CATEGORY_FILE = 'file';
    const CATEGORY_IMAGE = 'image';
    const CATEGORY_VIDEO = 'video';

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

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

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

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

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

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

    /**
     * @return string
     */
    public function getTranslationDomain()
    {
        return 'MediaMonksSonataMediaBundle';
    }

    /**
     * @param MediaInterface $media
     * @param array $options
     * @return array
     */
    public function toArray(MediaInterface $media, array $options = [])
    {
        return [
            'type'        => $this->getType(),
            'title'       => $media->getTitle(),
            'description' => $media->getDescription(),
            'authorName'  => $media->getAuthorName(),
            'copyright'   => $media->getCopyright(),
            'reference'   => $media->getProviderReference(),
        ];
    }

    /**
     * @return array
     */
    protected function getPointOfInterestChoices()
    {
        return array_flip(
            [
                'top-left'     => 'Top Left',
                'top'          => 'Top',
                'top-right'    => 'Top Right',
                'left'         => 'Left',
                'center'       => 'Center',
                'right'        => 'Right',
                'bottom-left'  => 'Bottom Left',
                'bottom'       => 'Bottom',
                'bottom-right' => 'Bottom Right',
            ]
        );
    }

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

        $this->buildProviderCreateForm($formMapper);
    }

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

        $this->buildProviderEditForm($formMapper);

        $formMapper->add(
            'imageContent',
            'file',
            [
                'required'    => false,
                'constraints' => [
                    new Constraint\File(),
                ],
                'label'       => 'Replacement Image',
            ]
        )
            ->add('title')
            ->add('description')
            ->add('authorName')
            ->add('copyright')
            ->add(
                'pointOfInterest',
                ChoiceType::class,
                [
                    'required' => false,
                    'label'    => 'Image Point Of Interest',
                    'choices'  => $this->getPointOfInterestChoices(),
                ]
            )
            ->end();
    }

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

    /**
     * @param Media $media
     * @param bool $useAsImage
     * @return string|void
     */
    protected function handleFileUpload(Media $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)
    {
        return [
            'originalName'      => $file->getClientOriginalName(),
            'originalExtension' => $file->getClientOriginalExtension(),
            'mimeType'          => $file->getClientMimeType(),
            'size'              => $file->getSize(),
        ];
    }

    /**
     * @param Media $media
     */
    public function updateImage(Media $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));
    }

    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 \Exception
     */
    protected function writeToFilesystem(UploadedFile $file, $filename)
    {
        set_error_handler(
            function () {
            }
        );
        $stream = fopen($file->getRealPath(), 'r+');
        $written = $this->getFilesystem()->writeStream($filename, $stream);
        fclose($stream); // this sometime messes up
        restore_error_handler();

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

    /**
     * @param $type
     * @return boolean
     */
    public function supports($type)
    {
        if ($type === self::TYPE_EMBED) {
            return $this->supportsEmbed();
        }
        if ($type === self::TYPE_IMAGE) {
            return $this->supportsImage();
        }
        if ($type === self::TYPE_DOWNLOAD) {
            return $this->supportsDownload();
        }

        return false;
    }

    /**
     *
     */
    protected function disableErrorHandler()
    {
        set_error_handler(
            function () {
            }
        );
    }

    /**
     *
     */
    protected function restoreErrorHandler()
    {
        restore_error_handler();
    }

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

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


1			<?php
2
3			namespace MediaMonks\SonataMediaBundle\Provider;
4
5			use League\Flysystem\Filesystem;
6			use MediaMonks\SonataMediaBundle\Entity\Media;
7			use MediaMonks\SonataMediaBundle\Model\MediaInterface;
8			use Sonata\AdminBundle\Form\FormMapper;
9			use Sonata\CoreBundle\Validator\ErrorElement;
10			use Symfony\Component\Form\Extension\Core\Type\ChoiceType;
11			use Symfony\Component\Form\Extension\Core\Type\FileType;
12			use Symfony\Component\Form\Extension\Core\Type\HiddenType;
13			use Symfony\Component\HttpFoundation\File\UploadedFile;
14			use Symfony\Component\Validator\Constraints as Constraint;
15
16			abstract class AbstractProvider implements ProviderInterface
17			{
18			const TYPE_EMBED = 'embed';
19			const TYPE_IMAGE = 'image';
20			const TYPE_DOWNLOAD = 'download';
21
22			const CATEGORY_AUDIO = 'audio';
23			const CATEGORY_FILE = 'file';
24			const CATEGORY_IMAGE = 'image';
25			const CATEGORY_VIDEO = 'video';
26
27			/**
28			* @var Filesystem
29			*/
30			protected $filesystem;
31
32			/**
33			* @var array
34			*/
35			private $imageConstraintOptions = [];
36
37			/**
38			* @param Filesystem $filesystem
39			*/
40			public function setFilesystem(Filesystem $filesystem)
41			{
42			$this->filesystem = $filesystem;
43			}
44
45			/**
46			* @param array $options
47			*/
48			public function setImageConstraintOptions(array $options)
49			{
50			$this->imageConstraintOptions = $options;
51			}
52
53			/**
54			* @return Filesystem
55			*/
56			public function getFilesystem()
57			{
58			return $this->filesystem;
59			}
60
61			/**
62			* @param Media $media
63			* @param $providerReferenceUpdated
64			*/
65			public function update(Media $media, $providerReferenceUpdated)
66			{
67			$this->updateImage($media);
68			}
69
70			/**
71			* @return string
72			*/
73			public function getTranslationDomain()
74			{
75			return 'MediaMonksSonataMediaBundle';
76			}
77
78			/**
79			* @param MediaInterface $media
80			* @param array $options
81			* @return array
82			*/
83			public function toArray(MediaInterface $media, array $options = [])
84			{
85			return [
86			'type' => $this->getType(),
87			'title' => $media->getTitle(),
88			'description' => $media->getDescription(),
89			'authorName' => $media->getAuthorName(),
90			'copyright' => $media->getCopyright(),
91			'reference' => $media->getProviderReference(),
92			];
93			}
94
95			/**
96			* @return array
97			*/
98			protected function getPointOfInterestChoices()
99			{
100			return array_flip(
101			[
102			'top-left' => 'Top Left',
103			'top' => 'Top',
104			'top-right' => 'Top Right',
105			'left' => 'Left',
106			'center' => 'Center',
107			'right' => 'Right',
108			'bottom-left' => 'Bottom Left',
109			'bottom' => 'Bottom',
110			'bottom-right' => 'Bottom Right',
111			]
112			);
113			}
114
115			/**
116			* @param FormMapper $formMapper
117			*/
118			public function buildCreateForm(FormMapper $formMapper)
119			{
120			$formMapper
121			->add('provider', 'hidden');
122
123			$this->buildProviderCreateForm($formMapper);
124			}
125
126			/**
127			* @param FormMapper $formMapper
128			*/
129			public function buildEditForm(FormMapper $formMapper)
130			{
131			$formMapper
132			->with('General')
133			->add('provider', HiddenType::class);
134
135			$this->buildProviderEditForm($formMapper);
136
137			$formMapper->add(
138			'imageContent',
139			'file',
140			[
141			'required' => false,
142			'constraints' => [
143			new Constraint\File(),
144			],
145			'label' => 'Replacement Image',
146			]
147			)
148			->add('title')
149			->add('description')
150			->add('authorName')
151			->add('copyright')
152			->add(
153			'pointOfInterest',
154			ChoiceType::class,
155			[
156			'required' => false,
157			'label' => 'Image Point Of Interest',
158			'choices' => $this->getPointOfInterestChoices(),
159			]
160			)
161			->end();
162			}
163
164			/**
165			* @param FormMapper $formMapper
166			*/
167			public function buildProviderEditForm(FormMapper $formMapper)
168			{
169			}
170
171			/**
172			* @param Media $media
173			* @param bool $useAsImage
174			* @return string\|void
175			*/
176			protected function handleFileUpload(Media $media, $useAsImage = false)
177			{
178			/**
179			* @var UploadedFile $file
180			*/
181			$file = $media->getBinaryContent();
182
183			if (empty($file)) {
184			return;
185			}
186
187			$filename = $this->getFilenameByFile($file);
188			$this->writeToFilesystem($file, $filename);
189
190			$media->setProviderMetadata(array_merge($media->getProviderMetaData(), $this->getFileMetaData($file)));
191
192			if (empty($media->getImage()) && $useAsImage) {
193			$media->setImage($filename);
194			$media->setImageMetaData($media->getProviderMetaData());
195			}
196
197			if (empty($media->getTitle())) {
198			$media->setTitle(str_replace('_', ' ', pathinfo($file->getClientOriginalName(), PATHINFO_FILENAME)));
199			}
200
201			return $filename;
202			}
203
204			/**
205			* @param UploadedFile $file
206			* @return array
207			*/
208			protected function getFileMetaData(UploadedFile $file)
209			{
210			return [
211			'originalName' => $file->getClientOriginalName(),
212			'originalExtension' => $file->getClientOriginalExtension(),
213			'mimeType' => $file->getClientMimeType(),
214			'size' => $file->getSize(),
215			];
216			}
217
218			/**
219			* @param Media $media
220			*/
221			public function updateImage(Media $media)
222			{
223			/**
224			* @var UploadedFile $file
225			*/
226			$file = $media->getImageContent();
227			if (empty($file)) {
228			return;
229			}
230
231			$filename = $this->getFilenameByFile($file);
232			$this->writeToFilesystem($file, $filename);
233
234			$media->setImage($filename);
235			$media->setImageMetaData($this->getFileMetaData($file));
236			}
237
238			protected function doAddFileField(FormMapper $formMapper, $name, $label, $required, $constraints = [])
239			{
240			if ($required) {
241			$constraints = array_merge([
242			new Constraint\NotBlank(),
243			new Constraint\NotNull(),
244			], $constraints);
245			}
246
247			$formMapper
248			->add(
249			$name,
250			FileType::class,
251			[
252			'multiple' => false,
253			'data_class' => null,
254			'constraints' => $constraints,
255			'label' => $label,
256			'required' => $required,
257			]
258			);
259			}
260
261			/**
262			* @param FormMapper $formMapper
263			* @param string $name
264			* @param string $label
265			* @param array $options
266			*/
267			public function addImageField(FormMapper $formMapper, $name, $label, $options = [])
268			{
269			$this->doAddFileField($formMapper, $name, $label, false, [
270			new Constraint\Image(array_merge($this->imageConstraintOptions, $options))
271			]);
272			}
273
274			/**
275			* @param FormMapper $formMapper
276			* @param $name
277			* @param $label
278			* @param array $options
279			*/
280			public function addRequiredImageField(FormMapper $formMapper, $name, $label, $options = [])
281			{
282			$this->doAddFileField($formMapper, $name, $label, true, [
283			new Constraint\Image(array_merge($this->imageConstraintOptions, $options))
284			]);
285			}
286
287			/**
288			* @param UploadedFile $file
289			* @return string
290			*/
291			protected function getFilenameByFile(UploadedFile $file)
292			{
293			return sprintf(
294			'%s_%d.%s',
295			sha1($file->getClientOriginalName()),
296			time(),
297			$file->getClientOriginalExtension()
298			);
299			}
300
301			/**
302			* @param UploadedFile $file
303			* @param $filename
304			* @throws \Exception
305			*/
306			protected function writeToFilesystem(UploadedFile $file, $filename)
307			{
308			set_error_handler(
309			function () {
310			}
311			);
312			$stream = fopen($file->getRealPath(), 'r+');
313			$written = $this->getFilesystem()->writeStream($filename, $stream);
314			fclose($stream); // this sometime messes up
315			restore_error_handler();
316
317			if (!$written) {
318			throw new \Exception('Could not write to file system');
319			}
320			}
321
322			/**
323			* @param $type
324			* @return boolean
325			*/
326			public function supports($type)
327			{
328			if ($type === self::TYPE_EMBED) {
329			return $this->supportsEmbed();
330			}
331			if ($type === self::TYPE_IMAGE) {
332			return $this->supportsImage();
333			}
334			if ($type === self::TYPE_DOWNLOAD) {
335			return $this->supportsDownload();
336			}
337
338			return false;
339			}
340
341			/**
342			*
343			*/
344			protected function disableErrorHandler()
345			{
346			set_error_handler(
347			function () {
348			}
349			);
350			}
351
352			/**
353			*
354			*/
355			protected function restoreErrorHandler()
356			{
357			restore_error_handler();
358			}
359
360			/**
361			* @param ErrorElement $errorElement
362			* @param Media $media
363			*/
364			public function validate(ErrorElement $errorElement, Media $media)
365			{
366			}
367
368			/**
369			* @return string
370			*/
371			public function getEmbedTemplate()
372			{
373			return sprintf('MediaMonksSonataMediaBundle:Provider:%s_embed.html.twig', $this->getType());
374			}
375			}
376

mediamonks / symfony-sonata-media-bundle

Push — master ( eb77f8...53cf26 )

AbstractProvider::getEmbedTemplate() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like