AbterPhp\Files\Service\File\Downloader

Complexity

Total Complexity

17

Size/Duplication

Total Lines	152
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	getStream()	0	8	2
A	logDownload()	0	6	1
A	getPublicFile()	0	9	3
A	getUserFile()	0	14	4
A	__construct()	0	12	1
A	isAllowed()	0	13	3
A	getReadStreamCallback()	0	12	3

<?php

declare(strict_types=1);

namespace AbterPhp\Files\Service\File;

use AbterPhp\Admin\Domain\Entities\User;
use AbterPhp\Files\Authorization\FileCategoryProvider;
use AbterPhp\Files\Domain\Entities\File;
use AbterPhp\Files\Domain\Entities\FileDownload;
use AbterPhp\Files\Orm\FileDownloadRepo;
use AbterPhp\Files\Orm\FileRepo as Repo;
use AbterPhp\Framework\Authorization\Constant\Role;
use AbterPhp\Framework\Filesystem\Uploader;
use Casbin\Enforcer;
use Casbin\Exceptions\CasbinException;
use League\Flysystem\FilesystemException;
use League\Flysystem\UnableToReadFile;
use Opulence\Orm\IUnitOfWork;
use Opulence\Orm\OrmException;

class Downloader
{
    const READ_LENGTH = 8192;

    /** @var Uploader */
    protected $uploader;

    /** @var Enforcer */
    protected $enforcer;

    /** @var Repo */
    protected $repo;

    /** @var FileDownloadRepo */
    protected $fileDownloadRepo;

    /** @var IUnitOfWork */
    protected $unitOfWork;

    /**
     * Download constructor.
     *
     * @param Uploader         $uploader
     * @param Enforcer         $enforcer
     * @param Repo             $repo
     * @param FileDownloadRepo $fileDownloadRepo
     * @param IUnitOfWork      $unitOfWork
     */
    public function __construct(
        Uploader $uploader,
        Enforcer $enforcer,
        Repo $repo,
        FileDownloadRepo $fileDownloadRepo,
        IUnitOfWork $unitOfWork
    ) {
        $this->uploader         = $uploader;
        $this->enforcer         = $enforcer;
        $this->repo             = $repo;
        $this->fileDownloadRepo = $fileDownloadRepo;
        $this->unitOfWork       = $unitOfWork;
    }

    /**
     * @param string    $filesystemName
     * @param User|null $user
     *
     * @return File|null
     * @throws CasbinException
     * @throws OrmException
     */
    public function getUserFile(string $filesystemName, ?User $user = null): ?File
    {
        /** @var File $entity */
        $entity = $this->repo->getByFilesystemName($filesystemName);
        if (!$entity || !$entity->getPublicName()) {

$entity is of type AbterPhp\Files\Domain\Entities\File, thus it always evaluated to true.

            return null;
        }

        $categoryResource = $entity->getCategory()->getIdentifier();
        if (!$this->isAllowed($categoryResource, $user)) {
            throw new CasbinException(sprintf('not allowed: %s.', $categoryResource));
        }

        return $entity;
    }

    /**
     * @param string $filesystemName
     *
     * @return File|null
     * @throws OrmException
     */
    public function getPublicFile(string $filesystemName): ?File
    {
        /** @var File $entity */
        $entity = $this->repo->getPublicByFilesystemName($filesystemName);
        if (!$entity || !$entity->getPublicName()) {

$entity is of type AbterPhp\Files\Domain\Entities\File, thus it always evaluated to true.

            return null;
        }

        return $entity;
    }

    /**
     * @param File $entity
     *
     * @return callable
     * @throws FilesystemException
     */
    public function getStream(File $entity): callable
    {
        $stream = $this->uploader->getStream($entity->getFilesystemName());
        if (!$stream) {

$stream is of type false|resource, thus it always evaluated to false.

            throw new UnableToReadFile($this->uploader->getPath($entity->getFilesystemName()));
        }

        return $this->getReadStreamCallback($stream);
    }

    /**
     * @param string    $resourceIdentifier
     * @param User|null $user
     *
     * @return bool
     * @throws CasbinException
     */
    protected function isAllowed(string $resourceIdentifier, ?User $user = null): bool
    {
        if (!$user) {
            return false;
        }

        $username = $user->getUsername();
        $resource = sprintf('%s_%s', FileCategoryProvider::PREFIX, $resourceIdentifier);
        if (!$this->enforcer->enforce($username, $resource, Role::READ)) {
            return false;
        }

        return true;
    }

    /**
     * @param File $file
     * @param User $user
     *
     * @throws OrmException
     */
    public function logDownload(File $file, User $user)
    {
        $fileDownload = new FileDownload('', $file, $user, new \DateTime());
        $this->fileDownloadRepo->add($fileDownload);

        $this->unitOfWork->commit();
    }

    /**
     * @param $stream
     *
     * @return callable
     */
    protected function getReadStreamCallback($stream): callable
    {
        if (!is_resource($stream)) {
            return function () {
            };
        }

        return function () use ($stream) {
            while (!feof($stream)) {
                print(@fread($stream, static::READ_LENGTH));

Are you sure @fread($stream, static::READ_LENGTH) of type false|string can be used in print()?

                ob_flush();
                flush();
            }
        };
    }
}