CodingSocks\UploadHandler\Driver\NgFileBaseHandler

Complexity

Total Complexity

15

Size/Duplication

Total Lines	155
Duplicated Lines	15.48 %

Coupling/Cohesion

Components	1
Dependencies	12

Test Coverage

Coverage

95%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	handle()	0	15	3
A	resume()	0	26	2
A	save()	14	14	2
A	isMonolithRequest()	0	4	1
A	validateChunkRequest()	0	9	1
A	saveMonolith()	10	10	1
A	saveChunk()	0	30	4

<?php

namespace CodingSocks\UploadHandler\Driver;

use Closure;
use CodingSocks\UploadHandler\Helper\ChunkHelpers;
use CodingSocks\UploadHandler\Identifier\Identifier;
use CodingSocks\UploadHandler\Range\NgFileUploadRange;
use CodingSocks\UploadHandler\Response\PercentageJsonResponse;
use CodingSocks\UploadHandler\StorageConfig;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Http\UploadedFile;
use Illuminate\Support\Arr;
use InvalidArgumentException;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
use Symfony\Component\HttpKernel\Exception\MethodNotAllowedHttpException;

class NgFileBaseHandler extends BaseHandler
{
    use ChunkHelpers;

    /**
     * @var \CodingSocks\UploadHandler\Identifier\Identifier
     */
    private $identifier;

    /**
     * NgFileDriver constructor.
     *
     * @param \CodingSocks\UploadHandler\Identifier\Identifier $identifier
     */
    public function __construct(Identifier $identifier)
    {
        $this->identifier = $identifier;
    }

    /**
     * @inheritDoc
     */
    public function handle(Request $request, StorageConfig $config, Closure $fileUploaded = null): Response
    {
        if ($this->isRequestMethodIn($request, [Request::METHOD_GET])) {
            return $this->resume($request, $config);
        }

        if ($this->isRequestMethodIn($request, [Request::METHOD_POST])) {
            return $this->save($request, $config, $fileUploaded);
        }

        throw new MethodNotAllowedHttpException([
            Request::METHOD_GET,
            Request::METHOD_POST,
        ]);
    }

    private function resume(Request $request, StorageConfig $config): Response
    {
        $request->validate([

The call to validate() misses a required argument $...$params.

            'file' => 'required',
            'totalSize' => 'required',
        ]);

        $originalFilename = $request->get('file');
        $totalSize = $request->get('totalSize');
        $uid = $this->identifier->generateFileIdentifier($totalSize, $originalFilename);

        if (!$this->chunkExists($config, $uid)) {
            return new JsonResponse([
                'file' => $originalFilename,
                'size' => 0,
            ]);
        }

        $chunk = Arr::last($this->chunks($config, $uid));
        $size = explode('-', basename($chunk))[1] + 1;

        return new JsonResponse([
            'file' => $originalFilename,
            'size' => $size,
        ]);
    }

    private function save(Request $request, StorageConfig $config, Closure $fileUploaded = null): Response

This method seems to be duplicated in your project.

    {
        $file = $request->file('file');

        $this->validateUploadedFile($file);

It seems like $file defined by $request->file('file') on line 87 can also be of type array; however, CodingSocks\UploadHandler\Driver\BaseHandler::validateUploadedFile() does only seem to accept null|object<Illuminate\Http\UploadedFile>, maybe add an additional type check?

        if ($this->isMonolithRequest($request)) {
            return $this->saveMonolith($file, $config, $fileUploaded);

It seems like $file defined by $request->file('file') on line 87 can also be of type array or null; however, CodingSocks\UploadHandler\Driver\NgFileBaseHandler::saveMonolith() does only seem to accept object<Illuminate\Http\UploadedFile>, maybe add an additional type check?

        }

        $this->validateChunkRequest($request);

        return $this->saveChunk($file, $request, $config, $fileUploaded);

It seems like $file defined by $request->file('file') on line 87 can also be of type array or null; however, CodingSocks\UploadHandler\Driver\NgFileBaseHandler::saveChunk() does only seem to accept object<Illuminate\Http\UploadedFile>, maybe add an additional type check?

    }

    private function isMonolithRequest(Request $request)
    {
        return empty($request->post());
    }

    /**
     * @param \Illuminate\Http\Request $request
     */
    private function validateChunkRequest(Request $request): void
    {
        $request->validate([

The call to validate() misses a required argument $...$params.

            '_chunkNumber' => 'required|numeric',
            '_chunkSize' => 'required|numeric',
            '_totalSize' => 'required|numeric',
            '_currentChunkSize' => 'required|numeric',
        ]);
    }

    /**
     * @param \Illuminate\Http\UploadedFile $file
     * @param \CodingSocks\UploadHandler\StorageConfig $config
     * @param \Closure|null $fileUploaded
     *
     * @return \Symfony\Component\HttpFoundation\Response
     */
    private function saveMonolith(UploadedFile $file, StorageConfig $config, Closure $fileUploaded = null): Response

This method seems to be duplicated in your project.

    {
        $path = $file->store($config->getMergedDirectory(), [
            'disk' => $config->getDisk(),
        ]);

        $this->triggerFileUploadedEvent($config->getDisk(), $path, $fileUploaded);

        return new PercentageJsonResponse(100);
    }

    /**
     * @param \Illuminate\Http\UploadedFile $file
     * @param \Illuminate\Http\Request $request
     * @param \CodingSocks\UploadHandler\StorageConfig $config
     * @param \Closure|null $fileUploaded
     *
     * @return \Symfony\Component\HttpFoundation\Response
     */
    private function saveChunk(UploadedFile $file, Request $request, StorageConfig $config, Closure $fileUploaded = null): Response
    {
        try {
            $range = new NgFileUploadRange($request);
        } catch (InvalidArgumentException $e) {
            throw new BadRequestHttpException($e->getMessage(), $e);
        }

        $originalFilename = $file->getClientOriginalName();
        $totalSize = $request->get('_totalSize');
        $uid = $this->identifier->generateFileIdentifier($totalSize, $originalFilename);

        $chunks = $this->storeChunk($config, $range, $file, $uid);

        if (!$range->isLast()) {
            return new PercentageJsonResponse($range->getPercentage());
        }

        $targetFilename = $file->hashName();

        $path = $this->mergeChunks($config, $chunks, $targetFilename);

        if ($config->sweep()) {
            $this->deleteChunkDirectory($config, $uid);
        }

        $this->triggerFileUploadedEvent($config->getDisk(), $path, $fileUploaded);

        return new PercentageJsonResponse(100);
    }
}