FileManager::validIdRequest() - Code Metrics - Inspection of "Change of request, we regenerate the hash if not g..." - libgraviton/graviton - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — feature/EVO-10275-file-hash-le... ( 4522d8...3c5ea6 )

unknown

created 2017-04-10 13:41 UTC

FileManager::validIdRequest() A

↳ Parent: FileManager

Complexity

Conditions	4
Paths	3

Size

Total Lines	10
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	20

Importance

Changes

Metric	Value
dl	0
loc	10
ccs	0
cts	10
cp	0
rs	9.2
c	0
b	0
f	0
cc	4
eloc	6
nc	3
nop	2
crap	20

<?php
/**
 * Handles file specific actions
 */

namespace Graviton\FileBundle\Manager;

use Doctrine\ODM\MongoDB\Id\UuidGenerator;
use GravitonDyn\FileBundle\Document\File as FileDocument;
use GravitonDyn\FileBundle\Document\FileMetadataBase;
use GravitonDyn\FileBundle\Document\FileMetadataEmbedded;
use League\Flysystem\Filesystem;
use Symfony\Component\Form\Exception\InvalidArgumentException;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpFoundation\ResponseHeaderBag;
use Symfony\Component\HttpFoundation\FileBag;
use Symfony\Component\HttpFoundation\File\UploadedFile;
use GravitonDyn\FileBundle\Document\File as DocumentFile;
use Doctrine\Bundle\MongoDBBundle\ManagerRegistry;
use Doctrine\ODM\MongoDB\DocumentManager;
use Symfony\Component\Filesystem\Filesystem as SfFileSystem;
use GravitonDyn\FileBundle\Model\File as DocumentModel;
use Graviton\ExceptionBundle\Exception\NotFoundException;

/**
 * @author   List of contributors <https://github.com/libgraviton/graviton/graphs/contributors>
 * @license  http://opensource.org/licenses/gpl-license.php GNU Public License
 * @link     http://swisscom.ch
 */
class FileManager
{
    /**
     * @var Filesystem
     */
    private $fileSystem;

    /**
     * @var DocumentManager
     */
    private $documentManager;

    /** @var array allowedMimeTypes Control files to be saved and returned */
    private $allowedMimeTypes = [];

    /**
     * FileManager constructor.
     *
     * @param Filesystem      $fileSystem      file system abstraction layer for s3 and more
     * @param ManagerRegistry $managerRegistry MongoDB registry manager
     */
    public function __construct(
        Filesystem $fileSystem,
        ManagerRegistry $managerRegistry
    ) {
        $this->fileSystem = $fileSystem;
        $this->documentManager = $managerRegistry->getManager();
    }

    /**
     * Configure allowed content types, empty is equal to all
     *
     * @param array $mimeTypes of Allowed types, application/pdf, image/jpeg...
     *
     * @return void
     */
    public function setAllowedMimeTypes(array $mimeTypes)
    {
        $this->allowedMimeTypes = $mimeTypes;
    }

    /**
     * Will update the response object with provided file data
     *
     * @param Response     $response response
     * @param DocumentFile $file     File document object from DB
     *
     * @return Response
     * @throws InvalidArgumentException if invalid info fetched from fileSystem
     */
    public function buildGetContentResponse(Response $response, FileDocument $file)
    {
        /** @var FileMetadataBase $metadata */
        $metadata = $file->getMetadata();
        if (!$metadata) {
            throw new InvalidArgumentException('Loaded file have no valid metadata');
        }

        // We use file's mimeType, just in case none we use DB's.
        $mimeType = $this->fileSystem->getMimetype($file->getId());
        if (!$mimeType) {
            $mimeType = $metadata->getMime();
        }
        if ($this->allowedMimeTypes && !in_array($mimeType, $this->allowedMimeTypes)) {
            throw new InvalidArgumentException('File mime type: '.$mimeType.' is not allowed as response.');
        }

        // Create Response
        $disposition = $response->headers->makeDisposition(
            ResponseHeaderBag::DISPOSITION_INLINE,
            $metadata->getFilename()
        );

        $response
            ->setStatusCode(Response::HTTP_OK)
            ->setContent($this->fileSystem->read($file->getId()));
        $response
            ->headers->set('Content-Type', $mimeType);
        $response
            ->headers->set('Content-Disposition', $disposition);
        return $response;
    }


