Dispatcher - Code Metrics - Inspection of "sm-110 Реализация мод workflow-zf2-toolkit" - old-town/workflow-zf2-dispatch - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — dev ( 40bda2...5b7120 )

by Андрей

created 2016-02-18 17:34 UTC

Dispatcher F

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	505
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	19

Importance

Changes	3
Bugs	0	Features	0

Metric	Value
wmc	53
c	3
b	0
f	0
lcom	1
cbo	19
dl	0
loc	505
rs	3.4784

21 Methods

Rating	Name	Size	Complexity
A	__construct()	4	1
A	init()	6	1
C	dispatch()	62	12
A	attachDefaultListeners()	8	1
B	onLoadMetadataHandler()	25	4
C	onPrepareDataHandler()	38	7
C	onCheckRunWorkflowHandler()	67	9
B	onRunWorkflowHandler()	40	4
A	factoryTransientVars()	6	1
A	workflowDispatchEventFactory()	6	1
A	factoryClassName()	13	2
A	getWorkflowService()	4	1
A	setWorkflowService()	6	1
A	getMetadataReader()	4	1
A	setMetadataReader()	6	1
A	getValidatorManager()	4	1
A	setValidatorManager()	6	1
A	getWorkflowDispatchEventClassName()	4	1
A	setWorkflowDispatchEventClassName()	6	1
A	getTransientVarsClassName()	4	1
A	setTransientVarsClassName()	6	1

How to fix Complexity

<?php
/**
 * @link https://github.com/old-town/workflow-zf2-dispatch
 * @author  Malofeykin Andrey  <[email protected]>
 */
namespace OldTown\Workflow\ZF2\Dispatch\Dispatcher;

use OldTown\Workflow\TransientVars\TransientVarsInterface;
use Zend\EventManager\EventManagerAwareTrait;
use OldTown\Workflow\ZF2\ServiceEngine\Workflow as WorkflowService;
use OldTown\Workflow\ZF2\Dispatch\Metadata\ReaderInterface;
use ReflectionClass;
use OldTown\Workflow\ZF2\Dispatch\Metadata\Target\Dispatch\MetadataInterface;
use Zend\Mvc\Controller\AbstractController;
use Traversable;
use Zend\Stdlib\ArrayUtils;
use Zend\Validator\ValidatorPluginManager;
use Zend\Validator\ValidatorChain;
use Zend\Validator\ValidatorInterface;
use OldTown\Workflow\TransientVars\BaseTransientVars;
use OldTown\Workflow\ZF2\ServiceEngine\Workflow\TransitionResultInterface;


/**
 * Class Dispatcher
 *
 * @package OldTown\Workflow\ZF2\Dispatch\Dispatcher
 */
class Dispatcher implements DispatcherInterface
{
    use EventManagerAwareTrait;

    /**
     * @var string
     */
    const WORKFLOW_DISPATCH_EVENT = 'workflowDispatchEvent';

    /**
     * Имя класса события
     *
     * @var string
     */
    protected $workflowDispatchEventClassName = WorkflowDispatchEvent::class;

    /**
     * Имя класса события
     *
     * @var string
     */
    protected $transientVarsClassName = BaseTransientVars::class;

    /**
     * @var WorkflowService
     */
    protected $workflowService;

    /**
     * @var ReaderInterface
     */
    protected $metadataReader;

    /**
     * @var ValidatorPluginManager
     */
    protected $validatorManager;

    /**
     * @param array $options
     */
    public function __construct(array $options = [])
    {
        call_user_func_array([$this, 'init'], $options);
    }

    /**
     * @param WorkflowService        $workflowService
     * @param ReaderInterface        $metadataReader
     * @param ValidatorPluginManager $validatorManager
     */
    protected function init(WorkflowService $workflowService, ReaderInterface $metadataReader, ValidatorPluginManager $validatorManager)
    {
        $this->setWorkflowService($workflowService);
        $this->setMetadataReader($metadataReader);
        $this->setValidatorManager($validatorManager);
    }

