AbstractProvider::addFileUploadField() - Code Metrics - Inspection of "Start on "file" provider" - mediamonks/symfony-sonata-media-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 26278b...61e1ff )

unknown

created 2017-01-20 16:14 UTC

AbstractProvider::addFileUploadField() A

↳ Parent: AbstractProvider

Complexity

Conditions	1
Paths	1

Size

Total Lines	18
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	18
ccs	0
cts	18
cp	0
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	12
nc	1
nop	3
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 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
{
    /**
     * @var Filesystem
     */
    protected $filesystem;

    /**
     * @var array
     */
    protected $templates = [];

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

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

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

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

    /**
     * @param Media $media
     */
    public function update(Media $media)
    {
    }

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

    /**
     * @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('providerName', 'hidden');

        $this->buildProviderCreateForm($formMapper);
    }

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

        $this->buildProviderEditForm($formMapper);

        $formMapper->add(
            'binaryContent',
            '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'    => 'Point Of Interest',
                    'choices'  => $this->getPointOfInterestChoices(),
                ]
            )
            ->end();
    }

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

    /**
     * @param Media $media
     * @return string
     * @throws \Exception
     */
    protected function handleFileUpload(Media $media)
    {
        /**
         * @var UploadedFile $file
         */
        $file = $media->getBinaryContent();

        $filename = sprintf(
            '%s_%d.%s',
            sha1($file->getClientOriginalName()),
            time(),
            $file->getClientOriginalExtension()
        );

        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');
        }

        $media->setProviderMetadata(
            array_merge(
                $media->getProviderMetaData(),
                [
                    'originalName'      => $file->getClientOriginalName(),
                    'originalExtension' => $file->getClientOriginalExtension(),
                    'mimeType'          => $file->getClientMimeType(),
                    'size'              => $file->getSize(),
                ]
            )
        );
        $media->setImage($filename);

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

        return $filename;
    }

    /**
     * @param FormMapper $formMapper
     * @param $name
     * @param $label
     */
    public function addFileUploadField(FormMapper $formMapper, $name, $label)
    {
        $formMapper
            ->add(
                $name,
                FileType::class,
                [
                    'multiple'    => false,
                    'data_class'  => null,
                    'constraints' => [
                        new Constraint\NotBlank(),
                        new Constraint\NotNull(),
                        new Constraint\File(),
                    ],
                    'label'       => $label,
                ]
            );
    }

    // @todo handle image replacement

    // @todo handle binary upload replacement
}


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 Symfony\Component\Form\Extension\Core\Type\ChoiceType;
10			use Symfony\Component\Form\Extension\Core\Type\FileType;
11			use Symfony\Component\Form\Extension\Core\Type\HiddenType;
12			use Symfony\Component\HttpFoundation\File\UploadedFile;
13			use Symfony\Component\Validator\Constraints as Constraint;
14
15			abstract class AbstractProvider implements ProviderInterface
16			{
17			/**
18			* @var Filesystem
19			*/
20			protected $filesystem;
21
22			/**
23			* @var array
24			*/
25			protected $templates = [];
26
27			/**
28			* @param Filesystem $filesystem
29			*/
30			public function __construct(Filesystem $filesystem)
31			{
32			$this->filesystem = $filesystem;
33			}
34
35			/**
36			* @return Filesystem
37			*/
38			public function getFilesystem()
39			{
40			return $this->filesystem;
41			}
42
43			/**
44			* @param Media $media
45			*/
46			public function prePersist(Media $media)
47			{
48			$this->update($media);
49			}
50
51			/**
52			* @param Media $media
53			*/
54			public function preUpdate(Media $media)
55			{
56			$this->update($media);
57			}
58
59			/**
60			* @param Media $media
61			*/
62			public function update(Media $media)
63			{
64			}
65
66			/**
67			* @param MediaInterface $media
68			* @param array $options
69			* @return array
70			*/
71			public function toArray(MediaInterface $media, array $options = [])
72			{
73			return [
74			'type' => $this->getTypeName(),
75			'title' => $media->getTitle(),
76			'description' => $media->getDescription(),
77			'authorName' => $media->getAuthorName(),
78			'copyright' => $media->getCopyright(),
79			];
80			}
81
82			/**
83			* @return array
84			*/
85			protected function getPointOfInterestChoices()
86			{
87			return array_flip(
88			[
89			'top-left' => 'Top Left',
90			'top' => 'Top',
91			'top-right' => 'Top Right',
92			'left' => 'Left',
93			'center' => 'Center',
94			'right' => 'Right',
95			'bottom-left' => 'Bottom Left',
96			'bottom' => 'Bottom',
97			'bottom-right' => 'Bottom Right',
98			]
99			);
100			}
101
102			/**
103			* @param FormMapper $formMapper
104			*/
105			public function buildCreateForm(FormMapper $formMapper)
106			{
107			$formMapper
108			->add('providerName', 'hidden');
109
110			$this->buildProviderCreateForm($formMapper);
111			}
112
113			/**
114			* @param FormMapper $formMapper
115			*/
116			public function buildEditForm(FormMapper $formMapper)
117			{
118			$formMapper
119			->with('General')
120			->add('providerName', HiddenType::class);
121
122			$this->buildProviderEditForm($formMapper);
123
124			$formMapper->add(
125			'binaryContent',
126			'file',
127			[
128			'required' => false,
129			'constraints' => [
130			new Constraint\File(),
131			],
132			'label' => 'Replacement Image',
133			]
134			)
135			->add('title')
136			->add('description')
137			->add('authorName')
138			->add('copyright')
139			->add(
140			'pointOfInterest',
141			ChoiceType::class,
142			[
143			'required' => false,
144			'label' => 'Point Of Interest',
145			'choices' => $this->getPointOfInterestChoices(),
146			]
147			)
148			->end();
149			}
150
151			/**
152			* @param FormMapper $formMapper
153			*/
154			public function buildProviderEditForm(FormMapper $formMapper)
155			{
156			}
157
158			/**
159			* @param Media $media
160			* @return string
161			* @throws \Exception
162			*/
163			protected function handleFileUpload(Media $media)
164			{
165			/**
166			* @var UploadedFile $file
167			*/
168			$file = $media->getBinaryContent();
169
170			$filename = sprintf(
171			'%s_%d.%s',
172			sha1($file->getClientOriginalName()),
173			time(),
174			$file->getClientOriginalExtension()
175			);
176
177			set_error_handler(
178			function () {
179			}
180			);
181			$stream = fopen($file->getRealPath(), 'r+');
182			$written = $this->getFilesystem()->writeStream($filename, $stream);
183			fclose($stream); // this sometime messes up
184			restore_error_handler();
185
186			if (!$written) {
187			throw new \Exception('Could not write to file system');
188			}
189
190			$media->setProviderMetadata(
191			array_merge(
192			$media->getProviderMetaData(),
193			[
194			'originalName' => $file->getClientOriginalName(),
195			'originalExtension' => $file->getClientOriginalExtension(),
196			'mimeType' => $file->getClientMimeType(),
197			'size' => $file->getSize(),
198			]
199			)
200			);
201			$media->setImage($filename);
202
203			if (empty($media->getTitle())) {
204			$media->setTitle(str_replace('_', ' ', pathinfo($file->getClientOriginalName(), PATHINFO_FILENAME)));
205			}
206
207			return $filename;
208			}
209
210			/**
211			* @param FormMapper $formMapper
212			* @param $name
213			* @param $label
214			*/
215			public function addFileUploadField(FormMapper $formMapper, $name, $label)
216			{
217			$formMapper
218			->add(
219			$name,
220			FileType::class,
221			[
222			'multiple' => false,
223			'data_class' => null,
224			'constraints' => [
225			new Constraint\NotBlank(),
226			new Constraint\NotNull(),
227			new Constraint\File(),
228			],
229			'label' => $label,
230			]
231			);
232			}
233
234			// @todo handle image replacement
235
236			// @todo handle binary upload replacement
237			}
238

mediamonks / symfony-sonata-media-bundle

Push — master ( 26278b...61e1ff )

AbstractProvider::addFileUploadField() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like