    /**
     * Save or update a file
     *
     * @param string $id       ID of file
     * @param String $filepath path to the file to save
     *
     * @return void
     */
    public function saveFile($id, $filepath)
    {
        // will save using a stream
        $fp = fopen($filepath, 'r+');

        $this->fileSystem->putStream($id, $fp);

        // close file
        fclose($fp);
    }

    /**
     * @param DocumentFile  $document File Document
     * @param Request       $request  Request bag
     * @param DocumentModel $model    File Document Model
     * @return DocumentFile
     */
    public function handleSaveRequest(
        FileDocument $document,
        Request $request,
        DocumentModel $model
    ) {
        $file = $this->getUploadedFileFromRequest($request);
        $requestId = $request->get('id', '');
        if ($requestId && !$document->getId()) {
            $document->setId($requestId);
        }

        try {
            $original = $model->find($requestId);
        } catch (NotFoundException $e) {
            $original = false;
        }

        $isNew = $requestId ? !$original : true;

        // If posted  file document not equal the one to be created or updated, then error
        if (!$this->validIdRequest($document, $requestId)) {
            throw new InvalidArgumentException('File id and Request id must match.');
        }

        $document = $this->buildFileDocument($document, $file, $original);
        if (!$document->getId()) {
            $n = new UuidGenerator();
            $uuid = (string) $n->generateV4();
            $document->setId($uuid);
        }

        // Filename limitation
        if ($filename = $document->getMetadata()->getFilename()) {
            // None English chars
            if (preg_match('/[^a-z_\-0-9.]/i', $filename)) {
                throw new InvalidArgumentException('None special chars allowed for filename, given: '.$filename);
            }
        }

        // All ok, let's save the file
        if ($isNew) {
            if (!$file || $file->getSize() == 0) {
                throw new InvalidArgumentException('You can not create a new empty file resource. No file received.');
            }
        }

        if ($file) {
            $this->saveFile($document->getId(), $file->getRealPath());
            $sfFileSys = new SfFileSystem();
            $sfFileSys->remove($file->getRealPath());
        }

        if ($isNew) {
            $model->insertRecord($document);
        } else {
            $model->updateRecord($document->getId(), $document);
        }

        // store id of new record so we don't need to re-parse body later when needed
        $request->attributes->set('id', $document->getId());

        return $document;
    }

    /**
     * Create the basic needs for a file
     *
     * @param DocumentFile $document Post or Put file document
     * @param UploadedFile $file     To be used in set metadata
     * @param DocumentFile $original If there is a original document
     *
     * @return DocumentFile
     * @throws InvalidArgumentException
     */
    private function buildFileDocument(FileDocument $document, $file, $original)
    {
        $now = new \DateTime();

        // If only a file is posted, check if there is a original object and clone it
        if ($file && $original && !$document->getMetadata()) {
            $document = clone $original;
        }

        // Basic Metadata update
        $metadata = $document->getMetadata() ?: new FileMetadataEmbedded();

        // File related, if no file uploaded we keep original file info.
        if ($file) {
            $hash = $metadata->getHash();
            if (!$hash || strlen($hash)>64) {
                $hash = hash('sha256', file_get_contents($file->getRealPath()));
            }
            $metadata->setHash($hash);
            $metadata->setMime($file->getMimeType());
            $metadata->setSize($file->getSize());
            if (!$metadata->getFilename()) {
                $fileName = $file->getClientOriginalName() ? $file->getClientOriginalName() : $file->getFilename();
                $fileName = preg_replace("/[^a-zA-Z0-9.]/", "-", $fileName);
                $metadata->setFilename($fileName);
            }
        } elseif ($original && ($originalMetadata = $original->getMetadata())) {
            if (!$metadata->getFilename()) {
                $metadata->setFilename($originalMetadata->getFilename());
            }
            $metadata->setHash($originalMetadata->getHash());
            $metadata->setMime($originalMetadata->getMime());
            $metadata->setSize($originalMetadata->getSize());
        }

        // Creation date. keep original if available
        if ($original && $original->getMetadata() && $original->getMetadata()->getCreatedate()) {
            $metadata->setCreatedate($original->getMetadata()->getCreatedate());
        } else {
            $metadata->setCreatedate($now);
        }

        $metadata->setModificationdate($now);
        $document->setMetadata($metadata);

        return $document;
    }

