eZ\Publish\Core\IO\IOMetadataHandler\Flysystem

Complexity

Total Complexity

15

Size/Duplication

Total Lines	98
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	create()	0	4	1
A	delete()	0	3	1
A	load()	0	18	3
A	count()	0	4	1
A	getFilePrefixForScope()	0	15	4
A	loadAll()	0	5	1
A	exists()	0	4	1
A	getMimeType()	0	4	1
A	deleteDirectory()	0	3	1

<?php

/**
 * This file is part of the eZ Publish Kernel package.
 *
 * @copyright Copyright (C) eZ Systems AS. All rights reserved.
 * @license For full copyright and license information view LICENSE file distributed with this source code.
 */
namespace eZ\Publish\Core\IO\IOMetadataHandler;

use DateTime;
use eZ\Publish\Core\IO\Exception\BinaryFileNotFoundException;
use eZ\Publish\Core\IO\IOMetadataHandler;
use eZ\Publish\SPI\IO\BinaryFile as SPIBinaryFile;
use eZ\Publish\SPI\IO\BinaryFileCreateStruct as SPIBinaryFileCreateStruct;
use League\Flysystem\FileNotFoundException;
use League\Flysystem\FilesystemInterface;

class Flysystem implements IOMetadataHandler
{
    /** @var FilesystemInterface */
    private $filesystem;

    public function __construct(FilesystemInterface $filesystem)
    {
        $this->filesystem = $filesystem;
    }

    /**
     * Only reads & return metadata, since the binarydata handler took care of creating the file already.
     *
     * @throws BinaryFileNotFoundException
     */
    public function create(SPIBinaryFileCreateStruct $spiBinaryFileCreateStruct)
    {
        return $this->load($spiBinaryFileCreateStruct->id);
    }

    /**
     * Does really nothing, the binary data handler takes care of it.
     *
     * @param $spiBinaryFileId
     */
    public function delete($spiBinaryFileId)
    {
    }

    public function load($spiBinaryFileId)
    {
        try {
            $info = $this->filesystem->getMetadata($spiBinaryFileId);
        } catch (FileNotFoundException $e) {
            throw new BinaryFileNotFoundException($spiBinaryFileId);
        }

        $spiBinaryFile = new SPIBinaryFile();
        $spiBinaryFile->id = $spiBinaryFileId;
        $spiBinaryFile->size = $info['size'];

        if (isset($info['timestamp'])) {
            $spiBinaryFile->mtime = new DateTime('@' . $info['timestamp']);
        }

        return $spiBinaryFile;
    }

    public function loadAll($scope)
    {
        //TODO return SPIBinaryFiles
        return $this->filesystem->listContents($this->getFilePrefixForScope($scope), true);
    }

    public function exists($spiBinaryFileId)
    {
        return $this->filesystem->has($spiBinaryFileId);
    }

    public function getMimeType($spiBinaryFileId)
    {
        return $this->filesystem->getMimetype($spiBinaryFileId);

The expression $this->filesystem->getMimetype($spiBinaryFileId); of type string|false adds false to the return on line 80 which is incompatible with the return type declared by the interface eZ\Publish\Core\IO\IOMetadataHandler::getMimeType of type string. It seems like you forgot to handle an error condition.

    }

    /**
     * Does nothing, as the binarydata handler takes care of it.
     */
    public function deleteDirectory($spiPath)
    {
    }

    public function count($scope)
    {
        return count($this->filesystem->listContents($this->getFilePrefixForScope($scope), true));
    }

    /**
     * Get the file prefix (storage path) for the given $scope.
     *
     * @param $scope
     * @return string
     */
    private function getFilePrefixForScope($scope)
    {
        switch ($scope) {
            case 'image':
                return 'images';

            case 'binaryfile':
                return 'original';

            case 'mediafile':
                return 'original';
        }

        return 'UNKNOWN_FILE_PREFIX';
    }
}