Dispatcher::onCheckRunWorkflowHandler() - Code Metrics - Inspection of "sm-108 Реализация workflow-zf2-dispatch. Поддержка..." - old-town/workflow-zf2-dispatch - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — dev ( d5e133...46b2b0 )

by Андрей

created 2016-02-12 08:43 UTC

Dispatcher::onCheckRunWorkflowHandler() C

↳ Parent: Dispatcher

Complexity

Conditions	9
Paths	30

Size

Total Lines	67
Code Lines	38

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
c	2
b	0
f	0
dl	0
loc	67
rs	6.3448
cc	9
eloc	38
nc	30
nop	1

How to fix Long Method

<?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\Reader\ReaderInterface;
use ReflectionClass;
use OldTown\Workflow\ZF2\Dispatch\Metadata\Storage\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
     */
    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) {
            $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
     */
    public function onRunWorkflowHandler(WorkflowDispatchEventInterface $e)
    {
        $mvcEvent = $e->getMvcEvent();

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

        $metadata = $e->getMetadata();

        $workflowManagerNameParam = $metadata->getWorkflowManagerNameRouterParam();
        $workflowManagerName = $routeMatch->getParam($workflowManagerNameParam, null);
        if (null === $workflowManagerName) {
            $errMsg = sprintf('Param "%s" not found', $workflowManagerNameParam);
            throw new Exception\InvalidArgumentException($errMsg);
        }

        $workflowActionNameParam = $metadata->getWorkflowActionNameRouterParam();
        $workflowActionName = $routeMatch->getParam($workflowActionNameParam, null);
        if (null === $workflowActionName) {
            $errMsg = sprintf('Param "%s" not found', $workflowActionNameParam);
            throw new Exception\InvalidArgumentException($errMsg);
        }


        $workflowActivity = $metadata->getWorkflowRunType();
        $transientVars = $this->factoryTransientVars();

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

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

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        switch ($workflowActivity) {
            case 'initialize': {

                $workflowNameParam = $metadata->getWorkflowNameRouterParam();
                $workflowName = $routeMatch->getParam($workflowNameParam, null);
                if (null === $workflowName) {
                    $errMsg = sprintf('Param "%s" not found', $workflowNameParam);
                    throw new Exception\InvalidArgumentException($errMsg);
                }

                $result = $this->getWorkflowService()->initialize($workflowManagerName, $workflowName, $workflowActionName, $transientVars);
                break;
            }
            case 'doAction': {

                $entryIdParam = $metadata->getEntryIdRouterParam();
                $entryId = $routeMatch->getParam($entryIdParam, null);
                if (null === $entryId) {
                    $errMsg = sprintf('Param "%s" not found', $entryIdParam);
                    throw new Exception\InvalidArgumentException($errMsg);
                }

                $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 ( d5e133...46b2b0 )

Dispatcher::onCheckRunWorkflowHandler() C

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

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\Reader\ReaderInterface;
12		use ReflectionClass;
13		use OldTown\Workflow\ZF2\Dispatch\Metadata\Storage\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		* Class Dispatcher
25		*
26		* @package OldTown\Workflow\ZF2\Dispatch\Dispatcher
27		*/
28		class Dispatcher implements DispatcherInterface
29		{
30		use EventManagerAwareTrait;
31
32		/**
33		* @var string
34		*/
35		const WORKFLOW_DISPATCH_EVENT = 'workflowDispatchEvent';
36
37		/**
38		* Имя класса события
39		*
40		* @var string
41		*/
42		protected $workflowDispatchEventClassName = WorkflowDispatchEvent::class;
43
44		/**
45		* Имя класса события
46		*
47		* @var string
48		*/
49		protected $transientVarsClassName = BaseTransientVars::class;
50
51		/**
52		* @var WorkflowService
53		*/
54		protected $workflowService;
55
56		/**
57		* @var ReaderInterface
58		*/
59		protected $metadataReader;
60
61		/**
62		* @var ValidatorPluginManager
63		*/
64		protected $validatorManager;
65
66		/**
67		* @param array $options
68		*/
69		public function __construct(array $options = [])
70		{
71		call_user_func_array([$this, 'init'], $options);
72		}
73
74		/**
75		* @param WorkflowService $workflowService
76		* @param ReaderInterface $metadataReader
77		* @param ValidatorPluginManager $validatorManager
78		*/
79		protected function init(WorkflowService $workflowService, ReaderInterface $metadataReader, ValidatorPluginManager $validatorManager)
80		{
81		$this->setWorkflowService($workflowService);
82		$this->setMetadataReader($metadataReader);
83		$this->setValidatorManager($validatorManager);
84		}
85
86		/**
87		* Диспетчирезация работы с workflow
88		*
89		* @param WorkflowDispatchEventInterface $event
90		*
91		* @return void
92		*/
93		public function dispatch(WorkflowDispatchEventInterface $event)
94		{
95		$event->getMvcEvent()->setParam(static::WORKFLOW_DISPATCH_EVENT, $event);
96		$event->setTarget($this);
97
98		$metadataResult = $this->getEventManager()->trigger(WorkflowDispatchEventInterface::LOAD_METADATA_EVENT, $event, function ($test) {
99		return ($test instanceof MetadataInterface);
100		});
101		$metadata = $metadataResult->last();
102
103		if (!$metadata instanceof MetadataInterface) {
104		return;
105		}
106
107		$event->setMetadata($metadata);
108
109		$prepareData = [];
110		if ($metadata->isFlagRunPrepareData()) {
111		$prepareDataResults = $this->getEventManager()->trigger(WorkflowDispatchEventInterface::PREPARE_DATA_EVENT, $event);
112		foreach ($prepareDataResults as $prepareDataResult) {
113		if (is_array($prepareDataResult) \|\| $prepareDataResult instanceof Traversable) {
114		$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 `112` 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...
115		}
116		}
117		}
118		$event->setPrepareData($prepareData);
119
120
121		$flagRunWorkflow = $metadata->isWorkflowDispatch();
122		if (true === $flagRunWorkflow) {
123		$dispatchConditionsResults = $this->getEventManager()->trigger(WorkflowDispatchEventInterface::CHECK_RUN_WORKFLOW_EVENT, $event);
124		foreach ($dispatchConditionsResults as $dispatchConditionsResult) {
125		if (false === $dispatchConditionsResult) {
126		$flagRunWorkflow = false;
127		break;
128		}
129		}
130		}
131
132		if (true === $flagRunWorkflow) {
133		$runWorkflowResults = $this->getEventManager()->trigger(WorkflowDispatchEventInterface::RUN_WORKFLOW_EVENT, $event, function ($result) {
134		return ($result instanceof TransitionResultInterface);
135		});
136
137		$workflowResult = $runWorkflowResults->last();
138		if ($workflowResult instanceof TransitionResultInterface) {
139		$event->setWorkflowResult($workflowResult);
140		}
141		}
142		}
143
144		/**
145		* Добавление подписчиков по умолчанию
146		*
147		*/
148		public function attachDefaultListeners()
149		{
150		$em = $this->getEventManager();
151		$em->attach(WorkflowDispatchEventInterface::LOAD_METADATA_EVENT, [$this, 'onLoadMetadataHandler']);
152		$em->attach(WorkflowDispatchEventInterface::PREPARE_DATA_EVENT, [$this, 'onPrepareDataHandler']);
153		$em->attach(WorkflowDispatchEventInterface::CHECK_RUN_WORKFLOW_EVENT, [$this, 'onCheckRunWorkflowHandler']);
154		$em->attach(WorkflowDispatchEventInterface::RUN_WORKFLOW_EVENT, [$this, 'onRunWorkflowHandler']);
155		}
156
157		/**
158		* Получение метаданных
159		*
160		* @param WorkflowDispatchEventInterface $e
161		*
162		* @return MetadataInterface\|null
163		*/
164		public function onLoadMetadataHandler(WorkflowDispatchEventInterface $e)
165		{
166		$mvcEvent = $e->getMvcEvent();
167		$controller = $mvcEvent->getTarget();
168		if (!$controller instanceof AbstractController) {
169		return null;
170		}
171
172		$routeMatch = $mvcEvent->getRouteMatch();
173		if (!$routeMatch) {
174		return null;
175		}
176
177		$action = $routeMatch->getParam('action', 'not-found');
178		$actionMethod = AbstractController::getMethodFromAction($action);
179
180		if (!method_exists($controller, $actionMethod)) {
181		return null;
182		}
183
184		$controllerClassName = get_class($controller);
185		$metadata = $this->getMetadataReader()->loadMetadataForAction($controllerClassName, $actionMethod);
186
187		return $metadata;
188		}
189
190		/**
191		* @param WorkflowDispatchEventInterface $e
192		*
193		* @return mixed\|null
194		*
195		* @throws Exception\PrepareDataException
196		*/
197		public function onPrepareDataHandler(WorkflowDispatchEventInterface $e)
198		{
199		$metadata = $e->getMetadata();
200
201		$type = $metadata->getPrepareDataMethod();
202		$handler = $metadata->getPrepareDataHandler();
203
204		$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...
205
206		if ('method' === $type) {
207		$mvcEvent = $e->getMvcEvent();
208		$controller = $mvcEvent->getTarget();
209		if (!$controller instanceof AbstractController) {
210		$errMsg = sprintf('Controller not implement %s', AbstractController::class);
211		throw new Exception\PrepareDataException($errMsg);
212		}
213		$callback = [$controller, $handler];
214		if (!is_callable($callback)) {
215		$errMsg = sprintf('Invalid handler"%s"', $handler);
216		throw new Exception\PrepareDataException($errMsg);
217		}
218		$prepareDataResult = call_user_func($callback, $e);
219		if (null === $prepareDataResult) {
220		$prepareDataResult = [];
221		}
222		} else {
223		$errMsg = sprintf('Preparing data for Workflow will fail. Unknown handler type %s.', $type);
224		throw new Exception\PrepareDataException($errMsg);
225		}
226
227		if (!is_array($prepareDataResult) && !$prepareDataResult instanceof Traversable) {
228		$errMsg = 'Data preparation The results should be an array or Traversable';
229		throw new Exception\PrepareDataException($errMsg);
230		}
231
232
233		return $prepareDataResult;
234		}
235
236		/**
237		* Проверка, на то нужно ли запускать workflow
238		*
239		* @param WorkflowDispatchEventInterface $e
240		*
241		* @return boolean\|null
242		*
243		* @throws \Zend\Validator\Exception\InvalidArgumentException
244		* @throws Exception\PrepareDataException
245		*/
246		public function onCheckRunWorkflowHandler(WorkflowDispatchEventInterface $e)
247		{
248		$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...
249		if (!$metadata->getFlagHasConditions()) {
250		return null;
251		}
252
253		try {
254		$conditions = $metadata->getConditions();
255
256		$validatorManager = $this->getValidatorManager();
257
258		/** @var ValidatorChain $validatorChains */
259		$validatorChains = $validatorManager->get(ValidatorChain::class);
260		} catch (\Exception $e) {
261		throw new Exception\PrepareDataException($e->getMessage(), $e->getCode(), $e);
262		}
263
264
265
266		$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...
267		$controller = $mvcEvent->getTarget();
268		if (!$controller instanceof AbstractController) {
269		$controller = null;
270		}
271
272
273		foreach ($conditions as $condition) {
274		try {
275		$type = $condition->getType();
276		$handler = $condition->getHandler();
277		switch ($type) {
278		case 'method': {
279		if (null === $controller) {
280		$errMsg = 'Controller not specified';
281		throw new Exception\CheckRunWorkflowEventException($errMsg);
282		}
283		$callback = [$controller, $handler];
284
285		/** @var ValidatorInterface $callbackValidator */
286		$callbackValidator = $validatorManager->get('callback', $callback);
287
288		$validatorChains->attach($callbackValidator);
289
290		break;
291		}
292		case 'service': {
293		$validatorParams = $condition->getParams();
294		/** @var ValidatorInterface $validator */
295		$validator = $validatorManager->get($handler, $validatorParams);
296
297		$validatorChains->attach($validator);
298
299		break;
300		}
301		default: {
302		$errMsg = sprintf('Preparing data for Workflow will fail. Unknown handler type %s.', $type);
303		throw new Exception\PrepareDataException($errMsg);
304		}
305		}
306		} catch (\Exception $e) {
307		throw new Exception\PrepareDataException($e->getMessage(), $e->getCode(), $e);
308		}
309		}
310
311		return $validatorChains->isValid($e);
312		}
313
314		/**
315		* Запуск workflow
316		*
317		* @param WorkflowDispatchEventInterface $e
318		*
319		* @return TransitionResultInterface
320		*
321		*
322		* @throws Exception\InvalidArgumentException
323		* @throws Exception\WorkflowDispatchEventException
324		*/
325		public function onRunWorkflowHandler(WorkflowDispatchEventInterface $e)
326		{
327		$mvcEvent = $e->getMvcEvent();
328
329		$routeMatch = $mvcEvent->getRouteMatch();
330		if (!$routeMatch) {
331		return null;
332		}
333
334		$metadata = $e->getMetadata();
335
336		$workflowManagerNameParam = $metadata->getWorkflowManagerNameRouterParam();
337		$workflowManagerName = $routeMatch->getParam($workflowManagerNameParam, null);
338		if (null === $workflowManagerName) {
339		$errMsg = sprintf('Param "%s" not found', $workflowManagerNameParam);
340		throw new Exception\InvalidArgumentException($errMsg);
341		}
342
343		$workflowActionNameParam = $metadata->getWorkflowActionNameRouterParam();
344		$workflowActionName = $routeMatch->getParam($workflowActionNameParam, null);
345		if (null === $workflowActionName) {
346		$errMsg = sprintf('Param "%s" not found', $workflowActionNameParam);
347		throw new Exception\InvalidArgumentException($errMsg);
348		}
349
350
351		$workflowActivity = $metadata->getWorkflowRunType();
352		$transientVars = $this->factoryTransientVars();
353
354		$prepareData = $e->getPrepareData();
355		foreach ($prepareData as $key => $value) {
356		$transientVars[$key] = $value;
357		}
358
359		$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...
360		switch ($workflowActivity) {
361	View Code Duplication	case 'initialize': {
		0 ignored issues – show Duplication introduced 2016-02-12 08:23 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
362		$workflowNameParam = $metadata->getWorkflowNameRouterParam();
363		$workflowName = $routeMatch->getParam($workflowNameParam, null);
364		if (null === $workflowName) {
365		$errMsg = sprintf('Param "%s" not found', $workflowNameParam);
366		throw new Exception\InvalidArgumentException($errMsg);
367		}
368
369		$result = $this->getWorkflowService()->initialize($workflowManagerName, $workflowName, $workflowActionName, $transientVars);
370		break;
371		}
372	View Code Duplication	case 'doAction': {
		0 ignored issues – show Duplication introduced 2016-02-12 08:23 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
373		$entryIdParam = $metadata->getEntryIdRouterParam();
374		$entryId = $routeMatch->getParam($entryIdParam, null);
375		if (null === $entryId) {
376		$errMsg = sprintf('Param "%s" not found', $entryIdParam);
377		throw new Exception\InvalidArgumentException($errMsg);
378		}
379
380		$result = $this->getWorkflowService()->doAction($workflowManagerName, $entryId, $workflowActionName, $transientVars);
381		break;
382		}
383		default: {
384		$errMsg = sprintf('Invalid activity %s', $workflowActivity);
385		throw new Exception\InvalidArgumentException($errMsg);
386		}
387		}
388
389		return $result;
390		}
391
392		/**
393		*
394		* @return TransientVarsInterface
395		*
396		* @throws Exception\WorkflowDispatchEventException
397		*/
398		public function factoryTransientVars()
399		{
400		$className = $this->getTransientVarsClassName();
401
402		return $this->factoryClassName($className, TransientVarsInterface::class);
403		}
404
405		/**
406		* Фабрика для создания событий
407		*
408		* @return WorkflowDispatchEventInterface
409		*
410		* @throws Exception\WorkflowDispatchEventException
411		*/
412		public function workflowDispatchEventFactory()
413		{
414		$className = $this->getWorkflowDispatchEventClassName();
415
416		return $this->factoryClassName($className, WorkflowDispatchEventInterface::class);
417		}
418
419		/**
420		* Создает экземпляр класса и проверяет то что созданный объект имплементирует заданный интерфейс
421		*
422		* @param $className
423		* @param $interface
424		*
425		* @return mixed
426		*
427		* @throws Exception\WorkflowDispatchEventException
428		*/
429		protected function factoryClassName($className, $interface)
430		{
431		$r = new ReflectionClass($className);
432
433		$instance = $r->newInstance();
434
435		if (!$instance instanceof $interface) {
436		$errMsg = sprintf('Class %s not implement %s', $className, $interface);
437		throw new Exception\WorkflowDispatchEventException($errMsg);
438		}
439
440		return $instance;
441		}
442
443		/**
444		* @return WorkflowService
445		*/
446		public function getWorkflowService()
447		{
448		return $this->workflowService;
449		}
450
451		/**
452		* @param WorkflowService $workflowService
453		*
454		* @return $this
455		*/
456		public function setWorkflowService(WorkflowService $workflowService)
457		{
458		$this->workflowService = $workflowService;
459
460		return $this;
461		}
462
463		/**
464		* @return ReaderInterface
465		*/
466		public function getMetadataReader()
467		{
468		return $this->metadataReader;
469		}
470
471		/**
472		* @param ReaderInterface $metadataReader
473		*
474		* @return $this
475		*/
476		public function setMetadataReader(ReaderInterface $metadataReader)
477		{
478		$this->metadataReader = $metadataReader;
479
480		return $this;
481		}
482
483		/**
484		* @return ValidatorPluginManager
485		*/
486		public function getValidatorManager()
487		{
488		return $this->validatorManager;
489		}
490
491		/**
492		* @param ValidatorPluginManager $validatorManager
493		*
494		* @return $this
495		*/
496		public function setValidatorManager(ValidatorPluginManager $validatorManager)
497		{
498		$this->validatorManager = $validatorManager;
499
500		return $this;
501		}
502
503		/**
504		* @return string
505		*/
506		public function getWorkflowDispatchEventClassName()
507		{
508		return $this->workflowDispatchEventClassName;
509		}
510
511		/**
512		* @param string $workflowDispatchEventClassName
513		*
514		* @return $this
515		*/
516		public function setWorkflowDispatchEventClassName($workflowDispatchEventClassName)
517		{
518		$this->workflowDispatchEventClassName = (string)$workflowDispatchEventClassName;
519
520		return $this;
521		}
522
523		/**
524		* @return string
525		*/
526		public function getTransientVarsClassName()
527		{
528		return $this->transientVarsClassName;
529		}
530
531		/**
532		* @param string $transientVarsClassName
533		*
534		* @return $this
535		*/
536		public function setTransientVarsClassName($transientVarsClassName)
537		{
538		$this->transientVarsClassName = (string)$transientVarsClassName;
539
540		return $this;
541		}
542		}
543

old-town / workflow-zf2-dispatch

GitHub Access Token became invalid

Push — dev ( d5e133...46b2b0 )

Dispatcher::onCheckRunWorkflowHandler() C

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like