Jarobe\TaskRunnerBundle\Command\TaskCommand

Complexity

Total Complexity

10

Size/Duplication

Total Lines	105
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	initialize()	0	8	1
B	execute()	0	27	4
	buildTaskBuilder()	0	1	?
A	prepareTaskEvent()	0	3	1
A	preProcess()	0	3	1
A	postProcess()	0	3	1
A	validateTask()	0	10	2

<?php

namespace Jarobe\TaskRunnerBundle\Command;

use Jarobe\TaskRunnerBundle\Entity\TaskEvent;
use Jarobe\TaskRunnerBundle\Manager\TaskEventManager;
use Jarobe\TaskRunnerBundle\Manager\TaskManager;
use Jarobe\TaskRunnerBundle\Model\TaskBuilder;
use Jarobe\TaskRunnerBundle\TaskType\TaskTypeInterface;
use Symfony\Bundle\FrameworkBundle\Command\ContainerAwareCommand;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Validator\ConstraintViolationInterface;
use Symfony\Component\Validator\Validator\ValidatorInterface;

abstract class TaskCommand extends ContainerAwareCommand
{
    /** @var TaskEventManager */
    private $taskEventManager;

    /** @var TaskManager */
    private $taskManager;

    /** @var ValidatorInterface */
    private $validator;

    public function initialize(InputInterface $input, OutputInterface $output)
    {
        parent::initialize($input, $output);
        $container = $this->getContainer();
        $this->taskEventManager = $container->get('jarobe.task_runner.task_event_manager');
        $this->taskManager = $container->get('jarobe.task_runner.task_manager');
        $this->validator = $container->get('validator');
    }

    /**
     * @param InputInterface $input
     * @param OutputInterface $output
     * @return int|null
     */
    public function execute(InputInterface $input, OutputInterface $output)
    {
        $taskBuilder = new TaskBuilder();

        $taskBuilder = $this->buildTaskBuilder($taskBuilder, $input);

        $validationErrors = $this->validateTask($taskBuilder->getTask());
        foreach ($validationErrors as $validationError) {
            $taskBuilder->addError($validationError);
        }

        if ($taskBuilder->hasErrors()) {
            foreach ($taskBuilder->getErrors() as $error) {
                $output->writeln("<error>".$error."</error>");
            }
            return null;
        }

        //Create the TaskEvent
        $taskEvent = $this->taskEventManager->createTaskEvent($taskBuilder->getTask());

        $this->preProcess($taskEvent, $input, $output);

        $taskEvent = $this->taskManager->process($taskEvent);

        $this->postProcess($taskEvent, $input, $output);
    }

    /**
     * @param TaskBuilder $taskBuilder
     * @param InputInterface $input
     * @return TaskBuilder
     */
    abstract protected function buildTaskBuilder(TaskBuilder $taskBuilder, InputInterface $input);

    /**
     * Overwrite this function if you want to do something before we process the TaskEvent
     * @param TaskEvent $taskEvent
     * @param InputInterface $input
     * @param OutputInterface $output
     */
    protected function prepareTaskEvent(TaskEvent $taskEvent, InputInterface $input, OutputInterface $output)

The parameter $taskEvent is not used and could be removed.

The parameter $input is not used and could be removed.

The parameter $output is not used and could be removed.

    {
    }

    /**
     * Overwrite this function if you want to do something before we process the TaskEvent
     * @param TaskEvent $taskEvent
     * @param InputInterface $input
     * @param OutputInterface $output
     */
    protected function preProcess(TaskEvent $taskEvent, InputInterface $input, OutputInterface $output)

The parameter $taskEvent is not used and could be removed.

The parameter $input is not used and could be removed.

The parameter $output is not used and could be removed.

    {
    }

    /**
     * Overwrite this function if you want to do something before we process the TaskEvent
     * @param TaskEvent $taskEvent
     * @param InputInterface $input
     * @param OutputInterface $output
     */
    protected function postProcess(TaskEvent $taskEvent, InputInterface $input, OutputInterface $output)

The parameter $taskEvent is not used and could be removed.

The parameter $input is not used and could be removed.

The parameter $output is not used and could be removed.

    {
    }

    /**
     * @param TaskTypeInterface $task
     * @return array
     */
    protected function validateTask(TaskTypeInterface $task)
    {
        $validationErrors = [];
        $validationErrorList = $this->validator->validate($task);
        /** @var ConstraintViolationInterface $error */
        foreach($validationErrorList as $error){
            $validationErrors[] = sprintf("%s: %s", $error->getPropertyPath(), $error->getMessage());
        }
        return $validationErrors;
    }
}