    /**
     * Диспетчирезация работы с workflow
     *
     * @param WorkflowDispatchEventInterface $event
     *
     * @return void
     *
     * @throws Exception\RunWorkflowParamException
     */
    public function dispatch(WorkflowDispatchEventInterface $event)
    {
        $event->getMvcEvent()->setParam(static::WORKFLOW_DISPATCH_EVENT, $event);
        $event->setTarget($this);

        $metadataResult = $this->getEventManager()->trigger(WorkflowDispatchEventInterface::LOAD_METADATA_EVENT, $event, function ($test) {
            return ($test instanceof MetadataInterface);
        });
        $metadata = $metadataResult->last();

        if (!$metadata instanceof MetadataInterface) {
            return;
        }

        $event->setMetadata($metadata);

        $prepareData = [];
        if ($metadata->isFlagRunPrepareData()) {
            $prepareDataResults = $this->getEventManager()->trigger(WorkflowDispatchEventInterface::PREPARE_DATA_EVENT, $event);
            foreach ($prepareDataResults as $prepareDataResult) {
                if (is_array($prepareDataResult) || $prepareDataResult instanceof Traversable) {
                    $prepareData = ArrayUtils::merge($prepareData, $prepareDataResult);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
                }
            }
        }
        $event->setPrepareData($prepareData);


        $flagRunWorkflow = $metadata->isWorkflowDispatch();
        if (true === $flagRunWorkflow) {
            $dispatchConditionsResults = $this->getEventManager()->trigger(WorkflowDispatchEventInterface::CHECK_RUN_WORKFLOW_EVENT, $event);
            foreach ($dispatchConditionsResults as $dispatchConditionsResult) {
                if (false === $dispatchConditionsResult) {
                    $flagRunWorkflow = false;
                    break;
                }
            }
        }

        if (true === $flagRunWorkflow) {
            $runWorkflowParamResults = $this->getEventManager()->trigger(WorkflowDispatchEventInterface::METADATA_WORKFLOW_TO_RUN_EVENT, $event, function ($result) {
                return ($result instanceof RunWorkflowParamInterface);
            });
            $runWorkflowParamResult = $runWorkflowParamResults->last();

            if (!$runWorkflowParamResult instanceof RunWorkflowParamInterface) {
                $errMsg = 'There is no evidence to launch workflow';
                throw new Exception\RunWorkflowParamException($errMsg);
            }
            $event->setRunWorkflowParam($runWorkflowParamResult);


            $runWorkflowResults = $this->getEventManager()->trigger(WorkflowDispatchEventInterface::RUN_WORKFLOW_EVENT, $event, function ($result) {
                return ($result instanceof TransitionResultInterface);
            });

            $workflowResult = $runWorkflowResults->last();
            if ($workflowResult instanceof TransitionResultInterface) {
                $event->setWorkflowResult($workflowResult);
            }
        }
    }

    /**
     * Добавление подписчиков по умолчанию
     *
     */
    public function attachDefaultListeners()
    {
        $em = $this->getEventManager();
        $em->attach(WorkflowDispatchEventInterface::LOAD_METADATA_EVENT, [$this, 'onLoadMetadataHandler']);
        $em->attach(WorkflowDispatchEventInterface::PREPARE_DATA_EVENT, [$this, 'onPrepareDataHandler']);
        $em->attach(WorkflowDispatchEventInterface::CHECK_RUN_WORKFLOW_EVENT, [$this, 'onCheckRunWorkflowHandler']);
        $em->attach(WorkflowDispatchEventInterface::RUN_WORKFLOW_EVENT, [$this, 'onRunWorkflowHandler']);
    }

    /**
     * Получение метаданных
     *
     * @param WorkflowDispatchEventInterface $e
     *
     * @return MetadataInterface|null
     */
    public function onLoadMetadataHandler(WorkflowDispatchEventInterface $e)
    {
        $mvcEvent = $e->getMvcEvent();
        $controller = $mvcEvent->getTarget();
        if (!$controller instanceof AbstractController) {
            return null;
        }

        $routeMatch = $mvcEvent->getRouteMatch();
        if (!$routeMatch) {
            return null;
        }

        $action = $routeMatch->getParam('action', 'not-found');
        $actionMethod = AbstractController::getMethodFromAction($action);

        if (!method_exists($controller, $actionMethod)) {
            return null;
        }

        $controllerClassName = get_class($controller);
        $metadata = $this->getMetadataReader()->loadMetadataForAction($controllerClassName, $actionMethod);

        return $metadata;
    }

