Basket::totalItems() - Code Metrics - Inspection of "Update types" - Lenius/basket - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 9c20ed...a7d58a )

by Carsten

created 2021-01-06 20:30 UTC

Basket::totalItems() A

↳ Parent: Project

Complexity

Conditions	3
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	3

Importance

Changes

Metric	Value
cc	3
nc	3
nop	1
dl	0
loc	11
ccs	5
cts	5
cp	1
crap	3
rs	9.9
c	0
b	0
f	0

<?php

/**
 * This file is part of Lenius Basket, a PHP package to handle
 * your shopping basket.
 *
 * Copyright (c) 2017 Lenius.
 * https://github.com/lenius/basket
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * @author Carsten Jonstrup<[email protected]>
 * @copyright 2017 Lenius.
 *
 * @version production
 *
 * @see https://github.com/lenius/basket
 */

namespace Lenius\Basket;

use InvalidArgumentException;

/**
 * Class Basket.
 */
class Basket
{
    /** @var string */
    protected string $id;


    /** @var IdentifierInterface */
    protected IdentifierInterface $identifier;

    /** @var StorageInterface */
    protected StorageInterface $store;

    /** @var array<string> */
    protected array $requiredParams = [
        'id',
        'name',
        'quantity',
        'price',
        'weight',
    ];

    /**
     * Basket constructor.
     *
     * @param StorageInterface    $store      The interface for storing the cart data
     * @param IdentifierInterface $identifier The interface for storing the identifier
     */
    public function __construct(StorageInterface $store, IdentifierInterface $identifier)
    {
        $this->store = $store;
        $this->identifier = $identifier;

        // Generate/retrieve identifier
        $this->id = $this->identifier->get();

        // Restore the cart from a saved version
        if (method_exists($this->store, 'restore')) {
            $this->store->restore();
        }

        // Let our storage class know which cart we're talking about
        $this->store->setIdentifier($this->id);
    }

    /**
     * Retrieve the basket contents.
     *
     * @param bool $asArray
     *
     * @return array An array of Item objects
     */
    public function &contents($asArray = false): array
    {
        return $this->store->data($asArray);
    }

    /**
     * Insert an item into the basket.
     *
     * @param ItemInterface $item
     * @return string A unique item identifier
     */
    public function insert(ItemInterface $item): string
    {
        $this->checkArgs($item);

        $itemIdentifier = $this->createItemIdentifier($item);

        if ($this->has($itemIdentifier) && $this->item($itemIdentifier) instanceof ItemInterface) {
            $item->quantity = $this->item($itemIdentifier)->quantity + $item->quantity;
            $this->update($itemIdentifier, $item);

            return $itemIdentifier;
        }

        $item->setIdentifier($itemIdentifier);

        $this->store->insertUpdate($item);

        return $itemIdentifier;
    }

    /**
     * Update an item.
     *
     * @param string $itemIdentifier The unique item identifier
     * @param mixed $key The key to update, or an array of key-value pairs
     * @param mixed $value The value to set $key to
     */
    public function update(string $itemIdentifier, $key, $value = null)
    {
        /** @var Item $item */
        foreach ($this->contents() as $item) {
            if ($item->identifier == $itemIdentifier) {
                $item->update($key, $value);

                break;
            }
        }
    }

    /**
     * Remove an item from the basket.
     *
     * @param string $identifier Unique item identifier
     */
    public function remove(string $identifier)
    {
        $this->store->remove($identifier);
    }

    /**
     * Destroy/empty the basket.
     */
    public function destroy()
    {
        $this->store->destroy();
    }

    /**
     * Check if the basket has a specific item.
     *
     * @param string $itemIdentifier The unique item identifier
     *
     * @return bool Yes or no?
     */
    public function has(string $itemIdentifier): bool
    {
        return $this->store->has($itemIdentifier);
    }

    /**
     * Return a specific item object by identifier.
     *
     * @param string $itemIdentifier The unique item identifier
     *
     * @return Item|bool
     */
    public function item(string $itemIdentifier)
    {
        return $this->store->item($itemIdentifier);
    }

    /**
     * Returns the first occurance of an item with a given id.
     *
     * @param string $id The item id
     *
     * @return bool|Item
     */
    public function find(string $id)
    {
        return $this->store->find($id);
    }

    /**
     * The total tax value for the basket.
     *
     * @return float The total tax value
     */
    public function tax(): float
    {
        $total = 0;

        /** @var Item $item */
        foreach ($this->contents() as $item) {
            $total += $item->tax();
        }

        return (float) $total;
    }

    /**
     * The total weight value for the basket.
     *
     * @return float The total weight value
     */
    public function weight(): float
    {
        $weight = 0;

        /** @var Item $item */
        foreach ($this->contents() as $item) {
            $weight += $item->weight();
        }

        return (float) $weight;
    }