    /**
     * Simple validation for post/put request
     *
     * @param DocumentFile $document  File document
     * @param string       $requestId Request ID
     * @return bool
     */
    private function validIdRequest(FileDocument $document, $requestId)

    {
        if (!$requestId && !$document->getId()) {
            return true;
        }
        if ($requestId === $document->getId()) {
            return true;
        }
        return false;
    }

    /**
     * Simple delete item from file system
     *
     * @param string $id ID of file to be deleted
     *
     * @return void
     */
    public function remove($id)
    {
        if ($this->fileSystem->has($id)) {
            $this->fileSystem->delete($id);
        }
    }

    /**
     * Set global uploaded file.
     * Only ONE file allowed per upload.
     *
     * @param Request $request service request
     * @return UploadedFile if file was uploaded
     * @throws InvalidArgumentException
     */
    private function getUploadedFileFromRequest(Request $request)
    {
        $file = false;

        if ($request->files instanceof FileBag && $request->files->count() > 0) {
            if ($request->files->count() > 1) {
                throw new InvalidArgumentException('Only 1 file upload per requests allowed.');
            }
            $files = $request->files->all();
            $file = reset($files);
            if ($this->allowedMimeTypes && !in_array($file->getMimeType(), $this->allowedMimeTypes)) {
                throw new InvalidArgumentException('File mime type: '.$file->getMimeType().' is not allowed.');
            }
        }

        return $file;
    }
}


