Order - Code Metrics - Inspection of "Merge pull request #5353 from pamil/fixtures/produ..." - pamil/Sylius - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (b23e60)

by Kamil

created 2016-06-27 08:10 UTC

Order F

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	524
Duplicated Lines	17.94 %

Coupling/Cohesion

Components	4
Dependencies	6

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
wmc	70
c	1
b	0
f	1
lcom	4
cbo	6
dl	94
loc	524
rs	2.7272

44 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	getId()	0	4	1
A	isCompleted()	0	4	1
A	complete()	0	4	1
A	getCompletedAt()	0	4	1
A	setCompletedAt()	0	4	1
A	getNumber()	0	4	1
A	setNumber()	0	4	1
A	getNotes()	0	4	1
A	setNotes()	0	4	1
A	getSequenceType()	0	4	1
A	getItems()	0	4	1
A	clearItems()	0	6	1
A	countItems()	0	4	1
A	addItem()	12	12	2
A	removeItem()	9	9	2
A	hasItem()	0	4	1
A	getItemsTotal()	0	4	1
A	recalculateItemsTotal()	0	9	2
A	getComments()	0	4	1
A	addComment()	0	7	2
A	removeComment()	0	7	2
A	getTotal()	0	4	1
A	setState()	0	4	1
A	getState()	0	4	1
A	getTotalQuantity()	0	10	2
A	isEmpty()	0	4	1
A	addIdentity()	0	8	2
A	hasIdentity()	0	4	1
A	getIdentities()	0	4	1
A	removeIdentity()	0	7	2
A	getAdjustments()	10	10	2
A	getAdjustmentsRecursively()	9	9	2
A	addAdjustment()	8	8	2
A	removeAdjustment()	8	8	3
A	hasAdjustment()	0	4	1
A	getAdjustmentsTotal()	15	15	4
A	getAdjustmentsTotalRecursively()	11	11	3
A	removeAdjustments()	0	10	3
A	removeAdjustmentsRecursively()	0	7	2
A	recalculateAdjustmentsTotal()	12	12	3
A	recalculateTotal()	0	8	2
A	addToAdjustmentsTotal()	0	7	2
A	subtractFromAdjustmentsTotal()	0	7	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Order often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Order, and based on these observations, apply Extract Interface, too.

<?php

/*
 * This file is part of the Sylius package.
 *
 * (c) Paweł Jędrzejewski
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Sylius\Component\Order\Model;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Sylius\Component\Resource\Model\TimestampableTrait;

/**
 * @author Paweł Jędrzejewski <[email protected]>
 */
class Order implements OrderInterface
{
    use TimestampableTrait;

    /**
     * @var mixed
     */
    protected $id;

    /**
     * @var \DateTime
     */
    protected $completedAt;

    /**
     * @var string
     */
    protected $number;

    /**
     * @var string
     */
    protected $notes;

    /**
     * @var Collection|OrderItemInterface[]
     */
    protected $items;

    /**
     * @var int
     */
    protected $itemsTotal = 0;

    /**
     * @var Collection|AdjustmentInterface[]
     */
    protected $adjustments;

    /**
     * @var Collection|CommentInterface[]
     */
    protected $comments;

    /**
     * @var Collection|IdentityInterface[]
     */
    protected $identities;

    /**
     * @var int
     */
    protected $adjustmentsTotal = 0;

    /**
     * Calculated total.
     * Items total + adjustments total.
     *
     * @var int
     */
    protected $total = 0;

    /**
     * @var string
     */
    protected $state = OrderInterface::STATE_CART;

    public function __construct()
    {
        $this->items = new ArrayCollection();
        $this->adjustments = new ArrayCollection();
        $this->comments = new ArrayCollection();
        $this->identities = new ArrayCollection();
        $this->createdAt = new \DateTime();
    }

    /**
     * {@inheritdoc}
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * {@inheritdoc}
     */
    public function isCompleted()
    {
        return null !== $this->completedAt;
    }

    /**
     * {@inheritdoc}
     */
    public function complete()
    {
        $this->completedAt = new \DateTime();
    }

    /**
     * {@inheritdoc}
     */
    public function getCompletedAt()
    {
        return $this->completedAt;
    }

    /**
     * {@inheritdoc}
     */
    public function setCompletedAt(\DateTime $completedAt = null)
    {
        $this->completedAt = $completedAt;
    }