    /**
     * The total value of the basket.
     *
     * @param bool $includeTax Include tax on the total?
     *
     * @return float The total basket value
     */
    public function total($includeTax = true): float
    {
        $total = 0;

        /** @var Item $item */
        foreach ($this->contents() as $item) {
            $total += $item->total($includeTax);
        }

        return (float) $total;
    }

    /**
     * The total number of items in the basket.
     *
     * @param bool $unique Just return unique items?
     *
     * @return int Total number of items
     */
    public function totalItems($unique = false): int
    {
        $total = 0;

        /** @var Item $item */
        foreach ($this->contents() as $item) {
            $total += $unique ? 1 : $item->quantity;
        }

        return $total;
    }

    /**
     * Set the basket identifier, useful if restoring a saved basket.
     *
     * @codeCoverageIgnore
     *
     * @param string $identifier
     */
    public function setIdentifier(string $identifier)
    {
        $this->store->setIdentifier($identifier);
    }

    /**
     * Create a unique item identifier.
     *
     * @param ItemInterface $item
     * @return string An md5 hash of item
     */
    protected function createItemIdentifier(ItemInterface $item): string
    {
        if (! array_key_exists('options', $item->toArray())) {
            $item->options = [];
        }

        $options = $item->options;

        ksort($options);

        $item->options = $options;

        return md5($item->id.serialize($item->options));
    }

    /**
     * Check if a basket item has the required parameters.
     * @param ItemInterface $item
     */
    protected function checkArgs(ItemInterface $item)
    {
        foreach ($this->requiredParams as $param) {
            if (! array_key_exists($param, $item->toArray())) {
                throw new InvalidArgumentException("The '{$param}' field is required");
            }
        }
    }
}


