ArgentCrusade\Flysystem\Selectel\SelectelAdapter

Complexity

Total Complexity

32

Size/Duplication

Total Lines	265
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	4

Importance

Changes	2
Bugs	1	Features	0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getFile()	0	4	1
A	transformFiles()	0	15	3
A	has()	0	4	1
A	read()	0	12	2
A	readStream()	0	14	2
A	listContents()	0	7	1
A	getMetadata()	0	6	2
A	getSize()	0	4	1
A	getMimetype()	0	4	1
A	getTimestamp()	0	4	1
A	write()	0	4	1
A	writeStream()	0	4	1
A	writeToContainer()	0	10	2
A	update()	0	4	1
A	updateStream()	0	4	1
A	rename()	0	10	2
A	copy()	0	10	2
A	delete()	0	10	2
A	deleteDir()	0	10	2
A	createDir()	0	10	2

<?php

namespace ArgentCrusade\Flysystem\Selectel;

use League\Flysystem\Config;
use League\Flysystem\AdapterInterface;
use League\Flysystem\Adapter\Polyfill\NotSupportingVisibilityTrait;
use ArgentCrusade\Selectel\CloudStorage\Contracts\ContainerContract;
use ArgentCrusade\Selectel\CloudStorage\Exceptions\FileNotFoundException;
use ArgentCrusade\Selectel\CloudStorage\Exceptions\UploadFailedException;
use ArgentCrusade\Selectel\CloudStorage\Exceptions\ApiRequestFailedException;

class SelectelAdapter implements AdapterInterface
{
    use NotSupportingVisibilityTrait;

    /**
     * Storage container.
     *
     * @var \ArgentCrusade\Selectel\CloudStorage\Contracts\ContainerContract
     */
    protected $container;

    /**
     * Create new instance.
     *
     * @param \ArgentCrusade\Selectel\CloudStorage\Contracts\ContainerContract $container
     */
    public function __construct(ContainerContract $container)
    {
        $this->container = $container;
    }

    /**
     * Loads file from container.
     *
     * @param string $path Path to file.
     *
     * @return \ArgentCrusade\Selectel\CloudStorage\Contracts\FileContract
     */
    protected function getFile($path)
    {
        return $this->container->files()->find($path);
    }

    /**
     * Transforms internal files array to Flysystem-compatible one.
     *
     * @param array $files Original Selectel's files array.
     *
     * @return array
     */
    protected function transformFiles($files)
    {
        $result = [];

        foreach ($files as $file) {
            $result[] = [
                'type' => $file['content_type'] === 'application/directory' ? 'dir' : 'file',
                'path' => $file['name'],
                'size' => intval($file['bytes']),
                'timestamp' => strtotime($file['last_modified']),
            ];
        }

        return $result;
    }

    /**
     * {@inheritdoc}
     */
    public function has($path)
    {
        return $this->container->files()->exists($path);
    }

    /**
     * {@inheritdoc}
     */
    public function read($path)
    {
        try {
            $file = $this->getFile($path);
        } catch (FileNotFoundException $e) {
            return false;
        }

        $contents = $file->read();

        return compact('contents');
    }

    /**
     * {@inheritdoc}
     */
    public function readStream($path)
    {
        try {
            $file = $this->getFile($path);
        } catch (FileNotFoundException $e) {
            return false;
        }

        $stream = $file->readStream();

        rewind($stream);

        return compact('stream');
    }

    /**
     * {@inheritdoc}
     */
    public function listContents($directory = '', $recursive = false)
    {
        $files = $this->container->files()->withPrefix($directory)->get();
        $result = $this->transformFiles($files);

        return $result;
    }

    /**
     * {@inheritdoc}
     */
    public function getMetadata($path)
    {
        $files = $this->listContents($path);

        return isset($files[0]) ? $files[0] : false;
    }

    /**
     * {@inheritdoc}
     */
    public function getSize($path)
    {
        return $this->getMetadata($path);
    }

    /**
     * {@inheritdoc}
     */
    public function getMimetype($path)
    {
        return $this->getMetadata($path);
    }

    /**
     * {@inheritdoc}
     */
    public function getTimestamp($path)
    {
        return $this->getMetadata($path);
    }

    /**
     * {@inheritdoc}
     */
    public function write($path, $contents, Config $config)
    {
        return $this->writeToContainer('String', $path, $contents);
    }

    /**
     * {@inheritdoc}
     */
    public function writeStream($path, $resource, Config $config)
    {
        return $this->writeToContainer('Stream', $path, $resource);
    }

    /**
     * Writes string or stream to container.
     *
     * @param string          $type    Upload type
     * @param string          $path    File path
     * @param string|resource $payload String content or Stream resource
     *
     * @return array|bool
     */
    protected function writeToContainer($type, $path, $payload)
    {
        try {
            $this->container->{'uploadFrom'.$type}($path, $payload);
        } catch (UploadFailedException $e) {
            return false;
        }

        return $this->getMetadata($path);
    }

    /**
     * {@inheritdoc}
     */
    public function update($path, $contents, Config $config)
    {
        return $this->write($path, $contents, $config);
    }

    /**
     * {@inheritdoc}
     */
    public function updateStream($path, $resource, Config $config)
    {
        return $this->writeStream($path, $resource, $config);
    }

    /**
     * {@inheritdoc}
     */
    public function rename($path, $newpath)
    {
        try {
            $this->getFile($path)->rename($newpath);
        } catch (ApiRequestFailedException $e) {
            return false;
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function copy($path, $newpath)
    {
        try {
            $this->getFile($path)->copy($newpath);
        } catch (ApiRequestFailedException $e) {
            return false;
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function delete($path)
    {
        try {
            $this->getFile($path)->delete();
        } catch (ApiRequestFailedException $e) {
            return false;
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function deleteDir($path)
    {
        try {
            $this->container->deleteDir($path);
        } catch (ApiRequestFailedException $e) {
            return false;
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function createDir($dirname, Config $config)
    {
        try {
            $this->container->createDir($dirname);
        } catch (ApiRequestFailedException $e) {
            return false;
        }

        return $this->getMetadata($dirname);
    }
}