    /**
     * {@inheritdoc}
     */
    public function getNumber()
    {
        return $this->number;
    }

    /**
     * {@inheritdoc}
     */
    public function setNumber($number)
    {
        $this->number = $number;
    }

    /**
     * {@inheritdoc}
     */
    public function getNotes()
    {
        return $this->notes;
    }

    /**
     * {@inheritdoc}
     */
    public function setNotes($notes)
    {
        $this->notes = $notes;
    }

    /**
     * {@inheritdoc}
     */
    public function getSequenceType()
    {
        return 'order';
    }

    /**
     * {@inheritdoc}
     */
    public function getItems()
    {
        return $this->items;
    }

    /**
     * {@inheritdoc}
     */
    public function clearItems()
    {
        $this->items->clear();

        $this->recalculateItemsTotal();
    }

    /**
     * {@inheritdoc}
     */
    public function countItems()
    {
        return $this->items->count();
    }

    /**
     * {@inheritdoc}
     */
    public function addItem(OrderItemInterface $item)

    {
        if ($this->hasItem($item)) {
            return;
        }

        $this->itemsTotal += $item->getTotal();
        $this->items->add($item);
        $item->setOrder($this);

        $this->recalculateTotal();
    }

    /**
     * {@inheritdoc}
     */
    public function removeItem(OrderItemInterface $item)

