Jobtech\LaravelChunky\ChunksManager

Complexity

Total Complexity

40

Size/Duplication

Total Lines	304
Duplicated Lines	0 %

Importance

Changes	4
Bugs	1	Features	0

19 Methods

Rating	Name	Duplication	Size	Complexity
B	checkChunkIntegrity()	0	20	7
A	getInstance()	0	7	2
A	validFolder()	0	4	1
A	deleteAllChunks()	0	21	5
A	getChunksFolder()	0	4	1
A	checkFilesIntegrity()	0	16	4
A	__construct()	0	7	1
A	getChunksDisk()	0	4	1
A	handleMerge()	0	19	2
A	temporaryFiles()	0	9	2
A	chunk()	0	8	2
A	handle()	0	20	3
A	getChunksOptions()	0	5	1
A	chunksFilesystem()	0	3	1
A	dispatchMerge()	0	19	2
A	chunkFolderNameFor()	0	3	1
A	deleteChunkFolder()	0	3	1
A	addChunk()	0	16	2
A	chunks()	0	3	1

<?php

namespace Jobtech\LaravelChunky;

use Illuminate\Container\Container;
use Illuminate\Http\UploadedFile;
use Illuminate\Support\Collection;
use Illuminate\Support\Str;
use Jobtech\LaravelChunky\Concerns\ChunkyRequestHelpers;
use Jobtech\LaravelChunky\Concerns\ManagerHelpers;
use Jobtech\LaravelChunky\Contracts\ChunksManager as ChunksManagerContract;
use Jobtech\LaravelChunky\Events\ChunksMerged;
use Jobtech\LaravelChunky\Exceptions\ChunksIntegrityException;
use Jobtech\LaravelChunky\Http\Requests\AddChunkRequest;
use Jobtech\LaravelChunky\Jobs\MergeChunks;
use Jobtech\LaravelChunky\Strategies\Contracts\MergeStrategy;
use Jobtech\LaravelChunky\Strategies\StrategyFactory;
use Jobtech\LaravelChunky\Support\ChunksFilesystem;

class ChunksManager implements ChunksManagerContract
{
    use ManagerHelpers;
    use ChunkyRequestHelpers;

    /** @var \Jobtech\LaravelChunky\ChunksManager|null */
    public static ?ChunksManager $instance = null;

    /** @var \Jobtech\LaravelChunky\ChunkySettings */
    private ChunkySettings $settings;

    /** @var \Jobtech\LaravelChunky\Support\ChunksFilesystem */
    private $chunksFilesystem;

    public function __construct(ChunkySettings $settings)
    {
        $this->settings = $settings;

        $this->chunksFilesystem = ChunksFilesystem::instance([
            'disk' => $settings->chunksDisk(),
            'folder' => $settings->chunksFolder(),
        ]);
    }

    /**
     * Chunks destination folder from file name slug.
     *
     * @param string $file
     *
     * @return string
     */
    private function chunkFolderNameFor(string $file)

The method chunkFolderNameFor() is not used, and could be removed.

    {
        return Str::slug($file);
    }

    /**
     * Dispatch a merge event.
     *
     * @param \Jobtech\LaravelChunky\Http\Requests\AddChunkRequest $request
     * @param string                                               $folder
     */
    private function dispatchMerge(AddChunkRequest $request, string $folder)
    {
        // TODO: Refactor

        if (empty($connection = $this->settings->connection())) {
            $this->handleMerge(
                $this->chunksFilesystem->fullPath($folder),
                $request->fileInput(),
                $request->chunkSizeInput(),
                $request->totalSizeInput()
            );
        } else {
            MergeChunks::dispatch(
                $this->chunksFilesystem->fullPath($folder),
                $request->fileInput(),
                $request->chunkSizeInput(),
                $request->totalSizeInput()
            )->onConnection($connection)
                ->onQueue($this->settings->queue());
        }
    }

    /**
     * {@inheritdoc}
     */
    public function chunksFilesystem(): ChunksFilesystem
    {
        return $this->chunksFilesystem;
    }

    /**
     * {@inheritdoc}
     */
    public function getChunksDisk(): ?string
    {
        return $this->settings
            ->chunksDisk();
    }

    /**
     * {@inheritdoc}
     */
    public function getChunksFolder(): string
    {
        return $this->settings
            ->chunksFolder();
    }

    /**
     * {@inheritdoc}
     */
    public function getChunksOptions(): array
    {
        return array_merge([
            'disk' => $this->getChunksDisk(),
        ], $this->settings->additionalChunksOptions());
    }

    /**
     * {@inheritdoc}
     */
    public function validFolder(string $folder): bool
    {
        return $this->chunksFilesystem()->exists(
            $this->chunksFilesystem->fullPath($folder)
        );
    }