    /**
     * @param WorkflowDispatchEventInterface $e
     *
     * @return mixed|null
     *
     * @throws Exception\PrepareDataException
     */
    public function onPrepareDataHandler(WorkflowDispatchEventInterface $e)
    {
        $metadata = $e->getMetadata();

        $type = $metadata->getPrepareDataMethod();
        $handler = $metadata->getPrepareDataHandler();

        $prepareDataResult = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

        if ('method' === $type) {
            $mvcEvent = $e->getMvcEvent();
            $controller = $mvcEvent->getTarget();
            if (!$controller instanceof AbstractController) {
                $errMsg = sprintf('Controller not implement %s', AbstractController::class);
                throw new Exception\PrepareDataException($errMsg);
            }
            $callback = [$controller, $handler];
            if (!is_callable($callback)) {
                $errMsg = sprintf('Invalid handler"%s"', $handler);
                throw new Exception\PrepareDataException($errMsg);
            }
            $prepareDataResult = call_user_func($callback, $e);
            if (null === $prepareDataResult) {
                $prepareDataResult = [];
            }
        } else {
            $errMsg = sprintf('Preparing data for Workflow will fail. Unknown handler type %s.', $type);
            throw new Exception\PrepareDataException($errMsg);
        }

        if (!is_array($prepareDataResult) && !$prepareDataResult instanceof Traversable) {
            $errMsg = 'Data preparation The results should be an array or Traversable';
            throw new Exception\PrepareDataException($errMsg);
        }


        return $prepareDataResult;
    }

    /**
     * Проверка, на то нужно ли запускать workflow
     *
     * @param WorkflowDispatchEventInterface $e
     *
     * @return boolean|null
     *
     * @throws \Zend\Validator\Exception\InvalidArgumentException
     * @throws  Exception\PrepareDataException
     */
    public function onCheckRunWorkflowHandler(WorkflowDispatchEventInterface $e)
    {
        $metadata = $e->getMetadata();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        if (!$metadata->getFlagHasConditions()) {
            return null;
        }

        try {
            $conditions = $metadata->getConditions();

            $validatorManager = $this->getValidatorManager();

            /** @var ValidatorChain $validatorChains */
            $validatorChains = $validatorManager->get(ValidatorChain::class);
        } catch (\Exception $e) {
            throw new Exception\PrepareDataException($e->getMessage(), $e->getCode(), $e);
        }



        $mvcEvent = $e->getMvcEvent();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $controller = $mvcEvent->getTarget();
        if (!$controller instanceof AbstractController) {
            $controller = null;
        }


        foreach ($conditions as $condition) {
            try {
                $type = $condition->getType();
                $handler = $condition->getHandler();
                switch ($type) {
                    case 'method': {
                        if (null === $controller) {
                            $errMsg = 'Controller not specified';
                            throw new Exception\CheckRunWorkflowEventException($errMsg);
                        }
                        $callback = [$controller, $handler];

                        /** @var ValidatorInterface $callbackValidator */
                        $callbackValidator = $validatorManager->get('callback', $callback);

                        $validatorChains->attach($callbackValidator);

                        break;
                    }
                    case 'service': {
                        $validatorParams = $condition->getParams();
                        /** @var ValidatorInterface $validator */
                        $validator = $validatorManager->get($handler, $validatorParams);

                        $validatorChains->attach($validator);

                        break;
                    }
                    default: {
                        $errMsg = sprintf('Preparing data for Workflow will fail. Unknown handler type %s.', $type);
                        throw new Exception\PrepareDataException($errMsg);
                    }
                }
            } catch (\Exception $e) {
                throw new Exception\PrepareDataException($e->getMessage(), $e->getCode(), $e);
            }
        }

        return $validatorChains->isValid($e);
    }

    /**
     * Запуск workflow
     *
     * @param WorkflowDispatchEventInterface $e
     *
     * @return TransitionResultInterface
     *
     *
     * @throws Exception\InvalidArgumentException
     * @throws  Exception\WorkflowDispatchEventException
     * @throws \OldTown\Workflow\ZF2\ServiceEngine\Exception\InvalidInitializeWorkflowEntryException
     * @throws \OldTown\Workflow\ZF2\ServiceEngine\Exception\DoActionException
     */
    public function onRunWorkflowHandler(WorkflowDispatchEventInterface $e)
    {
        $runWorkflowParam = $e->getRunWorkflowParam();
        $runWorkflowParam->valid();

        $transientVars = $this->factoryTransientVars();

        $prepareData = $e->getPrepareData();
        foreach ($prepareData as $key => $value) {
            $transientVars[$key] = $value;
        }

        $runWorkflowParam = $e->getRunWorkflowParam();
        $runWorkflowParam->valid();

        $workflowManagerName = $runWorkflowParam->getManagerName();
        $workflowActionName = $runWorkflowParam->getActionName();

        $workflowActivity = $runWorkflowParam->getRunType();
        $result = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        switch ($runWorkflowParam->getRunType()) {
            case RunWorkflowParamInterface::WORKFLOW_RUN_INITIALIZE: {
                $workflowName = $runWorkflowParam->getWorkflowName();
                $result = $this->getWorkflowService()->initialize($workflowManagerName, $workflowName, $workflowActionName, $transientVars);
                break;
            }
            case RunWorkflowParamInterface::WORKFLOW_RUN_TYPE_DO_ACTION: {
                $entryId = $runWorkflowParam->getEntryId();

                $result = $this->getWorkflowService()->doAction($workflowManagerName, $entryId, $workflowActionName, $transientVars);
                break;
            }
            default: {
                $errMsg = sprintf('Invalid activity %s', $workflowActivity);
                throw new Exception\InvalidArgumentException($errMsg);
            }
        }

        return $result;
    }

