AppBundle\Sync\TaskGenerator

Complexity

Total Complexity

15

Size/Duplication

Total Lines	187
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

97.33%

Importance

Changes	4
Bugs	1	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	getSlavePath()	0	8	1
A	getHash()	0	13	2
A	setSlavePathTpl()	0	4	1
A	getSlavePathTpl()	0	11	2
B	handle()	0	85	6
A	getLogger()	0	8	2
A	setLogger()	0	4	1

<?php
namespace AppBundle\Sync;

use AppBundle\Exception\TaskException;
use AppBundle\Sync\Entity\FileCollection;
use AppBundle\Sync\Entity\Task;
use AppBundle\Sync\Entity\Task\Add;
use AppBundle\Sync\Entity\Task\Delete;
use AppBundle\Sync\Entity\Task\Update;
use AppBundle\Sync\Entity\TaskCollection;
use AppBundle\Sync\Entity\File;
use Psr\Log\NullLogger;
use Psr\Log\LoggerInterface;

/**
 * Compare two FileCollections and generate tasks
 *
 * @author Sergey Sadovoi <serg.sadovoi@gmail.com>
 */
class TaskGenerator
{
    /**
     * @var string Path for slave file
     */
    protected $slavePathTpl;
    /**
     * @var LoggerInterface
     */
    protected $logger;

    /**
     * @param string $path
     */
    public function setSlavePathTpl($path)
    {
        $this->slavePathTpl = $path;
    }

    /**
     * @return string
     *
     * @throws TaskException
     */
    public function getSlavePathTpl()
    {
        if ($this->slavePathTpl == '') {
            throw new TaskException(
                '[TaskGenerator] You must set the Slave Path template',
                TaskException::SLAVE_PATH_NOT_SET
            );
        }

        return $this->slavePathTpl;
    }

    /**
     * Get the slave path form template
     *
     * @param string $uid  File uid
     *
     * @return string  Path to file
     */
    public function getSlavePath($uid)
    {
        $path = $this->getSlavePathTpl();
        $path = str_replace('__uid__', $uid, $path);
        $path = str_replace('__program__', substr($uid, 0, 4), $path);

        return $path;
    }

    /**
     * Compare collections and create tasks
     *
     * @param FileCollection $master
     * @param FileCollection $slave
     *
     * @return TaskCollection
     */
    public function handle(FileCollection $master, FileCollection $slave)
    {
        $masterHash = $this->getHash($master);
        $slaveHash  = $this->getHash($slave);

        $tasks = new TaskCollection();
        $createTaskCounter = 0;
        $deleteTaskCounter = 0;

        $logger = $this->getLogger();

        /**
         * Add and Update
         *
         * @var File $masterFile
         * @var File $slaveFile
         */
        $diff = array_diff_assoc($masterHash, $slaveHash);

        foreach ($diff as $uid => $hash) {
            $masterFile = $master->getByUid($uid);
            $slaveFile  = $slave->getByUid($uid);

            $new = !isset($slaveHash[$uid]);
            if ($new) {
                $task = new Add();
            } else {
                $task = new Update();
            }

            $task->setSourcePath($masterFile->getPath());
            $task->setDestPath($this->getSlavePath($uid));

            $tasks->addTask($task);

            $logger->info(
                sprintf(
                    '[TaskGenerator] Generated "%s" task based on files: S[%s] D[%s]',
                    $task->getName(),
                    $masterFile,
                    $slaveFile
                )
            );

            $createTaskCounter++;
        }

        // Delete
        $diff = array_diff_assoc($slaveHash, $masterHash);

        foreach ($diff as $uid => $hash) {
            // Skip changed files
            if (isset($masterHash[$uid])) {
                continue;
            }

            // Delete task
            $slaveFile = $slave->getByUid($uid);

            $task = new Delete();
            $task->setDestPath($slaveFile->getPath());

            $tasks->addTask($task);

            $logger->info(
                sprintf(
                    '[TaskGenerator] Generated "%s" task based on file: D[%s]',
                    $task->getName(),
                    $slaveFile
                )
            );

            $deleteTaskCounter++;
        }

        // Halt on huge delete action
        if ($deleteTaskCounter > 50) {
            throw new TaskException(
                'Huge amount of DELETE tasks. Exiting.',
                TaskException::HUGE_AMOUNT_TO_DELETE
            );
        }

        return $tasks;
    }

    /**
     * Calculates hashes for FileCollection
     *
     * @param FileCollection $files
     *
     * @return array  of hashes
     */
    private function getHash(FileCollection $files)
    {
        $hash = [];

        /**
         * @var File $file
         */
        foreach ($files as $file) {
            $hash[$file->getUid()] = md5($file->getUid() . $file->getSize());
        }

        return $hash;
    }

    /**
     * @return LoggerInterface
     */
    protected function getLogger()
    {
        if (is_null($this->logger)) {
            return new NullLogger();
        }

        return $this->logger;
    }

    /**
     * @param LoggerInterface $logger
     */
    public function setLogger(LoggerInterface $logger)
    {
        $this->logger = $logger;
    }
}