    /**
     * {@inheritdoc}
     */
    public function temporaryFiles(string $folder): Collection
    {
        $chunks = $this->chunks($folder);
        if (! $this->chunksFilesystem->isLocal()) {
            return $this->chunksFilesystem->createTemporaryFiles($folder, $chunks);
        }

        return $chunks->map(function (Chunk $chunk) {
            return $chunk->getPath();
        });
    }

    /**
     * {@inheritdoc}
     */
    public function chunks($folder = null): Collection
    {
        return $this->chunksFilesystem()->listChunks($folder);
    }

    /**
     * {@inheritdoc}
     */
    public function chunk($chunk)
    {
        if ($chunk instanceof Chunk) {
            $chunk = $chunk->getPath();
        }

        return $this->chunksFilesystem()
            ->readChunk($chunk);
    }

    /**
     * {@inheritdoc}
     */
    public function addChunk(UploadedFile $file, int $index, string $folder): Chunk
    {
        // Check integrity
        if (! $this->checkChunkIntegrity($folder, $index)) {
            throw new ChunksIntegrityException("Uploaded chunk with index {$index} violates the integrity");
        }

        // Store chunk
        return $this->chunksFilesystem->store(
            Chunk::create(
                $file,
                $index,
                $this->getChunksOptions()
            ),
            $this->chunksFilesystem->fullPath($folder),
            $this->getChunksOptions()
        );
    }

    /**
     * {@inheritdoc}
     */
    public function deleteChunkFolder(string $folder): bool
    {
        return $this->chunksFilesystem->delete($folder);
    }

    /**
     * {@inheritdoc}
     */
    public function deleteAllChunks($output = null): bool
    {
        $folders = $this->chunksFilesystem()->folders();

        $progress_bar = $this->hasProgressBar($output, count($folders));

        foreach ($folders as $folder) {
            if (! $this->deleteChunkFolder($folder)) {
                return false;
            }

            if ($progress_bar !== null) {
                $progress_bar->advance();
            }
        }

        if ($progress_bar !== null) {
            $progress_bar->finish();
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function handle(AddChunkRequest $request, $folder = null): Chunk
    {
        // Store chunk
        $folder = $this->checkFolder($request, $folder);
        $chunk = $this->addChunk(
            $request->fileInput(),
            $request->indexInput(),
            $folder
        );

        $chunk->setLast(
            $this->isLastIndex($request)
        );

        // Check merge
        if ($chunk->isLast() && $this->settings->autoMerge()) {
            $this->dispatchMerge($request, $folder);
        }

        return $chunk;
    }

    /**
     * {@inheritdoc}
     */
    public function handleMerge(string $folder, string $destination, int $chunk_size, int $total_size)
    {
        if (! $this->checkFilesIntegrity($folder, $chunk_size, $total_size)) {
            throw new ChunksIntegrityException('Chunks total file size doesnt match with original file size');
        }

        $factory = StrategyFactory::getInstance();
        /** @var MergeStrategy $strategy */
        $strategy = $factory->buildFrom($this, MergeManager::getInstance());
        $strategy->chunksFolder($folder);
        $destination = $strategy->destination($destination);

        $strategy->merge();

        event(new ChunksMerged(
            $strategy, $destination
        ));

        return $destination;
    }

    /**
     * {@inheritdoc}
     */
    public function checkChunkIntegrity(string $folder, int $index): bool
    {
        $path = $this->chunksFilesystem()->fullPath($folder);
        $default = $this->settings->defaultIndex();

        if (! $this->chunksFilesystem()->exists($path) && $index != $default) {
            return false;
        } elseif ($this->chunksFilesystem()->exists($path)) {
            if (ChunkySettings::INDEX_ZERO != $default) {
                $index -= $default;
            }

            return $this->chunksFilesystem()->chunksCount($path) == $index;
        } elseif ($index == $default) {
            if (! $this->chunksFilesystem()->makeDirectory($path)) {
                throw new ChunksIntegrityException("Cannot create chunks folder $path");
            }
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function checkFilesIntegrity(string $folder, int $chunk_size, int $total_size): bool
    {
        $total = 0;
        $chunks = $this->chunks($folder);

        foreach ($chunks as $chunk) {
            $size = $this->chunksFilesystem->chunkSize($chunk->getPath());

            if ($size < $chunk_size && ! $chunk->isLast()) {
                return false;
            }

            $total += $size;
        }

        return $total >= $total_size;
    }

    public static function getInstance(): ChunksManager
    {
        if (static::$instance === null) {
            static::$instance = Container::getInstance()->make(ChunksManagerContract::class);
        }

        return static::$instance;

The expression return static::instance could return the type null which is incompatible with the type-hinted return Jobtech\LaravelChunky\ChunksManager. Consider adding an additional type-check to rule them out.

    }
}