STS\StorageConnect\Models\Concerns\UploadsFiles

Complexity

Total Complexity

14

Size/Duplication

Total Lines	107
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	upload()	0	20	3
A	preparePaths()	0	16	4
A	handleUpload()	0	15	2
A	handleUploadError()	0	22	5

<?php
namespace STS\StorageConnect\Models\Concerns;

use Carbon\Carbon;
use Illuminate\Database\Eloquent\Model;
use STS\StorageConnect\Contracts\UploadTarget;
use STS\StorageConnect\Events\UploadFailed;
use STS\StorageConnect\Events\UploadRetrying;
use STS\StorageConnect\Events\UploadSucceeded;
use STS\StorageConnect\Exceptions\UploadException;
use STS\StorageConnect\Jobs\UploadFile;

trait UploadsFiles
{
    /**
     * @param      $source
     * @param      $destinationPath
     * @param bool $shouldQueue
     * @param null $queueJob
     *
     * @return bool
     */
    public function upload($source, $destinationPath = null, $shouldQueue = true, $queueJob = null)
    {
        $this->verify();

It seems like verify() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        if ($shouldQueue) {
            return dispatch(new UploadFile($source, $destinationPath, $this));
        }

        list($sourcePath, $destinationPath, $targetModel) = $this->preparePaths($source, $destinationPath);

        try {
            return $this->handleUpload($sourcePath, $destinationPath, $targetModel);
        } catch (UploadException $exception) {
            $this->handleUploadError($exception, $queueJob, $targetModel);
        }

        $this->ping();

It seems like ping() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        return false;
    }

    /**
     * @param $source
     * @param null $destinationPath
     *
     * @return array
     */
    protected function preparePaths($source, $destinationPath = null)
    {
        if($source instanceof Model && $source instanceof UploadTarget) {
            return [
                $source->upload_source_path,
                $destinationPath ?: $source->upload_destination_path,
                $source
            ];
        }

        return [
            (string) $source,
            $destinationPath,
            null
        ];
    }

    /**
     * @param $sourcePath
     * @param $destinationPath
     * @param null $targetModel
     *
     * @return bool
     */
    protected function handleUpload($sourcePath, $destinationPath, $targetModel = null)
    {
        if (starts_with($sourcePath, "s3://")) {
            app('aws')->createClient('s3')->registerStreamWrapper();
        }

        $this->adapter()->upload($sourcePath, $destinationPath);

It seems like adapter() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $this->uploaded_at = Carbon::now();

The property uploaded_at does not exist. Did you maybe forget to declare it?

        $this->save();

It seems like save() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        event(new UploadSucceeded($this, $sourcePath, $destinationPath, $targetModel));

        return true;
    }

    /**
     * @param UploadException $exception
     * @param null $job
     * @param null $targetModel
     *
     * @return mixed
     */
    protected function handleUploadError(UploadException $exception, $job = null, $targetModel = null)
    {
        $exception->setStorage($this);

        if ($exception->shouldRetry() && $job) {
            event(new UploadRetrying($this, $exception, $targetModel));

            $job->release();

            return;
        }

        if ($exception->shouldDisable()) {
            $this->disable($exception->getReason());

It seems like disable() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        }

        if ($job) {
            $job->fail($exception);
        }

        event(new UploadFailed($this, $exception, $targetModel));
    }
}