AttributeTypeAttributeAvController::generateUniqueFileName() - Code Metrics - Inspection of "Add image type" - thelia-modules/AttributeType - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#10)

unknown

created 2019-02-03 21:12 UTC

generateUniqueFileName() A

↳ Parent: AttributeTypeAttributeAvController

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	6
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php
/*************************************************************************************/
/*      This file is part of the module AttributeType                                */
/*                                                                                   */
/*      For the full copyright and license information, please view the LICENSE.txt  */
/*      file that was distributed with this source code.                             */
/*************************************************************************************/

namespace AttributeType\Controller;

use AttributeType\AttributeType;
use AttributeType\Event\AttributeTypeEvents;
use AttributeType\Event\AttributeTypeAvMetaEvent;
use AttributeType\Form\AttributeTypeAvMetaUpdateForm;
use AttributeType\Model\AttributeAttributeType;
use AttributeType\Model\AttributeAttributeTypeQuery;
use AttributeType\Model\AttributeTypeAvMeta;
use AttributeType\Model\AttributeTypeAvMetaQuery;
use AttributeType\Model\AttributeTypeQuery;
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\HttpFoundation\File\UploadedFile;
use Thelia\Core\Security\AccessManager;
use Thelia\Core\Security\Resource\AdminResources;
use Thelia\Files\Exception\ProcessFileException;
use Thelia\Model\Lang;
use Thelia\Model\LangQuery;

/**
 * Class AttributeTypeAttributeAvController
 * @package AttributeType\Controller
 * @author Gilles Bourgeat <[email protected]>
 */
class AttributeTypeAttributeAvController extends AttributeTypeController
{
    /** @var Lang[] */
    protected $langs = array();

    /** @var AttributeAttributeType[] */
    protected $attributeAttributeTypes = array();

    /**
     * @param int $attribute_id
     * @return null|\Symfony\Component\HttpFoundation\Response|\Thelia\Core\HttpFoundation\Response
     */
    public function updateMetaAction($attribute_id)
    {
        if (null !== $response = $this->checkAuth(array(AdminResources::ATTRIBUTE), null, AccessManager::UPDATE)) {
            return $response;
        }

        $form = $this->createForm("attribute_type_av_meta.update");

        try {
            $formUpdate = $this->validateForm($form);

            $attributeAvs = $formUpdate->get('attribute_av')->getData();

            foreach ($attributeAvs as $attributeAvId => $attributeAv) {
                foreach ($attributeAv['lang'] as $langId => $lang) {
                    foreach ($lang['attribute_type'] as $attributeTypeId => $value) {
                        $values = [];
                        $values[$langId] = $value;
                        $attributeType = AttributeTypeQuery::create()
                            ->findOneById($attributeTypeId);

                        if ($attributeType->getInputType() === "image") {
                            if (null === $value) {
                                continue;
                            }

                            $uploadedFileName = $this->uploadFile($value);
                            $values[$langId] = $uploadedFileName;

                            if (!$attributeType->getIsMultilingualAttributeAvValue()) {
                                $activeLangs = LangQuery::create()
                                    ->filterByActive(1)
                                    ->find();
                                /** @var Lang $lang */
                                foreach ($activeLangs as $lang) {
                                    $values[$lang->getId()] = $uploadedFileName;
                                }
                            }
                        }

                         foreach ($values as $langId => $langValue) {
                             $this->dispatchEvent(
                                 $this->getAttributeAttributeType($attributeTypeId, $attribute_id),
                                 $attributeAvId,
                                 $langId,
                                 $langValue
                             );
                         }
                    }
                }
            }

            $this->resetUpdateForm();
            return $this->generateSuccessRedirect($form);
        } catch (\Exception $e) {
            $this->setupFormErrorContext(
                $this->getTranslator()->trans("%obj modification", array('%obj' => $this->objectName)),
                $e->getMessage(),
                $form,
                $e
            );

            return $this->viewAttribute($attribute_id);
        }
    }

