FileManager::buildFileDocument() - Code Metrics - Inspection of "File hash should only allow A-Z 0-9 a-z _ -" - libgraviton/graviton - Measure and Improve Code Quality continuously with Scrutinizer

Completed

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

unknown

created 2017-04-11 07:14 UTC

FileManager::buildFileDocument() C

↳ Parent: FileManager

Complexity

Conditions	16
Paths	72

Size

Total Lines	49
Code Lines	31

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	272

Importance

Changes

Metric	Value
dl	0
loc	49
ccs	0
cts	39
cp	0
rs	5.1186
c	0
b	0
f	0
cc	16
eloc	31
nc	72
nop	3
crap	272

How to fix Complexity

<?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()));
            } else {
                $hash = preg_replace('/[^a-z0-9_-]/i', '-', $hash);
            }
            $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			} else {
232			$hash = preg_replace('/[^a-z0-9_-]/i', '-', $hash);
233			}
234			$metadata->setHash($hash);
235			$metadata->setMime($file->getMimeType());
236			$metadata->setSize($file->getSize());
237			if (!$metadata->getFilename()) {
238			$fileName = $file->getClientOriginalName() ? $file->getClientOriginalName() : $file->getFilename();
239			$fileName = preg_replace("/[^a-zA-Z0-9.]/", "-", $fileName);
240			$metadata->setFilename($fileName);
241			}
242			} elseif ($original && ($originalMetadata = $original->getMetadata())) {
243			if (!$metadata->getFilename()) {
244			$metadata->setFilename($originalMetadata->getFilename());
245			}
246			$metadata->setHash($originalMetadata->getHash());
247			$metadata->setMime($originalMetadata->getMime());
248			$metadata->setSize($originalMetadata->getSize());
249			}
250
251			// Creation date. keep original if available
252			if ($original && $original->getMetadata() && $original->getMetadata()->getCreatedate()) {
253			$metadata->setCreatedate($original->getMetadata()->getCreatedate());
254			} else {
255			$metadata->setCreatedate($now);
256			}
257
258			$metadata->setModificationdate($now);
259			$document->setMetadata($metadata);
260
261			return $document;
262			}
263
264			/**
265			* Simple validation for post/put request
266			*
267			* @param DocumentFile $document File document
268			* @param string $requestId Request ID
269			* @return bool
270			*/
271			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...
272			{
273			if (!$requestId && !$document->getId()) {
274			return true;
275			}
276			if ($requestId === $document->getId()) {
277			return true;
278			}
279			return false;
280			}
281
282			/**
283			* Simple delete item from file system
284			*
285			* @param string $id ID of file to be deleted
286			*
287			* @return void
288			*/
289			public function remove($id)
290			{
291			if ($this->fileSystem->has($id)) {
292			$this->fileSystem->delete($id);
293			}
294			}
295
296			/**
297			* Set global uploaded file.
298			* Only ONE file allowed per upload.
299			*
300			* @param Request $request service request
301			* @return UploadedFile if file was uploaded
302			* @throws InvalidArgumentException
303			*/
304			private function getUploadedFileFromRequest(Request $request)
305			{
306			$file = false;
307
308			if ($request->files instanceof FileBag && $request->files->count() > 0) {
309			if ($request->files->count() > 1) {
310			throw new InvalidArgumentException('Only 1 file upload per requests allowed.');
311			}
312			$files = $request->files->all();
313			$file = reset($files);
314			if ($this->allowedMimeTypes && !in_array($file->getMimeType(), $this->allowedMimeTypes)) {
315			throw new InvalidArgumentException('File mime type: '.$file->getMimeType().' is not allowed.');
316			}
317			}
318
319			return $file;
320			}
321			}
322

libgraviton / graviton

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

FileManager::buildFileDocument() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like