1		<?php
2
3		/**
4		* This file is part of Lenius Basket, a PHP package to handle
5		* your shopping basket.
6		*
7		* Copyright (c) 2017 Lenius.
8		* https://github.com/lenius/basket
9		*
10		* For the full copyright and license information, please view the LICENSE
11		* file that was distributed with this source code.
12		*
13		* @author Carsten Jonstrup<[email protected]>
14		* @copyright 2017 Lenius.
15		*
16		* @version production
17		*
18		* @see https://github.com/lenius/basket
19		*/
20
21		namespace Lenius\Basket;
22
23		use InvalidArgumentException;
24
25		/**
26		* Class Basket.
27		*/
28		class Basket
29		{
30		/** @var string */
31		protected string $id;
		0 ignored issues – show Bug introduced 2021-01-06 20:37 UTC by Report Bug Copy Issue Report This code did not parse for me. Apparently, there is an error somewhere around this line: Syntax error, unexpected T_STRING, expecting T_FUNCTION or T_CONST Loading history...
32
33		/** @var IdentifierInterface */
34		protected IdentifierInterface $identifier;
35
36		/** @var StorageInterface */
37		protected StorageInterface $store;
38
39		/** @var array<string> */
40		protected array $requiredParams = [
41		'id',
42		'name',
43		'quantity',
44		'price',
45		'weight',
46		];
47
48		/**
49		* Basket constructor.
50		*
51		* @param StorageInterface $store The interface for storing the cart data
52		* @param IdentifierInterface $identifier The interface for storing the identifier
53		*/
54	18	public function __construct(StorageInterface $store, IdentifierInterface $identifier)
55		{
56	18	$this->store = $store;
57	18	$this->identifier = $identifier;
58
59		// Generate/retrieve identifier
60	18	$this->id = $this->identifier->get();
61
62		// Restore the cart from a saved version
63	18	if (method_exists($this->store, 'restore')) {
64	18	$this->store->restore();
65		}
66
67		// Let our storage class know which cart we're talking about
68	18	$this->store->setIdentifier($this->id);
69	18	}
70
71		/**
72		* Retrieve the basket contents.
73		*
74		* @param bool $asArray
75		*
76		* @return array An array of Item objects
77		*/
78	14	public function &contents($asArray = false): array
79		{
80	14	return $this->store->data($asArray);
81		}
82
83		/**
84		* Insert an item into the basket.
85		*
86		* @param ItemInterface $item
87		* @return string A unique item identifier
88		*/
89	18	public function insert(ItemInterface $item): string
90		{
91	18	$this->checkArgs($item);
92
93	18	$itemIdentifier = $this->createItemIdentifier($item);
94
95	18	if ($this->has($itemIdentifier) && $this->item($itemIdentifier) instanceof ItemInterface) {
96	1	$item->quantity = $this->item($itemIdentifier)->quantity + $item->quantity;
97	1	$this->update($itemIdentifier, $item);
98
99	1	return $itemIdentifier;
100		}
101
102	18	$item->setIdentifier($itemIdentifier);
103
104	18	$this->store->insertUpdate($item);
105
106	18	return $itemIdentifier;
107		}
108
109		/**
110		* Update an item.
111		*
112		* @param string $itemIdentifier The unique item identifier
113		* @param mixed $key The key to update, or an array of key-value pairs
114		* @param mixed $value The value to set $key to
115		*/
116	2	public function update(string $itemIdentifier, $key, $value = null)
117		{
118		/** @var Item $item */
119	2	foreach ($this->contents() as $item) {
120	2	if ($item->identifier == $itemIdentifier) {
121	2	$item->update($key, $value);
122
123	2	break;
124		}
125		}
126	2	}
127
128		/**
129		* Remove an item from the basket.
130		*
131		* @param string $identifier Unique item identifier
132		*/
133	1	public function remove(string $identifier)
134		{
135	1	$this->store->remove($identifier);
136	1	}
137
138		/**
139		* Destroy/empty the basket.
140		*/
141	18	public function destroy()
142		{
143	18	$this->store->destroy();
144	18	}
145
146		/**
147		* Check if the basket has a specific item.
148		*
149		* @param string $itemIdentifier The unique item identifier
150		*
151		* @return bool Yes or no?
152		*/
153	18	public function has(string $itemIdentifier): bool
154		{
155	18	return $this->store->has($itemIdentifier);
156		}
157
158		/**
159		* Return a specific item object by identifier.
160		*
161		* @param string $itemIdentifier The unique item identifier
162		*
163		* @return Item\|bool
164		*/
165	5	public function item(string $itemIdentifier)
166		{
167	5	return $this->store->item($itemIdentifier);
168		}
169
170		/**
171		* Returns the first occurance of an item with a given id.
172		*
173		* @param string $id The item id
174		*
175		* @return bool\|Item
176		*/
177	1	public function find(string $id)
178		{
179	1	return $this->store->find($id);
180		}
181
182		/**
183		* The total tax value for the basket.
184		*
185		* @return float The total tax value
186		*/
187	2	public function tax(): float
188		{
189	2	$total = 0;
190
191		/** @var Item $item */
192	2	foreach ($this->contents() as $item) {
193	2	$total += $item->tax();
194		}
195
196	2	return (float) $total;
197		}
198
199		/**
200		* The total weight value for the basket.
201		*
202		* @return float The total weight value
203		*/
204	2	public function weight(): float
205		{
206	2	$weight = 0;
207
208		/** @var Item $item */
209	2	foreach ($this->contents() as $item) {
210	2	$weight += $item->weight();
211		}
212
213	2	return (float) $weight;
214		}
215
216		/**
217		* The total value of the basket.
218		*
219		* @param bool $includeTax Include tax on the total?
220		*
221		* @return float The total basket value
222		*/
223	5	public function total($includeTax = true): float
224		{
225	5	$total = 0;
226
227		/** @var Item $item */
228	5	foreach ($this->contents() as $item) {
229	5	$total += $item->total($includeTax);
230		}
231
232	5	return (float) $total;
233		}
234
235		/**
236		* The total number of items in the basket.
237		*
238		* @param bool $unique Just return unique items?
239		*
240		* @return int Total number of items
241		*/
242	1	public function totalItems($unique = false): int
243		{
244	1	$total = 0;
245
246		/** @var Item $item */
247	1	foreach ($this->contents() as $item) {
248	1	$total += $unique ? 1 : $item->quantity;
249		}
250
251	1	return $total;
252		}
253
254		/**
255		* Set the basket identifier, useful if restoring a saved basket.
256		*
257		* @codeCoverageIgnore
258		*
259		* @param string $identifier
260		*/
261		public function setIdentifier(string $identifier)
262		{
263		$this->store->setIdentifier($identifier);
264		}
265
266		/**
267		* Create a unique item identifier.
268		*
269		* @param ItemInterface $item
270		* @return string An md5 hash of item
271		*/
272	18	protected function createItemIdentifier(ItemInterface $item): string
273		{
274	18	if (! array_key_exists('options', $item->toArray())) {
275	13	$item->options = [];
276		}
277
278	18	$options = $item->options;
279
280	18	ksort($options);
281
282	18	$item->options = $options;
283
284	18	return md5($item->id.serialize($item->options));
285		}
286
287		/**
288		* Check if a basket item has the required parameters.
289		* @param ItemInterface $item
290		*/
291	18	protected function checkArgs(ItemInterface $item)
292		{
293	18	foreach ($this->requiredParams as $param) {
294	18	if (! array_key_exists($param, $item->toArray())) {
295		throw new InvalidArgumentException("The '{$param}' field is required");
296		}
297		}
298	18	}
299		}
300

Lenius / basket

Push — master ( 9c20ed...a7d58a )

Basket::totalItems() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like