WorkflowManager::hasWorkflowChanged() - Code Metrics - netzmacht/workflow - Measure and Improve Code Quality continuously with Scrutinizer

WorkflowManager::hasWorkflowChanged() A
last analyzed 2018-07-24 09:08 UTC

↳ Parent: WorkflowManager

Complexity

Conditions	4
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	19
rs	9.6333
c	0
b	0
f	0
cc	4
nc	3
nop	3

<?php

/**
 * Workflow library.
 *
 * @package    workflow
 * @author     David Molineus <[email protected]>
 * @copyright  2014-2017 netzmacht David Molineus
 * @license    LGPL 3.0 https://github.com/netzmacht/workflow
 * @filesource
 */

declare(strict_types=1);

namespace Netzmacht\Workflow\Manager;

use Assert\Assertion;
use Netzmacht\Workflow\Data\EntityId;
use Netzmacht\Workflow\Data\StateRepository;
use Netzmacht\Workflow\Exception\WorkflowNotFound;
use Netzmacht\Workflow\Flow\Exception\FlowException;
use Netzmacht\Workflow\Flow\Item;
use Netzmacht\Workflow\Flow\Workflow;
use Netzmacht\Workflow\Handler\TransitionHandler;
use Netzmacht\Workflow\Handler\TransitionHandlerFactory;

/**
 * Class Manager handles a set of workflows.
 *
 * Usually there will a different workflow manager for different workflow types. The manager is the API entry point
 * when using the workflow API.
 *
 * @package Netzmacht\Workflow
 */
class WorkflowManager implements Manager
{
    /**
     * The state repository.
     *
     * @var StateRepository
     */
    private $stateRepository;

    /**
     * A set of workflows.
     *
     * @var Workflow[]
     */
    private $workflows;

    /**
     * A Transition handler factory.
     *
     * @var TransitionHandlerFactory
     */
    private $handlerFactory;

    /**
     * Construct.
     *
     * @param TransitionHandlerFactory $handlerFactory  The transition handler factory.
     * @param StateRepository          $stateRepository The state repository.
     * @param Workflow[]               $workflows       The set of managed workflows.
     */
    public function __construct(
        TransitionHandlerFactory $handlerFactory,
        StateRepository $stateRepository,
        $workflows = []
    ) {
        Assertion::allIsInstanceOf($workflows, Workflow::class);

        $this->workflows       = $workflows;
        $this->handlerFactory  = $handlerFactory;
        $this->stateRepository = $stateRepository;
    }

    /**
     * {@inheritdoc}
     */
    public function handle(Item $item, string $transitionName = null, bool $changeWorkflow = false): ?TransitionHandler
    {
        $entity = $item->getEntity();

        if (!$this->hasWorkflow($item->getEntityId(), $entity)) {
            return null;
        }

        $workflow = $this->getWorkflow($item->getEntityId(), $entity);

        if ($this->hasWorkflowChanged($item, $workflow, !$changeWorkflow) && $changeWorkflow) {
            $item->detach();
        }

        $handler = $this->handlerFactory->createTransitionHandler(
            $item,
            $workflow,
            $transitionName,
            $item->getEntityId()->getProviderName(),
            $this->stateRepository
        );

        return $handler;
    }