    /**
     *
     * @return TransientVarsInterface
     *
     * @throws Exception\WorkflowDispatchEventException
     */
    public function factoryTransientVars()
    {
        $className = $this->getTransientVarsClassName();

        return $this->factoryClassName($className, TransientVarsInterface::class);
    }

    /**
     * Фабрика для создания событий
     *
     * @return WorkflowDispatchEventInterface
     *
     * @throws Exception\WorkflowDispatchEventException
     */
    public function workflowDispatchEventFactory()
    {
        $className = $this->getWorkflowDispatchEventClassName();

        return $this->factoryClassName($className, WorkflowDispatchEventInterface::class);
    }

    /**
     * Создает экземпляр класса и проверяет то что созданный объект имплементирует заданный интерфейс
     *
     * @param $className
     * @param $interface
     *
     * @return mixed
     *
     * @throws  Exception\WorkflowDispatchEventException
     */
    protected function factoryClassName($className, $interface)
    {
        $r = new ReflectionClass($className);

        $instance = $r->newInstance();

        if (!$instance instanceof $interface) {
            $errMsg = sprintf('Class %s not implement %s', $className, $interface);
            throw new Exception\WorkflowDispatchEventException($errMsg);
        }

        return $instance;
    }

    /**
     * @return WorkflowService
     */
    public function getWorkflowService()
    {
        return $this->workflowService;
    }

    /**
     * @param WorkflowService $workflowService
     *
     * @return $this
     */
    public function setWorkflowService(WorkflowService $workflowService)
    {
        $this->workflowService = $workflowService;

        return $this;
    }

    /**
     * @return ReaderInterface
     */
    public function getMetadataReader()
    {
        return $this->metadataReader;
    }

    /**
     * @param ReaderInterface $metadataReader
     *
     * @return $this
     */
    public function setMetadataReader(ReaderInterface $metadataReader)
    {
        $this->metadataReader = $metadataReader;

        return $this;
    }

    /**
     * @return ValidatorPluginManager
     */
    public function getValidatorManager()
    {
        return $this->validatorManager;
    }

    /**
     * @param ValidatorPluginManager $validatorManager
     *
     * @return $this
     */
    public function setValidatorManager(ValidatorPluginManager $validatorManager)
    {
        $this->validatorManager = $validatorManager;

        return $this;
    }

    /**
     * @return string
     */
    public function getWorkflowDispatchEventClassName()
    {
        return $this->workflowDispatchEventClassName;
    }

    /**
     * @param string $workflowDispatchEventClassName
     *
     * @return $this
     */
    public function setWorkflowDispatchEventClassName($workflowDispatchEventClassName)
    {
        $this->workflowDispatchEventClassName = (string)$workflowDispatchEventClassName;

        return $this;
    }

    /**
     * @return string
     */
    public function getTransientVarsClassName()
    {
        return $this->transientVarsClassName;
    }

    /**
     * @param string $transientVarsClassName
     *
     * @return $this
     */
    public function setTransientVarsClassName($transientVarsClassName)
    {
        $this->transientVarsClassName = (string)$transientVarsClassName;

        return $this;
    }
}


GitHub Access Token became invalid

Push — dev ( 40bda2...5b7120 )

Dispatcher F

Complexity

Size/Duplication

Coupling/Cohesion

Importance

21 Methods

How to fix Complexity

Complex Class

Available Fixes

Available Fixes

