CommonUploadController::afterAction() - Code Metrics - Inspection of "Add protection to physical delete multiplied files..." - itstructure/yii2-multi-format-uploader - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( ea324c...2e8bb7 )

by Andrey

created 2020-09-12 08:04 UTC

CommonUploadController::afterAction() A

↳ Parent: CommonUploadController

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace Itstructure\MFUploader\controllers\upload;

use Yii;
use yii\filters\{AccessControl, ContentNegotiator, VerbFilter};
use yii\base\{InvalidConfigException, UnknownMethodException, InvalidArgumentException};
use yii\web\{Controller, Request, Response, UploadedFile, BadRequestHttpException, NotFoundHttpException, ForbiddenHttpException};
use Aws\Exception\AwsException;
use Aws\S3\Exception\S3Exception;
use Itstructure\MFUploader\Module;
use Itstructure\MFUploader\assets\UploadmanagerAsset;
use Itstructure\MFUploader\models\Mediafile;
use Itstructure\MFUploader\traits\{ResponseTrait, MediaFilesTrait};
use Itstructure\MFUploader\interfaces\{UploadComponentInterface, UploadModelInterface};

/**
 * Class CommonUploadController
 * Common upload controller class to upload files.
 *
 * @property UploadComponentInterface $uploadComponent
 * @property UploadModelInterface $uploadModel
 * @property Module $module
 *
 * @package Itstructure\MFUploader\controllers\upload
 *
 * @author Andrey Girnik <[email protected]>
 */
abstract class CommonUploadController extends Controller
{
    use ResponseTrait, MediaFilesTrait;

    /**
     * @var string|array the configuration for creating the serializer that formats the response data.
     */
    public $serializer = 'yii\rest\Serializer';

    /**
     * @var UploadModelInterface
     */
    private $uploadModel;

    /**
     * @return UploadComponentInterface
     */
    abstract protected function getUploadComponent(): UploadComponentInterface;

    /**
     * Initialize.
     */
    public function init()
    {
        $this->enableCsrfValidation = $this->module->enableCsrfValidation;
    }

    /**
     * {@inheritdoc}
     */
    public function behaviors()
    {
        return [
            'access' => [
                'class' => AccessControl::class,
                'rules' => [
                    [
                        'allow' => true,
                        'roles' => $this->module->accessRoles,
                    ],
                ],
                'denyCallback' => function () {
                    \Yii::$app->response->format = Response::FORMAT_JSON;
                    throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
                }
            ],
            'contentNegotiator' => [
                'class' => ContentNegotiator::class,
                'formats' => [
                    'application/json' => Response::FORMAT_JSON,
                ],
            ],
            'verbFilter' => [
                'class' => VerbFilter::class,
                'actions' => $this->verbs(),
            ],
        ];
    }

    /**
     * {@inheritdoc}
     */
    public function afterAction($action, $result)
    {
        $result = parent::afterAction($action, $result);
        return $this->serializeData($result);
    }

    /**
     * @return array
     */
    public function verbs()
    {
        return [
            'save' => ['POST'],
            'delete' => ['POST'],
        ];
    }

    /**
     * Set upload model.
     *
     * @param UploadModelInterface $model
     *
     * @return void
     */
    public function setUploadModel(UploadModelInterface $model): void
    {
        $this->uploadModel = $model;

    }

    /**
     * Returns upload model.
     *
     * @return UploadModelInterface
     */
    public function getUploadModel(): UploadModelInterface
    {
        return $this->uploadModel;
    }

    /**
     * Send new file to upload it.
     *
     * @throws BadRequestHttpException
     *
     * @return array
     */
    public function actionSend()
    {
        try {
            $this->uploadModel = $this->getUploadComponent()->setModelForSave($this->setMediafileModel());


            return $this->actionSave(Yii::$app->request);

        } catch (InvalidConfigException|UnknownMethodException|NotFoundHttpException|InvalidArgumentException|
            AwsException|S3Exception|\Exception $e) {
            throw new BadRequestHttpException($e->getMessage(), $e->getCode());
        }
    }

    /**
     * Update existing file.
     *
     * @throws BadRequestHttpException
     *
     * @return array
     */
    public function actionUpdate()
    {
        try {
            $request = Yii::$app->request;

            if (empty($request->post('id'))) {
                return $this->getFailResponse(Module::t('actions', 'Error to save file.'), [
                    'errors' => Module::t('actions', 'Parameter id must be sent.')
                ]);
            }

            $this->uploadModel = $this->getUploadComponent()->setModelForSave(

                $this->setMediafileModel($request->post('id'))
            );

            return $this->actionSave($request);

        } catch (InvalidConfigException|UnknownMethodException|NotFoundHttpException|InvalidArgumentException|
            AwsException|S3Exception|\Exception $e) {
            throw new BadRequestHttpException($e->getMessage(), $e->getCode());
        }
    }