    {
        if ($this->hasItem($item)) {
            $this->items->removeElement($item);
            $this->itemsTotal -= $item->getTotal();
            $this->recalculateTotal();
            $item->setOrder(null);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function hasItem(OrderItemInterface $item)
    {
        return $this->items->contains($item);
    }

    /**
     * {@inheritdoc}
     */
    public function getItemsTotal()
    {
        return $this->itemsTotal;
    }

    /**
     * {@inheritdoc}
     */
    public function recalculateItemsTotal()
    {
        $this->itemsTotal = 0;
        foreach ($this->items as $item) {
            $this->itemsTotal += $item->getTotal();
        }

        $this->recalculateTotal();
    }

    /**
     * {@inheritdoc}
     */
    public function getComments()
    {
        return $this->comments;
    }

    /**
     * {@inheritdoc}
     */
    public function addComment(CommentInterface $comment)
    {
        if (!$this->comments->contains($comment)) {
            $comment->setOrder($this);
            $this->comments->add($comment);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function removeComment(CommentInterface $comment)
    {
        if ($this->comments->contains($comment)) {
            $comment->setOrder(null);
            $this->comments->removeElement($comment);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function getTotal()
    {
        return $this->total;
    }

    /**
     * {@inheritdoc}
     */
    public function setState($state)
    {
        $this->state = $state;
    }

    /**
     * {@inheritdoc}
     */
    public function getState()
    {
        return $this->state;
    }

    /**
     * {@inheritdoc}
     */
    public function getTotalQuantity()
    {
        $quantity = 0;

        foreach ($this->items as $item) {
            $quantity += $item->getQuantity();
        }

        return $quantity;
    }

    /**
     * {@inheritdoc}
     */
    public function isEmpty()
    {
        return $this->items->isEmpty();
    }

    /**
     * {@inheritdoc}
     */
    public function addIdentity(IdentityInterface $identity)
    {
        if (!$this->hasIdentity($identity)) {
            $this->identities->add($identity);

            $identity->setOrder($this);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function hasIdentity(IdentityInterface $identity)

    {
        return $this->identities->contains($identity);
    }

    /**
     * {@inheritdoc}
     */
    public function getIdentities()
    {
        return $this->identities;
    }

    /**
     * {@inheritdoc}
     */
    public function removeIdentity(IdentityInterface $identity)
    {
        if ($this->hasIdentity($identity)) {
            $identity->setOrder(null);
            $this->identities->removeElement($identity);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function getAdjustments($type = null)

    {
        if (null === $type) {
            return $this->adjustments;
        }

        return $this->adjustments->filter(function (AdjustmentInterface $adjustment) use ($type) {
            return $type === $adjustment->getType();
        });
    }

    /**
     * {@inheritdoc}
     */
    public function getAdjustmentsRecursively($type = null)

    {
        $adjustments = $this->getAdjustments($type)->toArray();
        foreach ($this->items as $item) {
            $adjustments = array_merge($adjustments, $item->getAdjustmentsRecursively($type));
        }

        return $adjustments;
    }

    /**
     * {@inheritdoc}
     */
    public function addAdjustment(AdjustmentInterface $adjustment)

    {
        if (!$this->hasAdjustment($adjustment)) {
            $this->adjustments->add($adjustment);
            $this->addToAdjustmentsTotal($adjustment);
            $adjustment->setAdjustable($this);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function removeAdjustment(AdjustmentInterface $adjustment)

    {
        if (!$adjustment->isLocked() && $this->hasAdjustment($adjustment)) {
            $this->adjustments->removeElement($adjustment);
            $this->subtractFromAdjustmentsTotal($adjustment);
            $adjustment->setAdjustable(null);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function hasAdjustment(AdjustmentInterface $adjustment)

    {
        return $this->adjustments->contains($adjustment);
    }

    /**
     * {@inheritdoc}
     */
    public function getAdjustmentsTotal($type = null)

    {
        if (null === $type) {
            return $this->adjustmentsTotal;
        }

        $total = 0;
        foreach ($this->getAdjustments($type) as $adjustment) {
            if (!$adjustment->isNeutral()) {
                $total += $adjustment->getAmount();
            }
        }

        return $total;
    }

    /**
     * {@inheritdoc}
     */
    public function getAdjustmentsTotalRecursively($type = null)

    {
        $total = 0;
        foreach ($this->getAdjustmentsRecursively($type) as $adjustment) {
            if (!$adjustment->isNeutral()) {
                $total += $adjustment->getAmount();
            }
        }

        return $total;
    }

    /**
     * {@inheritdoc}
     */
    public function removeAdjustments($type)
    {
        foreach ($this->getAdjustments($type) as $adjustment) {
            if ($adjustment->isLocked()) {
                continue;
            }

            $this->removeAdjustment($adjustment);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function removeAdjustmentsRecursively($type = null)
    {
        $this->removeAdjustments($type);
        foreach ($this->items as $item) {
            $item->removeAdjustmentsRecursively($type);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function recalculateAdjustmentsTotal()

    {
        $this->adjustmentsTotal = 0;

        foreach ($this->adjustments as $adjustment) {
            if (!$adjustment->isNeutral()) {
                $this->adjustmentsTotal += $adjustment->getAmount();
            }
        }

        $this->recalculateTotal();
    }

    /**
     * Calculate total.
     * Items total + Adjustments total.
     */
    protected function recalculateTotal()
    {
        $this->total = $this->itemsTotal + $this->adjustmentsTotal;

        if ($this->total < 0) {
            $this->total = 0;
        }
    }

    /**
     * @param AdjustmentInterface $adjustment
     */
    protected function addToAdjustmentsTotal(AdjustmentInterface $adjustment)
    {
        if (!$adjustment->isNeutral()) {
            $this->adjustmentsTotal += $adjustment->getAmount();
            $this->recalculateTotal();
        }
    }

    /**
     * @param AdjustmentInterface $adjustment
     */
    protected function subtractFromAdjustmentsTotal(AdjustmentInterface $adjustment)
    {
        if (!$adjustment->isNeutral()) {
            $this->adjustmentsTotal -= $adjustment->getAmount();
            $this->recalculateTotal();
        }
    }
}


1		<?php
2
3		/*
4		* This file is part of the Sylius package.
5		*
6		* (c) Paweł Jędrzejewski
7		*
8		* For the full copyright and license information, please view the LICENSE
9		* file that was distributed with this source code.
10		*/
11
12		namespace Sylius\Component\Order\Model;
13
14		use Doctrine\Common\Collections\ArrayCollection;
15		use Doctrine\Common\Collections\Collection;
16		use Sylius\Component\Resource\Model\TimestampableTrait;
17
18		/**
19		* @author Paweł Jędrzejewski <[email protected]>
20		*/
21		class Order implements OrderInterface
22		{
23		use TimestampableTrait;
24
25		/**
26		* @var mixed
27		*/
28		protected $id;
29
30		/**
31		* @var \DateTime
32		*/
33		protected $completedAt;
34
35		/**
36		* @var string
37		*/
38		protected $number;
39
40		/**
41		* @var string
42		*/
43		protected $notes;
44
45		/**
46		* @var Collection\|OrderItemInterface[]
47		*/
48		protected $items;
49
50		/**
51		* @var int
52		*/
53		protected $itemsTotal = 0;
54
55		/**
56		* @var Collection\|AdjustmentInterface[]
57		*/
58		protected $adjustments;
59
60		/**
61		* @var Collection\|CommentInterface[]
62		*/
63		protected $comments;
64
65		/**
66		* @var Collection\|IdentityInterface[]
67		*/
68		protected $identities;
69
70		/**
71		* @var int
72		*/
73		protected $adjustmentsTotal = 0;
74
75		/**
76		* Calculated total.
77		* Items total + adjustments total.
78		*
79		* @var int
80		*/
81		protected $total = 0;
82
83		/**
84		* @var string
85		*/
86		protected $state = OrderInterface::STATE_CART;
87
88		public function __construct()
89		{
90		$this->items = new ArrayCollection();
91		$this->adjustments = new ArrayCollection();
92		$this->comments = new ArrayCollection();
93		$this->identities = new ArrayCollection();
94		$this->createdAt = new \DateTime();
95		}
96
97		/**
98		* {@inheritdoc}
99		*/
100		public function getId()
101		{
102		return $this->id;
103		}
104
105		/**
106		* {@inheritdoc}
107		*/
108		public function isCompleted()
109		{
110		return null !== $this->completedAt;
111		}
112
113		/**
114		* {@inheritdoc}
115		*/
116		public function complete()
117		{
118		$this->completedAt = new \DateTime();
119		}
120
121		/**
122		* {@inheritdoc}
123		*/
124		public function getCompletedAt()
125		{
126		return $this->completedAt;
127		}
128
129		/**
130		* {@inheritdoc}
131		*/
132		public function setCompletedAt(\DateTime $completedAt = null)
133		{
134		$this->completedAt = $completedAt;
135		}
136
137		/**
138		* {@inheritdoc}
139		*/
140		public function getNumber()
141		{
142		return $this->number;
143		}
144
145		/**
146		* {@inheritdoc}
147		*/
148		public function setNumber($number)
149		{
150		$this->number = $number;
151		}
152
153		/**
154		* {@inheritdoc}
155		*/
156		public function getNotes()
157		{
158		return $this->notes;
159		}
160
161		/**
162		* {@inheritdoc}
163		*/
164		public function setNotes($notes)
165		{
166		$this->notes = $notes;
167		}
168
169		/**
170		* {@inheritdoc}
171		*/
172		public function getSequenceType()
173		{
174		return 'order';
175		}
176
177		/**
178		* {@inheritdoc}
179		*/
180		public function getItems()
181		{
182		return $this->items;
183		}
184
185		/**
186		* {@inheritdoc}
187		*/
188		public function clearItems()
189		{
190		$this->items->clear();
191
192		$this->recalculateItemsTotal();
193		}
194
195		/**
196		* {@inheritdoc}
197		*/
198		public function countItems()
199		{
200		return $this->items->count();
201		}
202
203		/**
204		* {@inheritdoc}
205		*/
206	View Code Duplication	public function addItem(OrderItemInterface $item)
		0 ignored issues – show Duplication introduced 2016-06-24 14:31 UTC by Report Bug Copy Issue Report This method seems to be duplicated in 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...
207		{
208		if ($this->hasItem($item)) {
209		return;
210		}
211
212		$this->itemsTotal += $item->getTotal();
213		$this->items->add($item);
214		$item->setOrder($this);
215
216		$this->recalculateTotal();
217		}
218
219		/**
220		* {@inheritdoc}
221		*/
222	View Code Duplication	public function removeItem(OrderItemInterface $item)
		0 ignored issues – show Duplication introduced 2016-06-24 14:31 UTC by Report Bug Copy Issue Report This method seems to be duplicated in 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...
223		{
224		if ($this->hasItem($item)) {
225		$this->items->removeElement($item);
226		$this->itemsTotal -= $item->getTotal();
227		$this->recalculateTotal();
228		$item->setOrder(null);
229		}
230		}
231
232		/**
233		* {@inheritdoc}
234		*/
235		public function hasItem(OrderItemInterface $item)
236		{
237		return $this->items->contains($item);
238		}
239
240		/**
241		* {@inheritdoc}
242		*/
243		public function getItemsTotal()
244		{
245		return $this->itemsTotal;
246		}
247
248		/**
249		* {@inheritdoc}
250		*/
251		public function recalculateItemsTotal()
252		{
253		$this->itemsTotal = 0;
254		foreach ($this->items as $item) {
255		$this->itemsTotal += $item->getTotal();
256		}
257
258		$this->recalculateTotal();
259		}
260
261		/**
262		* {@inheritdoc}
263		*/
264		public function getComments()
265		{
266		return $this->comments;
267		}
268
269		/**
270		* {@inheritdoc}
271		*/
272		public function addComment(CommentInterface $comment)
273		{
274		if (!$this->comments->contains($comment)) {
275		$comment->setOrder($this);
276		$this->comments->add($comment);
277		}
278		}
279
280		/**
281		* {@inheritdoc}
282		*/
283		public function removeComment(CommentInterface $comment)
284		{
285		if ($this->comments->contains($comment)) {
286		$comment->setOrder(null);
287		$this->comments->removeElement($comment);
288		}
289		}
290
291		/**
292		* {@inheritdoc}
293		*/
294		public function getTotal()
295		{
296		return $this->total;
297		}
298
299		/**
300		* {@inheritdoc}
301		*/
302		public function setState($state)
303		{
304		$this->state = $state;
305		}
306
307		/**
308		* {@inheritdoc}
309		*/
310		public function getState()
311		{
312		return $this->state;
313		}
314
315		/**
316		* {@inheritdoc}
317		*/
318		public function getTotalQuantity()
319		{
320		$quantity = 0;
321
322		foreach ($this->items as $item) {
323		$quantity += $item->getQuantity();
324		}
325
326		return $quantity;
327		}
328
329		/**
330		* {@inheritdoc}
331		*/
332		public function isEmpty()
333		{
334		return $this->items->isEmpty();
335		}
336
337		/**
338		* {@inheritdoc}
339		*/
340		public function addIdentity(IdentityInterface $identity)
341		{
342		if (!$this->hasIdentity($identity)) {
343		$this->identities->add($identity);
344
345		$identity->setOrder($this);
346		}
347		}
348
349		/**
350		* {@inheritdoc}
351		*/
352		public function hasIdentity(IdentityInterface $identity)
		0 ignored issues – show Documentation introduced 2016-06-24 14:31 UTC by Report Bug Copy Issue Report The return type could not be reliably inferred; please add a `@return` annotation. Our type inference engine in quite powerful, but sometimes the code does not provide enough clues to go by. In these cases we request you to add a `@return` annotation as described here. Loading history...
353		{
354		return $this->identities->contains($identity);
355		}
356
357		/**
358		* {@inheritdoc}
359		*/
360		public function getIdentities()
361		{
362		return $this->identities;
363		}
364
365		/**
366		* {@inheritdoc}
367		*/
368		public function removeIdentity(IdentityInterface $identity)
369		{
370		if ($this->hasIdentity($identity)) {
371		$identity->setOrder(null);
372		$this->identities->removeElement($identity);
373		}
374		}
375
376		/**
377		* {@inheritdoc}
378		*/
379	View Code Duplication	public function getAdjustments($type = null)
		0 ignored issues – show Duplication introduced 2016-06-24 14:31 UTC by Report Bug Copy Issue Report This method seems to be duplicated in 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...
380		{
381		if (null === $type) {
382		return $this->adjustments;
383		}
384
385		return $this->adjustments->filter(function (AdjustmentInterface $adjustment) use ($type) {
386		return $type === $adjustment->getType();
387		});
388		}
389
390		/**
391		* {@inheritdoc}
392		*/
393	View Code Duplication	public function getAdjustmentsRecursively($type = null)
		0 ignored issues – show Duplication introduced 2016-06-24 14:31 UTC by Report Bug Copy Issue Report This method seems to be duplicated in 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...
394		{
395		$adjustments = $this->getAdjustments($type)->toArray();
396		foreach ($this->items as $item) {
397		$adjustments = array_merge($adjustments, $item->getAdjustmentsRecursively($type));
398		}
399
400		return $adjustments;
401		}
402
403		/**
404		* {@inheritdoc}
405		*/
406	View Code Duplication	public function addAdjustment(AdjustmentInterface $adjustment)
		0 ignored issues – show Duplication introduced 2016-06-24 14:31 UTC by Report Bug Copy Issue Report This method seems to be duplicated in 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...
407		{
408		if (!$this->hasAdjustment($adjustment)) {
409		$this->adjustments->add($adjustment);
410		$this->addToAdjustmentsTotal($adjustment);
411		$adjustment->setAdjustable($this);
412		}
413		}
414
415		/**
416		* {@inheritdoc}
417		*/
418	View Code Duplication	public function removeAdjustment(AdjustmentInterface $adjustment)
		0 ignored issues – show Duplication introduced 2016-06-24 14:31 UTC by Report Bug Copy Issue Report This method seems to be duplicated in 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...
419		{
420		if (!$adjustment->isLocked() && $this->hasAdjustment($adjustment)) {
421		$this->adjustments->removeElement($adjustment);
422		$this->subtractFromAdjustmentsTotal($adjustment);
423		$adjustment->setAdjustable(null);
424		}
425		}
426
427		/**
428		* {@inheritdoc}
429		*/
430		public function hasAdjustment(AdjustmentInterface $adjustment)
		0 ignored issues – show Documentation introduced 2016-06-24 14:31 UTC by Report Bug Copy Issue Report The return type could not be reliably inferred; please add a `@return` annotation. Our type inference engine in quite powerful, but sometimes the code does not provide enough clues to go by. In these cases we request you to add a `@return` annotation as described here. Loading history...
431		{
432		return $this->adjustments->contains($adjustment);
433		}
434
435		/**
436		* {@inheritdoc}
437		*/
438	View Code Duplication	public function getAdjustmentsTotal($type = null)
		0 ignored issues – show Duplication introduced 2016-06-24 14:31 UTC by Report Bug Copy Issue Report This method seems to be duplicated in 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...
439		{
440		if (null === $type) {
441		return $this->adjustmentsTotal;
442		}
443
444		$total = 0;
445		foreach ($this->getAdjustments($type) as $adjustment) {
446		if (!$adjustment->isNeutral()) {
447		$total += $adjustment->getAmount();
448		}
449		}
450
451		return $total;
452		}
453
454		/**
455		* {@inheritdoc}
456		*/
457	View Code Duplication	public function getAdjustmentsTotalRecursively($type = null)
		0 ignored issues – show Duplication introduced 2016-06-24 14:31 UTC by Report Bug Copy Issue Report This method seems to be duplicated in 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...
458		{
459		$total = 0;
460		foreach ($this->getAdjustmentsRecursively($type) as $adjustment) {
461		if (!$adjustment->isNeutral()) {
462		$total += $adjustment->getAmount();
463		}
464		}
465
466		return $total;
467		}
468
469		/**
470		* {@inheritdoc}
471		*/
472		public function removeAdjustments($type)
473		{
474		foreach ($this->getAdjustments($type) as $adjustment) {
475		if ($adjustment->isLocked()) {
476		continue;
477		}
478
479		$this->removeAdjustment($adjustment);
480		}
481		}
482
483		/**
484		* {@inheritdoc}
485		*/
486		public function removeAdjustmentsRecursively($type = null)
487		{
488		$this->removeAdjustments($type);
489		foreach ($this->items as $item) {
490		$item->removeAdjustmentsRecursively($type);
491		}
492		}
493
494		/**
495		* {@inheritdoc}
496		*/
497	View Code Duplication	public function recalculateAdjustmentsTotal()
		0 ignored issues – show Duplication introduced 2016-06-24 14:31 UTC by Report Bug Copy Issue Report This method seems to be duplicated in 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...
498		{
499		$this->adjustmentsTotal = 0;
500
501		foreach ($this->adjustments as $adjustment) {
502		if (!$adjustment->isNeutral()) {
503		$this->adjustmentsTotal += $adjustment->getAmount();
504		}
505		}
506
507		$this->recalculateTotal();
508		}
509
510		/**
511		* Calculate total.
512		* Items total + Adjustments total.
513		*/
514		protected function recalculateTotal()
515		{
516		$this->total = $this->itemsTotal + $this->adjustmentsTotal;
517
518		if ($this->total < 0) {
519		$this->total = 0;
520		}
521		}
522
523		/**
524		* @param AdjustmentInterface $adjustment
525		*/
526		protected function addToAdjustmentsTotal(AdjustmentInterface $adjustment)
527		{
528		if (!$adjustment->isNeutral()) {
529		$this->adjustmentsTotal += $adjustment->getAmount();
530		$this->recalculateTotal();
531		}
532		}
533
534		/**
535		* @param AdjustmentInterface $adjustment
536		*/
537		protected function subtractFromAdjustmentsTotal(AdjustmentInterface $adjustment)
538		{
539		if (!$adjustment->isNeutral()) {
540		$this->adjustmentsTotal -= $adjustment->getAmount();
541		$this->recalculateTotal();
542		}
543		}
544		}
545

pamil / Sylius