    /**
     * {@inheritdoc}
     */
    public function addWorkflow(Workflow $workflow): Manager
    {
        $this->workflows[] = $workflow;

        return $this;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * {@inheritdoc}
     *
     * @throws WorkflowNotFound When no supporting workflow is found.
     */
    public function getWorkflow(EntityId $entityId, $entity): Workflow
    {
        foreach ($this->workflows as $workflow) {
            if ($workflow->supports($entityId, $entity)) {
                return $workflow;
            }
        }

        throw WorkflowNotFound::forEntity($entityId);
    }

    /**
     * {@inheritdoc}
     *
     * @throws WorkflowNotFound When no workflow with name is found.
     */
    public function getWorkflowByName(string $name): Workflow
    {
        foreach ($this->workflows as $workflow) {
            if ($workflow->getName() == $name) {
                return $workflow;
            }
        }

        throw WorkflowNotFound::withName($name);
    }

    /**
     * {@inheritdoc}
     */
    public function getWorkflowByItem(Item $item): Workflow
    {
        return $this->getWorkflow($item->getEntityId(), $item->getEntity());
    }

    /**
     * {@inheritdoc}
     */
    public function hasWorkflow(EntityId $entityId, $entity): bool
    {
        foreach ($this->workflows as $workflow) {
            if ($workflow->supports($entityId, $entity)) {
                return true;
            }
        }

        return false;
    }

    /**
     * {@inheritdoc}
     */
    public function getWorkflows(): iterable
    {
        return $this->workflows;
    }

    /**
     * {@inheritdoc}
     */
    public function createItem(EntityId $entityId, $entity): Item
    {
        $stateHistory = $this->stateRepository->find($entityId);

        return Item::reconstitute($entityId, $entity, $stateHistory);
    }

    /**
     * Guard that already started workflow is the same which is tried to be ran now.
     *
     * @param Item     $item     Current workflow item.
     * @param Workflow $workflow Selected workflow.
     * @param bool     $throw    If true an error is thrown.
     *
     * @throws FlowException If item workflow is not the same as current workflow.
     *
     * @return bool
     */
    private function hasWorkflowChanged(Item $item, Workflow $workflow, bool $throw = true): bool
    {
        if ($item->isWorkflowStarted() && $item->getWorkflowName() != $workflow->getName()) {
            $message = sprintf(
                'Item "%s" already process workflow "%s" and cannot be handled by "%s"',
                $item->getEntityId(),
                $item->getWorkflowName(),
                $workflow->getName()
            );

            if ($throw) {
                throw new FlowException($message);
            }

            return true;
        }

        return false;
    }
}


1			<?php
2
3			/**
4			* Workflow library.
5			*
6			* @package workflow
7			* @author David Molineus <[email protected]>
8			* @copyright 2014-2017 netzmacht David Molineus
9			* @license LGPL 3.0 https://github.com/netzmacht/workflow
10			* @filesource
11			*/
12
13			declare(strict_types=1);
14
15			namespace Netzmacht\Workflow\Manager;
16
17			use Assert\Assertion;
18			use Netzmacht\Workflow\Data\EntityId;
19			use Netzmacht\Workflow\Data\StateRepository;
20			use Netzmacht\Workflow\Exception\WorkflowNotFound;
21			use Netzmacht\Workflow\Flow\Exception\FlowException;
22			use Netzmacht\Workflow\Flow\Item;
23			use Netzmacht\Workflow\Flow\Workflow;
24			use Netzmacht\Workflow\Handler\TransitionHandler;
25			use Netzmacht\Workflow\Handler\TransitionHandlerFactory;
26
27			/**
28			* Class Manager handles a set of workflows.
29			*
30			* Usually there will a different workflow manager for different workflow types. The manager is the API entry point
31			* when using the workflow API.
32			*
33			* @package Netzmacht\Workflow
34			*/
35			class WorkflowManager implements Manager
36			{
37			/**
38			* The state repository.
39			*
40			* @var StateRepository
41			*/
42			private $stateRepository;
43
44			/**
45			* A set of workflows.
46			*
47			* @var Workflow[]
48			*/
49			private $workflows;
50
51			/**
52			* A Transition handler factory.
53			*
54			* @var TransitionHandlerFactory
55			*/
56			private $handlerFactory;
57
58			/**
59			* Construct.
60			*
61			* @param TransitionHandlerFactory $handlerFactory The transition handler factory.
62			* @param StateRepository $stateRepository The state repository.
63			* @param Workflow[] $workflows The set of managed workflows.
64			*/
65			public function __construct(
66			TransitionHandlerFactory $handlerFactory,
67			StateRepository $stateRepository,
68			$workflows = []
69			) {
70			Assertion::allIsInstanceOf($workflows, Workflow::class);
71
72			$this->workflows = $workflows;
73			$this->handlerFactory = $handlerFactory;
74			$this->stateRepository = $stateRepository;
75			}
76
77			/**
78			* {@inheritdoc}
79			*/
80			public function handle(Item $item, string $transitionName = null, bool $changeWorkflow = false): ?TransitionHandler
81			{
82			$entity = $item->getEntity();
83
84			if (!$this->hasWorkflow($item->getEntityId(), $entity)) {
85			return null;
86			}
87
88			$workflow = $this->getWorkflow($item->getEntityId(), $entity);
89
90			if ($this->hasWorkflowChanged($item, $workflow, !$changeWorkflow) && $changeWorkflow) {
91			$item->detach();
92			}
93
94			$handler = $this->handlerFactory->createTransitionHandler(
95			$item,
96			$workflow,
97			$transitionName,
98			$item->getEntityId()->getProviderName(),
99			$this->stateRepository
100			);
101
102			return $handler;
103			}
104
105			/**
106			* {@inheritdoc}
107			*/
108			public function addWorkflow(Workflow $workflow): Manager
109			{
110			$this->workflows[] = $workflow;
111
112			return $this;
			0 ignored issues – show Bug Best Practice introduced 2017-11-01 13:50 UTC by Report Bug Copy Issue Report The return type of `return $this;` (`Netzmacht\Workflow\Manager\WorkflowManager`) is incompatible with the return type declared by the interface `Netzmacht\Workflow\Manager\Manager::addWorkflow` of type `self`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
113			}
114
115			/**
116			* {@inheritdoc}
117			*
118			* @throws WorkflowNotFound When no supporting workflow is found.
119			*/
120			public function getWorkflow(EntityId $entityId, $entity): Workflow
121			{
122			foreach ($this->workflows as $workflow) {
123			if ($workflow->supports($entityId, $entity)) {
124			return $workflow;
125			}
126			}
127
128			throw WorkflowNotFound::forEntity($entityId);
129			}
130
131			/**
132			* {@inheritdoc}
133			*
134			* @throws WorkflowNotFound When no workflow with name is found.
135			*/
136			public function getWorkflowByName(string $name): Workflow
137			{
138			foreach ($this->workflows as $workflow) {
139			if ($workflow->getName() == $name) {
140			return $workflow;
141			}
142			}
143
144			throw WorkflowNotFound::withName($name);
145			}
146
147			/**
148			* {@inheritdoc}
149			*/
150			public function getWorkflowByItem(Item $item): Workflow
151			{
152			return $this->getWorkflow($item->getEntityId(), $item->getEntity());
153			}
154
155			/**
156			* {@inheritdoc}
157			*/
158			public function hasWorkflow(EntityId $entityId, $entity): bool
159			{
160			foreach ($this->workflows as $workflow) {
161			if ($workflow->supports($entityId, $entity)) {
162			return true;
163			}
164			}
165
166			return false;
167			}
168
169			/**
170			* {@inheritdoc}
171			*/
172			public function getWorkflows(): iterable
173			{
174			return $this->workflows;
175			}
176
177			/**
178			* {@inheritdoc}
179			*/
180			public function createItem(EntityId $entityId, $entity): Item
181			{
182			$stateHistory = $this->stateRepository->find($entityId);
183
184			return Item::reconstitute($entityId, $entity, $stateHistory);
185			}
186
187			/**
188			* Guard that already started workflow is the same which is tried to be ran now.
189			*
190			* @param Item $item Current workflow item.
191			* @param Workflow $workflow Selected workflow.
192			* @param bool $throw If true an error is thrown.
193			*
194			* @throws FlowException If item workflow is not the same as current workflow.
195			*
196			* @return bool
197			*/
198			private function hasWorkflowChanged(Item $item, Workflow $workflow, bool $throw = true): bool
199			{
200			if ($item->isWorkflowStarted() && $item->getWorkflowName() != $workflow->getName()) {
201			$message = sprintf(
202			'Item "%s" already process workflow "%s" and cannot be handled by "%s"',
203			$item->getEntityId(),
204			$item->getWorkflowName(),
205			$workflow->getName()
206			);
207
208			if ($throw) {
209			throw new FlowException($message);
210			}
211
212			return true;
213			}
214
215			return false;
216			}
217			}
218

netzmacht / workflow

GitHub Access Token became invalid

WorkflowManager::hasWorkflowChanged() A last analyzed 2018-07-24 09:08 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

WorkflowManager::hasWorkflowChanged() A
last analyzed 2018-07-24 09:08 UTC