STS\StorageConnect\Models\Concerns\UploadsFiles::preparePaths()

Complexity

Conditions	4
Paths	3

Size

Total Lines

16

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

1 Method

Rating	Name	Duplication	Size	Complexity
A	UploadsFiles::handleUpload()	0	4	1

<?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\UploadInProgress;
use STS\StorageConnect\Events\UploadRetrying;
use STS\StorageConnect\Events\UploadStarted;
use STS\StorageConnect\Events\UploadSucceeded;
use STS\StorageConnect\Exceptions\UploadException;
use STS\StorageConnect\Jobs\CheckUploadStatus;
use STS\StorageConnect\Jobs\UploadFile;
use STS\StorageConnect\UploadRequest;
use STS\StorageConnect\UploadResponse;

/**
 * @property Carbon uploaded_at
 */
trait UploadsFiles
{
    /**
     * @param      $source
     * @param      $destinationPath
     * @param bool $shouldQueue
     * @param null $queueJob
     *
     * @return UploadResponse|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));
        }

        $request = new UploadRequest($source, $destinationPath);

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

            return false;
        } finally {
            $this->ping();

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

        }
    }

    /**
     * @param UploadRequest $request
     *
     * @return UploadResponse
     */
    protected function handleUpload( UploadRequest $request )
    {
        return $this->processResponse($this->adapter()->upload($request));

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

    }

    /**
     * @param UploadResponse $response
     */
    public function checkUploadStatus( UploadResponse $response )
    {
        $this->processResponse($this->adapter()->checkUploadStatus($response));

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

    }

    /**
     * @param UploadResponse $response
     *
     * @return UploadResponse
     */
    protected function processResponse( UploadResponse $response )
    {
        if ($response->isAsync()) {
            dispatch(new CheckUploadStatus($this, $response));

            if ($response->getStatusChecks() == 0) {
                event(new UploadStarted($this, $response));
            } else {
                event(new UploadInProgress($this, $response));
            }
        } else {
            $this->uploaded_at = Carbon::now();
            $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, $response));
        }

        return $response;
    }

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

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

            $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));
    }
}