    /**
     * Delete the media model entry with files.
     *
     * @throws BadRequestHttpException
     *
     * @return array
     */
    public function actionDelete()
    {
        try {
            $deleted = $this->deleteMediafileEntry(Yii::$app->request->post('id'), $this->module);

            if (false === $deleted) {
                return $this->getFailResponse(
                    Module::t('actions', 'Error to delete file.')
                );
            }

            return $this->getSuccessResponse(
                Module::t('actions', 'Deleted {0} files.', [$deleted])
            );

        } catch (InvalidConfigException|\Exception $e) {
            throw new BadRequestHttpException($e->getMessage(), $e->getCode());
        }
    }

    /**
     * Provides upload or update file.
     *
     * @throws InvalidConfigException
     * @throws BadRequestHttpException
     *
     * @param $request
     *
     * @return array
     */
    private function actionSave($request)
    {
        if (!($request instanceof Request)) {
            throw new InvalidArgumentException('Param $request must be instanceof yii\web\Request.');
        }

        if (null === $this->uploadModel) {
            throw new InvalidConfigException('Upload model is not defined.');
        }

        $this->uploadModel->setAttributes($request->post(), false);
        $this->uploadModel->setFile(UploadedFile::getInstanceByName($this->module->fileAttributeName));

        if (!$this->uploadModel->save()) {
            return $this->getFailResponse(Module::t('actions', 'Error to save file.'), [
                'errors' => $this->uploadModel->getErrors()
            ]);
        }

        if ($this->uploadModel->getMediafileModel()->isImage()) {
            $this->uploadModel->createThumbs();
        }

        $response = [];
        $response['files'][] = $this->getUploadResponse();

        return $this->getSuccessResponse(Module::t('actions', 'File saved.'), $response);
    }

    /**
     * Serializes the specified data.
     * The default implementation will create a serializer based on the configuration given by [[serializer]].
     * It then uses the serializer to serialize the given data.
     *
     * @param mixed $data the data to be serialized
     *
     * @return mixed the serialized data.
     */
    private function serializeData($data)
    {
        return Yii::createObject($this->serializer)->serialize($data);
    }

    /**
     * Response with uploaded file data.
     *
     * @return array
     */
    private function getUploadResponse(): array
    {
        $mediafileModel = $this->uploadModel->getMediafileModel();

        return [
            'id'            => $this->uploadModel->getId(),
            'url'           => $mediafileModel->getViewUrl(),
            'thumbnailUrl'  => $mediafileModel->getDefaultThumbUrl(UploadmanagerAsset::register($this->view)->baseUrl),

            'name'          => $mediafileModel->filename,
            'type'          => $mediafileModel->type,
            'size'          => $mediafileModel->size,
        ];
    }

    /**
     * Returns an intermediate model for working with the main.
     *
     * @param int|null $id
     *
     * @throws UnknownMethodException
     * @throws NotFoundHttpException
     *
     * @return Mediafile
     */
    private function setMediafileModel(int $id = null): Mediafile
    {
        if (null === $id) {
            return new Mediafile();
        } else {
            return $this->findMediafileModel($id);
        }
    }
}