1			<?php
2			/**
3			* @link https://github.com/old-town/workflow-zf2-dispatch
4			* @author Malofeykin Andrey <[email protected]>
5			*/
6			namespace OldTown\Workflow\ZF2\Dispatch\Dispatcher;
7
8			use OldTown\Workflow\TransientVars\TransientVarsInterface;
9			use Zend\EventManager\EventManagerAwareTrait;
10			use OldTown\Workflow\ZF2\ServiceEngine\Workflow as WorkflowService;
11			use OldTown\Workflow\ZF2\Dispatch\Metadata\ReaderInterface;
12			use ReflectionClass;
13			use OldTown\Workflow\ZF2\Dispatch\Metadata\Target\Dispatch\MetadataInterface;
14			use Zend\Mvc\Controller\AbstractController;
15			use Traversable;
16			use Zend\Stdlib\ArrayUtils;
17			use Zend\Validator\ValidatorPluginManager;
18			use Zend\Validator\ValidatorChain;
19			use Zend\Validator\ValidatorInterface;
20			use OldTown\Workflow\TransientVars\BaseTransientVars;
21			use OldTown\Workflow\ZF2\ServiceEngine\Workflow\TransitionResultInterface;
22
23
24			/**
25			* Class Dispatcher
26			*
27			* @package OldTown\Workflow\ZF2\Dispatch\Dispatcher
28			*/
29			class Dispatcher implements DispatcherInterface
30			{
31			use EventManagerAwareTrait;
32
33			/**
34			* @var string
35			*/
36			const WORKFLOW_DISPATCH_EVENT = 'workflowDispatchEvent';
37
38			/**
39			* Имя класса события
40			*
41			* @var string
42			*/
43			protected $workflowDispatchEventClassName = WorkflowDispatchEvent::class;
44
45			/**
46			* Имя класса события
47			*
48			* @var string
49			*/
50			protected $transientVarsClassName = BaseTransientVars::class;
51
52			/**
53			* @var WorkflowService
54			*/
55			protected $workflowService;
56
57			/**
58			* @var ReaderInterface
59			*/
60			protected $metadataReader;
61
62			/**
63			* @var ValidatorPluginManager
64			*/
65			protected $validatorManager;
66
67			/**
68			* @param array $options
69			*/
70			public function __construct(array $options = [])
71			{
72			call_user_func_array([$this, 'init'], $options);
73			}
74
75			/**
76			* @param WorkflowService $workflowService
77			* @param ReaderInterface $metadataReader
78			* @param ValidatorPluginManager $validatorManager
79			*/
80			protected function init(WorkflowService $workflowService, ReaderInterface $metadataReader, ValidatorPluginManager $validatorManager)
81			{
82			$this->setWorkflowService($workflowService);
83			$this->setMetadataReader($metadataReader);
84			$this->setValidatorManager($validatorManager);
85			}
86
87			/**
88			* Диспетчирезация работы с workflow
89			*
90			* @param WorkflowDispatchEventInterface $event
91			*
92			* @return void
93			*
94			* @throws Exception\RunWorkflowParamException
95			*/
96			public function dispatch(WorkflowDispatchEventInterface $event)
97			{
98			$event->getMvcEvent()->setParam(static::WORKFLOW_DISPATCH_EVENT, $event);
99			$event->setTarget($this);
100
101			$metadataResult = $this->getEventManager()->trigger(WorkflowDispatchEventInterface::LOAD_METADATA_EVENT, $event, function ($test) {
102			return ($test instanceof MetadataInterface);
103			});
104			$metadata = $metadataResult->last();
105
106			if (!$metadata instanceof MetadataInterface) {
107			return;
108			}
109
110			$event->setMetadata($metadata);
111
112			$prepareData = [];
113			if ($metadata->isFlagRunPrepareData()) {
114			$prepareDataResults = $this->getEventManager()->trigger(WorkflowDispatchEventInterface::PREPARE_DATA_EVENT, $event);
115			foreach ($prepareDataResults as $prepareDataResult) {
116			if (is_array($prepareDataResult) \|\| $prepareDataResult instanceof Traversable) {
117			$prepareData = ArrayUtils::merge($prepareData, $prepareDataResult);
			0 ignored issues – show Bug introduced 2016-02-12 08:23 UTC by Report Bug Copy Issue Report It seems like `$prepareDataResult` defined by `$prepareDataResult` on line `115` can also be of type `object<Traversable>`; however, `Zend\Stdlib\ArrayUtils::merge()` does only seem to accept `array`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
118			}
119			}
120			}
121			$event->setPrepareData($prepareData);
122
123
124			$flagRunWorkflow = $metadata->isWorkflowDispatch();
125			if (true === $flagRunWorkflow) {
126			$dispatchConditionsResults = $this->getEventManager()->trigger(WorkflowDispatchEventInterface::CHECK_RUN_WORKFLOW_EVENT, $event);
127			foreach ($dispatchConditionsResults as $dispatchConditionsResult) {
128			if (false === $dispatchConditionsResult) {
129			$flagRunWorkflow = false;
130			break;
131			}
132			}
133			}
134
135			if (true === $flagRunWorkflow) {
136			$runWorkflowParamResults = $this->getEventManager()->trigger(WorkflowDispatchEventInterface::METADATA_WORKFLOW_TO_RUN_EVENT, $event, function ($result) {
137			return ($result instanceof RunWorkflowParamInterface);
138			});
139			$runWorkflowParamResult = $runWorkflowParamResults->last();
140
141			if (!$runWorkflowParamResult instanceof RunWorkflowParamInterface) {
142			$errMsg = 'There is no evidence to launch workflow';
143			throw new Exception\RunWorkflowParamException($errMsg);
144			}
145			$event->setRunWorkflowParam($runWorkflowParamResult);
146
147
148			$runWorkflowResults = $this->getEventManager()->trigger(WorkflowDispatchEventInterface::RUN_WORKFLOW_EVENT, $event, function ($result) {
149			return ($result instanceof TransitionResultInterface);
150			});
151
152			$workflowResult = $runWorkflowResults->last();
153			if ($workflowResult instanceof TransitionResultInterface) {
154			$event->setWorkflowResult($workflowResult);
155			}
156			}
157			}
158
159			/**
160			* Добавление подписчиков по умолчанию
161			*
162			*/
163			public function attachDefaultListeners()
164			{
165			$em = $this->getEventManager();
166			$em->attach(WorkflowDispatchEventInterface::LOAD_METADATA_EVENT, [$this, 'onLoadMetadataHandler']);
167			$em->attach(WorkflowDispatchEventInterface::PREPARE_DATA_EVENT, [$this, 'onPrepareDataHandler']);
168			$em->attach(WorkflowDispatchEventInterface::CHECK_RUN_WORKFLOW_EVENT, [$this, 'onCheckRunWorkflowHandler']);
169			$em->attach(WorkflowDispatchEventInterface::RUN_WORKFLOW_EVENT, [$this, 'onRunWorkflowHandler']);
170			}
171
172			/**
173			* Получение метаданных
174			*
175			* @param WorkflowDispatchEventInterface $e
176			*
177			* @return MetadataInterface\|null
178			*/
179			public function onLoadMetadataHandler(WorkflowDispatchEventInterface $e)
180			{
181			$mvcEvent = $e->getMvcEvent();
182			$controller = $mvcEvent->getTarget();
183			if (!$controller instanceof AbstractController) {
184			return null;
185			}
186
187			$routeMatch = $mvcEvent->getRouteMatch();
188			if (!$routeMatch) {
189			return null;
190			}
191
192			$action = $routeMatch->getParam('action', 'not-found');
193			$actionMethod = AbstractController::getMethodFromAction($action);
194
195			if (!method_exists($controller, $actionMethod)) {
196			return null;
197			}
198
199			$controllerClassName = get_class($controller);
200			$metadata = $this->getMetadataReader()->loadMetadataForAction($controllerClassName, $actionMethod);
201
202			return $metadata;
203			}
204
205			/**
206			* @param WorkflowDispatchEventInterface $e
207			*
208			* @return mixed\|null
209			*
210			* @throws Exception\PrepareDataException
211			*/
212			public function onPrepareDataHandler(WorkflowDispatchEventInterface $e)
213			{
214			$metadata = $e->getMetadata();
215
216			$type = $metadata->getPrepareDataMethod();
217			$handler = $metadata->getPrepareDataHandler();
218
219			$prepareDataResult = null;
			0 ignored issues – show Unused Code introduced 2016-02-12 08:23 UTC by Report Bug Copy Issue Report `$prepareDataResult` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
220
221			if ('method' === $type) {
222			$mvcEvent = $e->getMvcEvent();
223			$controller = $mvcEvent->getTarget();
224			if (!$controller instanceof AbstractController) {
225			$errMsg = sprintf('Controller not implement %s', AbstractController::class);
226			throw new Exception\PrepareDataException($errMsg);
227			}
228			$callback = [$controller, $handler];
229			if (!is_callable($callback)) {
230			$errMsg = sprintf('Invalid handler"%s"', $handler);
231			throw new Exception\PrepareDataException($errMsg);
232			}
233			$prepareDataResult = call_user_func($callback, $e);
234			if (null === $prepareDataResult) {
235			$prepareDataResult = [];
236			}
237			} else {
238			$errMsg = sprintf('Preparing data for Workflow will fail. Unknown handler type %s.', $type);
239			throw new Exception\PrepareDataException($errMsg);
240			}
241
242			if (!is_array($prepareDataResult) && !$prepareDataResult instanceof Traversable) {
243			$errMsg = 'Data preparation The results should be an array or Traversable';
244			throw new Exception\PrepareDataException($errMsg);
245			}
246
247
248			return $prepareDataResult;
249			}
250
251			/**
252			* Проверка, на то нужно ли запускать workflow
253			*
254			* @param WorkflowDispatchEventInterface $e
255			*
256			* @return boolean\|null
257			*
258			* @throws \Zend\Validator\Exception\InvalidArgumentException
259			* @throws Exception\PrepareDataException
260			*/
261			public function onCheckRunWorkflowHandler(WorkflowDispatchEventInterface $e)
262			{
263			$metadata = $e->getMetadata();
			0 ignored issues – show Bug introduced 2016-02-12 08:46 UTC by Report Bug Copy Issue Report The method `getMetadata` does only exist in `OldTown\Workflow\ZF2\Dis...wDispatchEventInterface`, but not in `Exception`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
264			if (!$metadata->getFlagHasConditions()) {
265			return null;
266			}
267
268			try {
269			$conditions = $metadata->getConditions();
270
271			$validatorManager = $this->getValidatorManager();
272
273			/** @var ValidatorChain $validatorChains */
274			$validatorChains = $validatorManager->get(ValidatorChain::class);
275			} catch (\Exception $e) {
276			throw new Exception\PrepareDataException($e->getMessage(), $e->getCode(), $e);
277			}
278
279
280
281			$mvcEvent = $e->getMvcEvent();
			0 ignored issues – show Bug introduced 2016-02-12 08:46 UTC by Report Bug Copy Issue Report The method `getMvcEvent` does only exist in `OldTown\Workflow\ZF2\Dis...wDispatchEventInterface`, but not in `Exception`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
282			$controller = $mvcEvent->getTarget();
283			if (!$controller instanceof AbstractController) {
284			$controller = null;
285			}
286
287
288			foreach ($conditions as $condition) {
289			try {
290			$type = $condition->getType();
291			$handler = $condition->getHandler();
292			switch ($type) {
293			case 'method': {
294			if (null === $controller) {
295			$errMsg = 'Controller not specified';
296			throw new Exception\CheckRunWorkflowEventException($errMsg);
297			}
298			$callback = [$controller, $handler];
299
300			/** @var ValidatorInterface $callbackValidator */
301			$callbackValidator = $validatorManager->get('callback', $callback);
302
303			$validatorChains->attach($callbackValidator);
304
305			break;
306			}
307			case 'service': {
308			$validatorParams = $condition->getParams();
309			/** @var ValidatorInterface $validator */
310			$validator = $validatorManager->get($handler, $validatorParams);
311
312			$validatorChains->attach($validator);
313
314			break;
315			}
316			default: {
317			$errMsg = sprintf('Preparing data for Workflow will fail. Unknown handler type %s.', $type);
318			throw new Exception\PrepareDataException($errMsg);
319			}
320			}
321			} catch (\Exception $e) {
322			throw new Exception\PrepareDataException($e->getMessage(), $e->getCode(), $e);
323			}
324			}
325
326			return $validatorChains->isValid($e);
327			}
328
329			/**
330			* Запуск workflow
331			*
332			* @param WorkflowDispatchEventInterface $e
333			*
334			* @return TransitionResultInterface
335			*
336			*
337			* @throws Exception\InvalidArgumentException
338			* @throws Exception\WorkflowDispatchEventException
339			* @throws \OldTown\Workflow\ZF2\ServiceEngine\Exception\InvalidInitializeWorkflowEntryException
340			* @throws \OldTown\Workflow\ZF2\ServiceEngine\Exception\DoActionException
341			*/
342			public function onRunWorkflowHandler(WorkflowDispatchEventInterface $e)
343			{
344			$runWorkflowParam = $e->getRunWorkflowParam();
345			$runWorkflowParam->valid();
346
347			$transientVars = $this->factoryTransientVars();
348
349			$prepareData = $e->getPrepareData();
350			foreach ($prepareData as $key => $value) {
351			$transientVars[$key] = $value;
352			}
353
354			$runWorkflowParam = $e->getRunWorkflowParam();
355			$runWorkflowParam->valid();
356
357			$workflowManagerName = $runWorkflowParam->getManagerName();
358			$workflowActionName = $runWorkflowParam->getActionName();
359
360			$workflowActivity = $runWorkflowParam->getRunType();
361			$result = null;
			0 ignored issues – show Unused Code introduced 2016-02-12 08:23 UTC by Report Bug Copy Issue Report `$result` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
362			switch ($runWorkflowParam->getRunType()) {
363			case RunWorkflowParamInterface::WORKFLOW_RUN_INITIALIZE: {
364			$workflowName = $runWorkflowParam->getWorkflowName();
365			$result = $this->getWorkflowService()->initialize($workflowManagerName, $workflowName, $workflowActionName, $transientVars);
366			break;
367			}
368			case RunWorkflowParamInterface::WORKFLOW_RUN_TYPE_DO_ACTION: {
369			$entryId = $runWorkflowParam->getEntryId();
370
371			$result = $this->getWorkflowService()->doAction($workflowManagerName, $entryId, $workflowActionName, $transientVars);
372			break;
373			}
374			default: {
375			$errMsg = sprintf('Invalid activity %s', $workflowActivity);
376			throw new Exception\InvalidArgumentException($errMsg);
377			}
378			}
379
380			return $result;
381			}
382
383			/**
384			*
385			* @return TransientVarsInterface
386			*
387			* @throws Exception\WorkflowDispatchEventException
388			*/
389			public function factoryTransientVars()
390			{
391			$className = $this->getTransientVarsClassName();
392
393			return $this->factoryClassName($className, TransientVarsInterface::class);
394			}
395
396			/**
397			* Фабрика для создания событий
398			*
399			* @return WorkflowDispatchEventInterface
400			*
401			* @throws Exception\WorkflowDispatchEventException
402			*/
403			public function workflowDispatchEventFactory()
404			{
405			$className = $this->getWorkflowDispatchEventClassName();
406
407			return $this->factoryClassName($className, WorkflowDispatchEventInterface::class);
408			}
409
410			/**
411			* Создает экземпляр класса и проверяет то что созданный объект имплементирует заданный интерфейс
412			*
413			* @param $className
414			* @param $interface
415			*
416			* @return mixed
417			*
418			* @throws Exception\WorkflowDispatchEventException
419			*/
420			protected function factoryClassName($className, $interface)
421			{
422			$r = new ReflectionClass($className);
423
424			$instance = $r->newInstance();
425
426			if (!$instance instanceof $interface) {
427			$errMsg = sprintf('Class %s not implement %s', $className, $interface);
428			throw new Exception\WorkflowDispatchEventException($errMsg);
429			}
430
431			return $instance;
432			}
433
434			/**
435			* @return WorkflowService
436			*/
437			public function getWorkflowService()
438			{
439			return $this->workflowService;
440			}
441
442			/**
443			* @param WorkflowService $workflowService
444			*
445			* @return $this
446			*/
447			public function setWorkflowService(WorkflowService $workflowService)
448			{
449			$this->workflowService = $workflowService;
450
451			return $this;
452			}
453
454			/**
455			* @return ReaderInterface
456			*/
457			public function getMetadataReader()
458			{
459			return $this->metadataReader;
460			}
461
462			/**
463			* @param ReaderInterface $metadataReader
464			*
465			* @return $this
466			*/
467			public function setMetadataReader(ReaderInterface $metadataReader)
468			{
469			$this->metadataReader = $metadataReader;
470
471			return $this;
472			}
473
474			/**
475			* @return ValidatorPluginManager
476			*/
477			public function getValidatorManager()
478			{
479			return $this->validatorManager;
480			}
481
482			/**
483			* @param ValidatorPluginManager $validatorManager
484			*
485			* @return $this
486			*/
487			public function setValidatorManager(ValidatorPluginManager $validatorManager)
488			{
489			$this->validatorManager = $validatorManager;
490
491			return $this;
492			}
493
494			/**
495			* @return string
496			*/
497			public function getWorkflowDispatchEventClassName()
498			{
499			return $this->workflowDispatchEventClassName;
500			}
501
502			/**
503			* @param string $workflowDispatchEventClassName
504			*
505			* @return $this
506			*/
507			public function setWorkflowDispatchEventClassName($workflowDispatchEventClassName)
508			{
509			$this->workflowDispatchEventClassName = (string)$workflowDispatchEventClassName;
510
511			return $this;
512			}
513
514			/**
515			* @return string
516			*/
517			public function getTransientVarsClassName()
518			{
519			return $this->transientVarsClassName;
520			}
521
522			/**
523			* @param string $transientVarsClassName
524			*
525			* @return $this
526			*/
527			public function setTransientVarsClassName($transientVarsClassName)
528			{
529			$this->transientVarsClassName = (string)$transientVarsClassName;
530
531			return $this;
532			}
533			}
534

old-town / workflow-zf2-dispatch

GitHub Access Token became invalid

Push — dev ( 40bda2...5b7120 )

Dispatcher F

Complexity

Size/Duplication

Coupling/Cohesion

Importance

21 Methods

How to fix Complexity

Complex Class

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like