1			<?php
2			/**
3			* Handles file specific actions
4			*/
5
6			namespace Graviton\FileBundle\Manager;
7
8			use Doctrine\ODM\MongoDB\Id\UuidGenerator;
9			use GravitonDyn\FileBundle\Document\File as FileDocument;
10			use GravitonDyn\FileBundle\Document\FileMetadataBase;
11			use GravitonDyn\FileBundle\Document\FileMetadataEmbedded;
12			use League\Flysystem\Filesystem;
13			use Symfony\Component\Form\Exception\InvalidArgumentException;
14			use Symfony\Component\HttpFoundation\Request;
15			use Symfony\Component\HttpFoundation\Response;
16			use Symfony\Component\HttpFoundation\ResponseHeaderBag;
17			use Symfony\Component\HttpFoundation\FileBag;
18			use Symfony\Component\HttpFoundation\File\UploadedFile;
19			use GravitonDyn\FileBundle\Document\File as DocumentFile;
20			use Doctrine\Bundle\MongoDBBundle\ManagerRegistry;
21			use Doctrine\ODM\MongoDB\DocumentManager;
22			use Symfony\Component\Filesystem\Filesystem as SfFileSystem;
23			use GravitonDyn\FileBundle\Model\File as DocumentModel;
24			use Graviton\ExceptionBundle\Exception\NotFoundException;
25
26			/**
27			* @author List of contributors <https://github.com/libgraviton/graviton/graphs/contributors>
28			* @license http://opensource.org/licenses/gpl-license.php GNU Public License
29			* @link http://swisscom.ch
30			*/
31			class FileManager
32			{
33			/**
34			* @var Filesystem
35			*/
36			private $fileSystem;
37
38			/**
39			* @var DocumentManager
40			*/
41			private $documentManager;
42
43			/** @var array allowedMimeTypes Control files to be saved and returned */
44			private $allowedMimeTypes = [];
45
46			/**
47			* FileManager constructor.
48			*
49			* @param Filesystem $fileSystem file system abstraction layer for s3 and more
50			* @param ManagerRegistry $managerRegistry MongoDB registry manager
51			*/
52			public function __construct(
53			Filesystem $fileSystem,
54			ManagerRegistry $managerRegistry
55			) {
56			$this->fileSystem = $fileSystem;
57			$this->documentManager = $managerRegistry->getManager();
58			}
59
60			/**
61			* Configure allowed content types, empty is equal to all
62			*
63			* @param array $mimeTypes of Allowed types, application/pdf, image/jpeg...
64			*
65			* @return void
66			*/
67			public function setAllowedMimeTypes(array $mimeTypes)
68			{
69			$this->allowedMimeTypes = $mimeTypes;
70			}
71
72			/**
73			* Will update the response object with provided file data
74			*
75			* @param Response $response response
76			* @param DocumentFile $file File document object from DB
77			*
78			* @return Response
79			* @throws InvalidArgumentException if invalid info fetched from fileSystem
80			*/
81			public function buildGetContentResponse(Response $response, FileDocument $file)
82			{
83			/** @var FileMetadataBase $metadata */
84			$metadata = $file->getMetadata();
85			if (!$metadata) {
86			throw new InvalidArgumentException('Loaded file have no valid metadata');
87			}
88
89			// We use file's mimeType, just in case none we use DB's.
90			$mimeType = $this->fileSystem->getMimetype($file->getId());
91			if (!$mimeType) {
92			$mimeType = $metadata->getMime();
93			}
94			if ($this->allowedMimeTypes && !in_array($mimeType, $this->allowedMimeTypes)) {
95			throw new InvalidArgumentException('File mime type: '.$mimeType.' is not allowed as response.');
96			}
97
98			// Create Response
99			$disposition = $response->headers->makeDisposition(
100			ResponseHeaderBag::DISPOSITION_INLINE,
101			$metadata->getFilename()
102			);
103
104			$response
105			->setStatusCode(Response::HTTP_OK)
106			->setContent($this->fileSystem->read($file->getId()));
107			$response
108			->headers->set('Content-Type', $mimeType);
109			$response
110			->headers->set('Content-Disposition', $disposition);
111			return $response;
112			}
113
114
115			/**
116			* Save or update a file
117			*
118			* @param string $id ID of file
119			* @param String $filepath path to the file to save
120			*
121			* @return void
122			*/
123			public function saveFile($id, $filepath)
124			{
125			// will save using a stream
126			$fp = fopen($filepath, 'r+');
127
128			$this->fileSystem->putStream($id, $fp);
129
130			// close file
131			fclose($fp);
132			}
133
134			/**
135			* @param DocumentFile $document File Document
136			* @param Request $request Request bag
137			* @param DocumentModel $model File Document Model
138			* @return DocumentFile
139			*/
140			public function handleSaveRequest(
141			FileDocument $document,
142			Request $request,
143			DocumentModel $model
144			) {
145			$file = $this->getUploadedFileFromRequest($request);
146			$requestId = $request->get('id', '');
147			if ($requestId && !$document->getId()) {
148			$document->setId($requestId);
149			}
150
151			try {
152			$original = $model->find($requestId);
153			} catch (NotFoundException $e) {
154			$original = false;
155			}
156
157			$isNew = $requestId ? !$original : true;
158
159			// If posted file document not equal the one to be created or updated, then error
160			if (!$this->validIdRequest($document, $requestId)) {
161			throw new InvalidArgumentException('File id and Request id must match.');
162			}
163
164			$document = $this->buildFileDocument($document, $file, $original);
165			if (!$document->getId()) {
166			$n = new UuidGenerator();
167			$uuid = (string) $n->generateV4();
168			$document->setId($uuid);
169			}
170
171			// Filename limitation
172			if ($filename = $document->getMetadata()->getFilename()) {
173			// None English chars
174			if (preg_match('/[^a-z_\-0-9.]/i', $filename)) {
175			throw new InvalidArgumentException('None special chars allowed for filename, given: '.$filename);
176			}
177			}
178
179			// All ok, let's save the file
180			if ($isNew) {
181			if (!$file \|\| $file->getSize() == 0) {
182			throw new InvalidArgumentException('You can not create a new empty file resource. No file received.');
183			}
184			}
185
186			if ($file) {
187			$this->saveFile($document->getId(), $file->getRealPath());
188			$sfFileSys = new SfFileSystem();
189			$sfFileSys->remove($file->getRealPath());
190			}
191
192			if ($isNew) {
193			$model->insertRecord($document);
194			} else {
195			$model->updateRecord($document->getId(), $document);
196			}
197
198			// store id of new record so we don't need to re-parse body later when needed
199			$request->attributes->set('id', $document->getId());
200
201			return $document;
202			}
203
204			/**
205			* Create the basic needs for a file
206			*
207			* @param DocumentFile $document Post or Put file document
208			* @param UploadedFile $file To be used in set metadata
209			* @param DocumentFile $original If there is a original document
210			*
211			* @return DocumentFile
212			* @throws InvalidArgumentException
213			*/
214			private function buildFileDocument(FileDocument $document, $file, $original)
215			{
216			$now = new \DateTime();
217
218			// If only a file is posted, check if there is a original object and clone it
219			if ($file && $original && !$document->getMetadata()) {
220			$document = clone $original;
221			}
222
223			// Basic Metadata update
224			$metadata = $document->getMetadata() ?: new FileMetadataEmbedded();
225
226			// File related, if no file uploaded we keep original file info.
227			if ($file) {
228			$hash = $metadata->getHash();
229			if (!$hash \|\| strlen($hash)>64) {
230			$hash = hash('sha256', file_get_contents($file->getRealPath()));
231			}
232			$metadata->setHash($hash);
233			$metadata->setMime($file->getMimeType());
234			$metadata->setSize($file->getSize());
235			if (!$metadata->getFilename()) {
236			$fileName = $file->getClientOriginalName() ? $file->getClientOriginalName() : $file->getFilename();
237			$fileName = preg_replace("/[^a-zA-Z0-9.]/", "-", $fileName);
238			$metadata->setFilename($fileName);
239			}
240			} elseif ($original && ($originalMetadata = $original->getMetadata())) {
241			if (!$metadata->getFilename()) {
242			$metadata->setFilename($originalMetadata->getFilename());
243			}
244			$metadata->setHash($originalMetadata->getHash());
245			$metadata->setMime($originalMetadata->getMime());
246			$metadata->setSize($originalMetadata->getSize());
247			}
248
249			// Creation date. keep original if available
250			if ($original && $original->getMetadata() && $original->getMetadata()->getCreatedate()) {
251			$metadata->setCreatedate($original->getMetadata()->getCreatedate());
252			} else {
253			$metadata->setCreatedate($now);
254			}
255
256			$metadata->setModificationdate($now);
257			$document->setMetadata($metadata);
258
259			return $document;
260			}
261
262			/**
263			* Simple validation for post/put request
264			*
265			* @param DocumentFile $document File document
266			* @param string $requestId Request ID
267			* @return bool
268			*/
269			private function validIdRequest(FileDocument $document, $requestId)
			0 ignored issues – show Coding Style introduced 2016-11-09 09:12 UTC by Report Bug Copy Issue Report `function validIdRequest()` does not seem to conform to the naming convention (`^(?:is\|has\|should\|may\|supports)`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history...
270			{
271			if (!$requestId && !$document->getId()) {
272			return true;
273			}
274			if ($requestId === $document->getId()) {
275			return true;
276			}
277			return false;
278			}
279
280			/**
281			* Simple delete item from file system
282			*
283			* @param string $id ID of file to be deleted
284			*
285			* @return void
286			*/
287			public function remove($id)
288			{
289			if ($this->fileSystem->has($id)) {
290			$this->fileSystem->delete($id);
291			}
292			}
293
294			/**
295			* Set global uploaded file.
296			* Only ONE file allowed per upload.
297			*
298			* @param Request $request service request
299			* @return UploadedFile if file was uploaded
300			* @throws InvalidArgumentException
301			*/
302			private function getUploadedFileFromRequest(Request $request)
303			{
304			$file = false;
305
306			if ($request->files instanceof FileBag && $request->files->count() > 0) {
307			if ($request->files->count() > 1) {
308			throw new InvalidArgumentException('Only 1 file upload per requests allowed.');
309			}
310			$files = $request->files->all();
311			$file = reset($files);
312			if ($this->allowedMimeTypes && !in_array($file->getMimeType(), $this->allowedMimeTypes)) {
313			throw new InvalidArgumentException('File mime type: '.$file->getMimeType().' is not allowed.');
314			}
315			}
316
317			return $file;
318			}
319			}
320

libgraviton / graviton

Push — feature/EVO-10275-file-hash-le... ( 4522d8...3c5ea6 )

FileManager::validIdRequest() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like