    public function deleteMetaAction($attribute_id, $attribute_type_id, $attribute_av_id, $lang_id)
    {
        if (null !== $response = $this->checkAuth(array(AdminResources::ATTRIBUTE), null, AccessManager::DELETE)) {
            return $response;
        }
        $form = $this->createForm("attribute_type.delete");
        try {
            $this->validateForm($form);
            $attributeType = AttributeTypeQuery::create()
                ->findOneById($attribute_type_id);
            $attributeAttributeType =  $this->getAttributeAttributeType($attribute_type_id, $attribute_id);
            $eventName = AttributeTypeEvents::ATTRIBUTE_TYPE_AV_META_DELETE;
            $attributeAvMetaQuery = AttributeTypeAvMetaQuery::create()
                ->filterByAttributeAvId($attribute_av_id)
                ->filterByAttributeAttributeTypeId($attributeAttributeType->getId());
            if ($attributeType->getIsMultilingualAttributeAvValue()) {
                $attributeAvMetaQuery->filterByLocale($this->getLocale($lang_id));
            }
            $attributeAvMetas = $attributeAvMetaQuery->find();
            foreach ($attributeAvMetas as $attributeAvMeta) {
                $this->dispatch(
                    $eventName,
                    (new AttributeTypeAvMetaEvent($attributeAvMeta))
                );
            }
            $this->resetUpdateForm();
            return $this->generateSuccessRedirect($form);
        } catch (\Exception $e) {
            $this->setupFormErrorContext(
                $this->getTranslator()->trans("%obj modification", array('%obj' => $this->objectName)),
                $e->getMessage(),
                $form,
                $e
            );
            return $this->viewAttribute($attribute_id);
        }
    }

    /**
     * @param AttributeAttributeType $attributeAttributeType
     * @param int $attributeAvId
     * @param int $langId
     * @param string $value
     * @throws \Exception
     */
    protected function dispatchEvent(AttributeAttributeType $attributeAttributeType, $attributeAvId, $langId, $value)
    {
        $eventName = AttributeTypeEvents::ATTRIBUTE_TYPE_AV_META_UPDATE;

        $attributeAvMeta = AttributeTypeAvMetaQuery::create()
            ->filterByAttributeAvId($attributeAvId)
            ->filterByAttributeAttributeTypeId($attributeAttributeType->getId())
            ->filterByLocale($this->getLocale($langId))
            ->findOne();

        // create if not exist
        if ($attributeAvMeta === null) {
            $eventName = AttributeTypeEvents::ATTRIBUTE_TYPE_AV_META_CREATE;

            $attributeAvMeta = (new AttributeTypeAvMeta())
                ->setAttributeAvId($attributeAvId)
                ->setAttributeAttributeTypeId($attributeAttributeType->getId())
                ->setLocale($this->getLocale($langId));
        }

        $attributeAvMeta->setValue($value);

        $this->dispatch(
            $eventName,
            (new AttributeTypeAvMetaEvent($attributeAvMeta))
        );
    }

    /**
     * @param int $attributeTypeId
     * @param int $attributeId
     * @return AttributeAttributeType
     * @throws \Exception
     */
    protected function getAttributeAttributeType($attributeTypeId, $attributeId)
    {
        if (!isset($this->attributeAttributeTypes[$attributeTypeId])) {
            $this->attributeAttributeTypes[$attributeTypeId] = AttributeAttributeTypeQuery::create()
                ->filterByAttributeTypeId($attributeTypeId)
                ->filterByAttributeId($attributeId)
                ->findOne();

            if ($this->attributeAttributeTypes[$attributeTypeId] === null) {
                throw new \Exception('AttributeAttributeType not found');
            }
        }

        return $this->attributeAttributeTypes[$attributeTypeId];
    }

    /**
     * @param int $langId
     * @return string
     * @throws \Exception
     */
    protected function getLocale($langId)
    {
        if (!isset($this->langs[$langId])) {
            $this->langs[$langId] = LangQuery::create()->findPk($langId);

            if ($this->langs[$langId] === null) {
                throw new \Exception('Lang not found');
            }
        }

        return $this->langs[$langId]->getLocale();
    }