1			<?php
2
3			namespace Itstructure\MFUploader\controllers\upload;
4
5			use Yii;
6			use yii\filters\{AccessControl, ContentNegotiator, VerbFilter};
7			use yii\base\{InvalidConfigException, UnknownMethodException, InvalidArgumentException};
8			use yii\web\{Controller, Request, Response, UploadedFile, BadRequestHttpException, NotFoundHttpException, ForbiddenHttpException};
9			use Aws\Exception\AwsException;
10			use Aws\S3\Exception\S3Exception;
11			use Itstructure\MFUploader\Module;
12			use Itstructure\MFUploader\assets\UploadmanagerAsset;
13			use Itstructure\MFUploader\models\Mediafile;
14			use Itstructure\MFUploader\traits\{ResponseTrait, MediaFilesTrait};
15			use Itstructure\MFUploader\interfaces\{UploadComponentInterface, UploadModelInterface};
16
17			/**
18			* Class CommonUploadController
19			* Common upload controller class to upload files.
20			*
21			* @property UploadComponentInterface $uploadComponent
22			* @property UploadModelInterface $uploadModel
23			* @property Module $module
24			*
25			* @package Itstructure\MFUploader\controllers\upload
26			*
27			* @author Andrey Girnik <[email protected]>
28			*/
29			abstract class CommonUploadController extends Controller
30			{
31			use ResponseTrait, MediaFilesTrait;
32
33			/**
34			* @var string\|array the configuration for creating the serializer that formats the response data.
35			*/
36			public $serializer = 'yii\rest\Serializer';
37
38			/**
39			* @var UploadModelInterface
40			*/
41			private $uploadModel;
42
43			/**
44			* @return UploadComponentInterface
45			*/
46			abstract protected function getUploadComponent(): UploadComponentInterface;
47
48			/**
49			* Initialize.
50			*/
51			public function init()
52			{
53			$this->enableCsrfValidation = $this->module->enableCsrfValidation;
54			}
55
56			/**
57			* {@inheritdoc}
58			*/
59			public function behaviors()
60			{
61			return [
62			'access' => [
63			'class' => AccessControl::class,
64			'rules' => [
65			[
66			'allow' => true,
67			'roles' => $this->module->accessRoles,
68			],
69			],
70			'denyCallback' => function () {
71			\Yii::$app->response->format = Response::FORMAT_JSON;
72			throw new ForbiddenHttpException(Yii::t('yii', 'You are not allowed to perform this action.'));
73			}
74			],
75			'contentNegotiator' => [
76			'class' => ContentNegotiator::class,
77			'formats' => [
78			'application/json' => Response::FORMAT_JSON,
79			],
80			],
81			'verbFilter' => [
82			'class' => VerbFilter::class,
83			'actions' => $this->verbs(),
84			],
85			];
86			}
87
88			/**
89			* {@inheritdoc}
90			*/
91			public function afterAction($action, $result)
92			{
93			$result = parent::afterAction($action, $result);
94			return $this->serializeData($result);
95			}
96
97			/**
98			* @return array
99			*/
100			public function verbs()
101			{
102			return [
103			'save' => ['POST'],
104			'delete' => ['POST'],
105			];
106			}
107
108			/**
109			* Set upload model.
110			*
111			* @param UploadModelInterface $model
112			*
113			* @return void
114			*/
115			public function setUploadModel(UploadModelInterface $model): void
116			{
117			$this->uploadModel = $model;
			0 ignored issues – show Documentation Bug introduced 2018-05-15 06:06 UTC by Report Bug Copy Issue Report It seems like `$model` of type `object<Itstructure\MFUpl...s\UploadModelInterface>` is incompatible with the declared type `object<UploadModelInterface>` of property `$uploadModel`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
118			}
119
120			/**
121			* Returns upload model.
122			*
123			* @return UploadModelInterface
124			*/
125			public function getUploadModel(): UploadModelInterface
126			{
127			return $this->uploadModel;
128			}
129
130			/**
131			* Send new file to upload it.
132			*
133			* @throws BadRequestHttpException
134			*
135			* @return array
136			*/
137			public function actionSend()
138			{
139			try {
140			$this->uploadModel = $this->getUploadComponent()->setModelForSave($this->setMediafileModel());
			0 ignored issues – show Documentation Bug introduced 2018-05-15 06:06 UTC by Report Bug Copy Issue Report It seems like `$this->getUploadComponen...s->setMediafileModel())` of type `object<Itstructure\MFUpl...s\UploadModelInterface>` is incompatible with the declared type `object<UploadModelInterface>` of property `$uploadModel`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
141
142			return $this->actionSave(Yii::$app->request);
143
144			} catch (InvalidConfigException\|UnknownMethodException\|NotFoundHttpException\|InvalidArgumentException\|
145			AwsException\|S3Exception\|\Exception $e) {
146			throw new BadRequestHttpException($e->getMessage(), $e->getCode());
147			}
148			}
149
150			/**
151			* Update existing file.
152			*
153			* @throws BadRequestHttpException
154			*
155			* @return array
156			*/
157			public function actionUpdate()
158			{
159			try {
160			$request = Yii::$app->request;
161
162			if (empty($request->post('id'))) {
163			return $this->getFailResponse(Module::t('actions', 'Error to save file.'), [
164			'errors' => Module::t('actions', 'Parameter id must be sent.')
165			]);
166			}
167
168			$this->uploadModel = $this->getUploadComponent()->setModelForSave(
			0 ignored issues – show Documentation Bug introduced 2018-05-15 06:06 UTC by Report Bug Copy Issue Report It seems like `$this->getUploadComponen...($request->post('id')))` of type `object<Itstructure\MFUpl...s\UploadModelInterface>` is incompatible with the declared type `object<UploadModelInterface>` of property `$uploadModel`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
169			$this->setMediafileModel($request->post('id'))
170			);
171
172			return $this->actionSave($request);
173
174			} catch (InvalidConfigException\|UnknownMethodException\|NotFoundHttpException\|InvalidArgumentException\|
175			AwsException\|S3Exception\|\Exception $e) {
176			throw new BadRequestHttpException($e->getMessage(), $e->getCode());
177			}
178			}
179
180			/**
181			* Delete the media model entry with files.
182			*
183			* @throws BadRequestHttpException
184			*
185			* @return array
186			*/
187			public function actionDelete()
188			{
189			try {
190			$deleted = $this->deleteMediafileEntry(Yii::$app->request->post('id'), $this->module);
191
192			if (false === $deleted) {
193			return $this->getFailResponse(
194			Module::t('actions', 'Error to delete file.')
195			);
196			}
197
198			return $this->getSuccessResponse(
199			Module::t('actions', 'Deleted {0} files.', [$deleted])
200			);
201
202			} catch (InvalidConfigException\|\Exception $e) {
203			throw new BadRequestHttpException($e->getMessage(), $e->getCode());
204			}
205			}
206
207			/**
208			* Provides upload or update file.
209			*
210			* @throws InvalidConfigException
211			* @throws BadRequestHttpException
212			*
213			* @param $request
214			*
215			* @return array
216			*/
217			private function actionSave($request)
218			{
219			if (!($request instanceof Request)) {
220			throw new InvalidArgumentException('Param $request must be instanceof yii\web\Request.');
221			}
222
223			if (null === $this->uploadModel) {
224			throw new InvalidConfigException('Upload model is not defined.');
225			}
226
227			$this->uploadModel->setAttributes($request->post(), false);
228			$this->uploadModel->setFile(UploadedFile::getInstanceByName($this->module->fileAttributeName));
229
230			if (!$this->uploadModel->save()) {
231			return $this->getFailResponse(Module::t('actions', 'Error to save file.'), [
232			'errors' => $this->uploadModel->getErrors()
233			]);
234			}
235
236			if ($this->uploadModel->getMediafileModel()->isImage()) {
237			$this->uploadModel->createThumbs();
238			}
239
240			$response = [];
241			$response['files'][] = $this->getUploadResponse();
242
243			return $this->getSuccessResponse(Module::t('actions', 'File saved.'), $response);
244			}
245
246			/**
247			* Serializes the specified data.
248			* The default implementation will create a serializer based on the configuration given by [[serializer]].
249			* It then uses the serializer to serialize the given data.
250			*
251			* @param mixed $data the data to be serialized
252			*
253			* @return mixed the serialized data.
254			*/
255			private function serializeData($data)
256			{
257			return Yii::createObject($this->serializer)->serialize($data);
258			}
259
260			/**
261			* Response with uploaded file data.
262			*
263			* @return array
264			*/
265			private function getUploadResponse(): array
266			{
267			$mediafileModel = $this->uploadModel->getMediafileModel();
268
269			return [
270			'id' => $this->uploadModel->getId(),
271			'url' => $mediafileModel->getViewUrl(),
272			'thumbnailUrl' => $mediafileModel->getDefaultThumbUrl(UploadmanagerAsset::register($this->view)->baseUrl),
			0 ignored issues – show Compatibility introduced 2018-05-15 06:06 UTC by Report Bug Copy Issue Report `$this->view` of type `object<yii\base\View>` is not a sub-type of `object<yii\web\View>`. It seems like you assume a child class of the class `yii\base\View` to be always present. This check looks for parameters that are defined as one type in their type hint or doc comment but seem to be used as a narrower type, i.e an implementation of an interface or a subclass. Consider changing the type of the parameter or doing an instanceof check before assuming your parameter is of the expected type. Loading history...
273			'name' => $mediafileModel->filename,
274			'type' => $mediafileModel->type,
275			'size' => $mediafileModel->size,
276			];
277			}
278
279			/**
280			* Returns an intermediate model for working with the main.
281			*
282			* @param int\|null $id
283			*
284			* @throws UnknownMethodException
285			* @throws NotFoundHttpException
286			*
287			* @return Mediafile
288			*/
289			private function setMediafileModel(int $id = null): Mediafile
290			{
291			if (null === $id) {
292			return new Mediafile();
293			} else {
294			return $this->findMediafileModel($id);
295			}
296			}
297			}
298

itstructure / yii2-multi-format-uploader

Push — master ( ea324c...2e8bb7 )

CommonUploadController::afterAction() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like