    /**
     * @param UploadedFile $file
     * @return string
     */
    protected function uploadFile(UploadedFile $file)
    {
        if ($file->getError() == UPLOAD_ERR_INI_SIZE) {
            $message = $this->getTranslator()
                ->trans(
                    'File is too large, please retry with a file having a size less than %size%.',
                    array('%size%' => ini_get('upload_max_filesize')),
                    'core'
                );
            throw new ProcessFileException($message, 403);
        }
        $validMimeTypes = [
            'image/jpeg' => ["jpg", "jpeg"],
            'image/png' => ["png"],
            'image/gif' => ["gif"]
        ];
        $mimeType = $file->getMimeType();
        if (!isset($validMimeTypes[$mimeType])) {
            $message = $this->getTranslator()
                ->trans(
                    'Only files having the following mime type are allowed: %types%',
                    [ '%types%' => implode(', ', array_keys($validMimeTypes))]
                );
            throw new ProcessFileException($message, 415);
        }
        $regex = "#^(.+)\.(".implode("|", $validMimeTypes[$mimeType]).")$#i";
        $realFileName = $file->getClientOriginalName();
        if (!preg_match($regex, $realFileName)) {
            $message = $this->getTranslator()
                ->trans(
                    "There's a conflict between your file extension \"%ext\" and the mime type \"%mime\"",
                    [
                        '%mime' => $mimeType,
                        '%ext' => $file->getClientOriginalExtension()
                    ]
                );
            throw new ProcessFileException($message, 415);
        }
        $fileSystem = new Filesystem();
        $fileSystem->mkdir(THELIA_WEB_DIR. DS .AttributeType::ATTRIBUTE_TYPE_AV_IMAGE_FOLDER);
        $fileName = $this->generateUniqueFileName().'_'.$realFileName;
        $file->move(THELIA_WEB_DIR. DS .AttributeType::ATTRIBUTE_TYPE_AV_IMAGE_FOLDER, $fileName);
        return DS . AttributeType::ATTRIBUTE_TYPE_AV_IMAGE_FOLDER. DS .$fileName;
    }

    /**
     * @return string
     */
    protected function generateUniqueFileName()
    {
        // md5() reduces the similarity of the file names generated by
        // uniqid(), which is based on timestamps
        return substr(md5(uniqid()), 0, 10);
    }

    protected function resetUpdateForm() {
        $this->getParserContext()->remove(AttributeTypeAvMetaUpdateForm::class.':form');
        $theliaFormErrors = $this->getRequest()->getSession()->get('thelia.form-errors');
        unset($theliaFormErrors[AttributeTypeAvMetaUpdateForm::class.':form']);
        $this->getRequest()->getSession()->set('thelia.form-errors', $theliaFormErrors);
    }
}


1			<?php
2			/*************************************************************************************/
3			/* This file is part of the module AttributeType */
4			/* */
5			/* For the full copyright and license information, please view the LICENSE.txt */
6			/* file that was distributed with this source code. */
7			/*************************************************************************************/
8
9			namespace AttributeType\Controller;
10
11			use AttributeType\AttributeType;
12			use AttributeType\Event\AttributeTypeEvents;
13			use AttributeType\Event\AttributeTypeAvMetaEvent;
14			use AttributeType\Form\AttributeTypeAvMetaUpdateForm;
15			use AttributeType\Model\AttributeAttributeType;
16			use AttributeType\Model\AttributeAttributeTypeQuery;
17			use AttributeType\Model\AttributeTypeAvMeta;
18			use AttributeType\Model\AttributeTypeAvMetaQuery;
19			use AttributeType\Model\AttributeTypeQuery;
20			use Symfony\Component\Filesystem\Filesystem;
21			use Symfony\Component\HttpFoundation\File\UploadedFile;
22			use Thelia\Core\Security\AccessManager;
23			use Thelia\Core\Security\Resource\AdminResources;
24			use Thelia\Files\Exception\ProcessFileException;
25			use Thelia\Model\Lang;
26			use Thelia\Model\LangQuery;
27
28			/**
29			* Class AttributeTypeAttributeAvController
30			* @package AttributeType\Controller
31			* @author Gilles Bourgeat <[email protected]>
32			*/
33			class AttributeTypeAttributeAvController extends AttributeTypeController
34			{
35			/** @var Lang[] */
36			protected $langs = array();
37
38			/** @var AttributeAttributeType[] */
39			protected $attributeAttributeTypes = array();
40
41			/**
42			* @param int $attribute_id
43			* @return null\|\Symfony\Component\HttpFoundation\Response\|\Thelia\Core\HttpFoundation\Response
44			*/
45			public function updateMetaAction($attribute_id)
46			{
47			if (null !== $response = $this->checkAuth(array(AdminResources::ATTRIBUTE), null, AccessManager::UPDATE)) {
48			return $response;
49			}
50
51			$form = $this->createForm("attribute_type_av_meta.update");
52
53			try {
54			$formUpdate = $this->validateForm($form);
55
56			$attributeAvs = $formUpdate->get('attribute_av')->getData();
57
58			foreach ($attributeAvs as $attributeAvId => $attributeAv) {
59			foreach ($attributeAv['lang'] as $langId => $lang) {
60			foreach ($lang['attribute_type'] as $attributeTypeId => $value) {
61			$values = [];
62			$values[$langId] = $value;
63			$attributeType = AttributeTypeQuery::create()
64			->findOneById($attributeTypeId);
65
66			if ($attributeType->getInputType() === "image") {
67			if (null === $value) {
68			continue;
69			}
70
71			$uploadedFileName = $this->uploadFile($value);
72			$values[$langId] = $uploadedFileName;
73
74			if (!$attributeType->getIsMultilingualAttributeAvValue()) {
75			$activeLangs = LangQuery::create()
76			->filterByActive(1)
77			->find();
78			/** @var Lang $lang */
79			foreach ($activeLangs as $lang) {
80			$values[$lang->getId()] = $uploadedFileName;
81			}
82			}
83			}
84
85			foreach ($values as $langId => $langValue) {
86			$this->dispatchEvent(
87			$this->getAttributeAttributeType($attributeTypeId, $attribute_id),
88			$attributeAvId,
89			$langId,
90			$langValue
91			);
92			}
93			}
94			}
95			}
96
97			$this->resetUpdateForm();
98			return $this->generateSuccessRedirect($form);
99			} catch (\Exception $e) {
100			$this->setupFormErrorContext(
101			$this->getTranslator()->trans("%obj modification", array('%obj' => $this->objectName)),
102			$e->getMessage(),
103			$form,
104			$e
105			);
106
107			return $this->viewAttribute($attribute_id);
108			}
109			}
110
111			public function deleteMetaAction($attribute_id, $attribute_type_id, $attribute_av_id, $lang_id)
112			{
113			if (null !== $response = $this->checkAuth(array(AdminResources::ATTRIBUTE), null, AccessManager::DELETE)) {
114			return $response;
115			}
116			$form = $this->createForm("attribute_type.delete");
117			try {
118			$this->validateForm($form);
119			$attributeType = AttributeTypeQuery::create()
120			->findOneById($attribute_type_id);
121			$attributeAttributeType = $this->getAttributeAttributeType($attribute_type_id, $attribute_id);
122			$eventName = AttributeTypeEvents::ATTRIBUTE_TYPE_AV_META_DELETE;
123			$attributeAvMetaQuery = AttributeTypeAvMetaQuery::create()
124			->filterByAttributeAvId($attribute_av_id)
125			->filterByAttributeAttributeTypeId($attributeAttributeType->getId());
126			if ($attributeType->getIsMultilingualAttributeAvValue()) {
127			$attributeAvMetaQuery->filterByLocale($this->getLocale($lang_id));
128			}
129			$attributeAvMetas = $attributeAvMetaQuery->find();
130			foreach ($attributeAvMetas as $attributeAvMeta) {
131			$this->dispatch(
132			$eventName,
133			(new AttributeTypeAvMetaEvent($attributeAvMeta))
134			);
135			}
136			$this->resetUpdateForm();
137			return $this->generateSuccessRedirect($form);
138			} catch (\Exception $e) {
139			$this->setupFormErrorContext(
140			$this->getTranslator()->trans("%obj modification", array('%obj' => $this->objectName)),
141			$e->getMessage(),
142			$form,
143			$e
144			);
145			return $this->viewAttribute($attribute_id);
146			}
147			}
148
149			/**
150			* @param AttributeAttributeType $attributeAttributeType
151			* @param int $attributeAvId
152			* @param int $langId
153			* @param string $value
154			* @throws \Exception
155			*/
156			protected function dispatchEvent(AttributeAttributeType $attributeAttributeType, $attributeAvId, $langId, $value)
157			{
158			$eventName = AttributeTypeEvents::ATTRIBUTE_TYPE_AV_META_UPDATE;
159
160			$attributeAvMeta = AttributeTypeAvMetaQuery::create()
161			->filterByAttributeAvId($attributeAvId)
162			->filterByAttributeAttributeTypeId($attributeAttributeType->getId())
163			->filterByLocale($this->getLocale($langId))
164			->findOne();
165
166			// create if not exist
167			if ($attributeAvMeta === null) {
168			$eventName = AttributeTypeEvents::ATTRIBUTE_TYPE_AV_META_CREATE;
169
170			$attributeAvMeta = (new AttributeTypeAvMeta())
171			->setAttributeAvId($attributeAvId)
172			->setAttributeAttributeTypeId($attributeAttributeType->getId())
173			->setLocale($this->getLocale($langId));
174			}
175
176			$attributeAvMeta->setValue($value);
177
178			$this->dispatch(
179			$eventName,
180			(new AttributeTypeAvMetaEvent($attributeAvMeta))
181			);
182			}
183
184			/**
185			* @param int $attributeTypeId
186			* @param int $attributeId
187			* @return AttributeAttributeType
188			* @throws \Exception
189			*/
190			protected function getAttributeAttributeType($attributeTypeId, $attributeId)
191			{
192			if (!isset($this->attributeAttributeTypes[$attributeTypeId])) {
193			$this->attributeAttributeTypes[$attributeTypeId] = AttributeAttributeTypeQuery::create()
194			->filterByAttributeTypeId($attributeTypeId)
195			->filterByAttributeId($attributeId)
196			->findOne();
197
198			if ($this->attributeAttributeTypes[$attributeTypeId] === null) {
199			throw new \Exception('AttributeAttributeType not found');
200			}
201			}
202
203			return $this->attributeAttributeTypes[$attributeTypeId];
204			}
205
206			/**
207			* @param int $langId
208			* @return string
209			* @throws \Exception
210			*/
211			protected function getLocale($langId)
212			{
213			if (!isset($this->langs[$langId])) {
214			$this->langs[$langId] = LangQuery::create()->findPk($langId);
215
216			if ($this->langs[$langId] === null) {
217			throw new \Exception('Lang not found');
218			}
219			}
220
221			return $this->langs[$langId]->getLocale();
222			}
223
224			/**
225			* @param UploadedFile $file
226			* @return string
227			*/
228			protected function uploadFile(UploadedFile $file)
229			{
230			if ($file->getError() == UPLOAD_ERR_INI_SIZE) {
231			$message = $this->getTranslator()
232			->trans(
233			'File is too large, please retry with a file having a size less than %size%.',
234			array('%size%' => ini_get('upload_max_filesize')),
235			'core'
236			);
237			throw new ProcessFileException($message, 403);
238			}
239			$validMimeTypes = [
240			'image/jpeg' => ["jpg", "jpeg"],
241			'image/png' => ["png"],
242			'image/gif' => ["gif"]
243			];
244			$mimeType = $file->getMimeType();
245			if (!isset($validMimeTypes[$mimeType])) {
246			$message = $this->getTranslator()
247			->trans(
248			'Only files having the following mime type are allowed: %types%',
249			[ '%types%' => implode(', ', array_keys($validMimeTypes))]
250			);
251			throw new ProcessFileException($message, 415);
252			}
253			$regex = "#^(.+)\.(".implode("\|", $validMimeTypes[$mimeType]).")$#i";
254			$realFileName = $file->getClientOriginalName();
255			if (!preg_match($regex, $realFileName)) {
256			$message = $this->getTranslator()
257			->trans(
258			"There's a conflict between your file extension \"%ext\" and the mime type \"%mime\"",
259			[
260			'%mime' => $mimeType,
261			'%ext' => $file->getClientOriginalExtension()
262			]
263			);
264			throw new ProcessFileException($message, 415);
265			}
266			$fileSystem = new Filesystem();
267			$fileSystem->mkdir(THELIA_WEB_DIR. DS .AttributeType::ATTRIBUTE_TYPE_AV_IMAGE_FOLDER);
268			$fileName = $this->generateUniqueFileName().'_'.$realFileName;
269			$file->move(THELIA_WEB_DIR. DS .AttributeType::ATTRIBUTE_TYPE_AV_IMAGE_FOLDER, $fileName);
270			return DS . AttributeType::ATTRIBUTE_TYPE_AV_IMAGE_FOLDER. DS .$fileName;
271			}
272
273			/**
274			* @return string
275			*/
276			protected function generateUniqueFileName()
277			{
278			// md5() reduces the similarity of the file names generated by
279			// uniqid(), which is based on timestamps
280			return substr(md5(uniqid()), 0, 10);
281			}
282
283			protected function resetUpdateForm() {
284			$this->getParserContext()->remove(AttributeTypeAvMetaUpdateForm::class.':form');
285			$theliaFormErrors = $this->getRequest()->getSession()->get('thelia.form-errors');
286			unset($theliaFormErrors[AttributeTypeAvMetaUpdateForm::class.':form']);
287			$this->getRequest()->getSession()->set('thelia.form-errors', $theliaFormErrors);
288			}
289			}
290

thelia-modules / AttributeType

Pull Request — master (#10)

generateUniqueFileName() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like