Treestoneit\ShoppingCart\Concerns\ManagesCartItems

Complexity

Total Complexity

18

Size/Duplication

Total Lines	203
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getModel()	0	4	1
A	add()	0	38	3
A	update()	0	4	1
A	updateQuantity()	0	14	3
A	updateOptions()	0	6	1
A	updateOption()	0	4	1
A	remove()	0	18	3
A	destroy()	0	8	1
A	refreshCart()	0	20	3
A	persist()	0	6	1

<?php

namespace Treestoneit\ShoppingCart\Concerns;

use Illuminate\Support\Facades\Session;
use Treestoneit\ShoppingCart\Buyable;
use Treestoneit\ShoppingCart\Models\Cart;
use Treestoneit\ShoppingCart\Models\CartItem;

trait ManagesCartItems
{
    use HasItems;

    /**
     * Get the cart model instance.
     *
     * @return \Treestoneit\ShoppingCart\Models\Cart
     */
    public function getModel(): Cart
    {
        return $this->cart;
    }

    /**
     * Add an item to the cart.
     *
     * @param  \Treestoneit\ShoppingCart\Buyable  $buyable
     * @param  int  $quantity
     * @param  array|null  $options
     * @return \Treestoneit\ShoppingCart\CartManager
     */
    public function add(Buyable $buyable, int $quantity = 1, array $options = []): self
    {
        $newItem = new CartItem();
        $newItem->setRelation('buyable', $buyable);
        $newItem->buyable()->associate($buyable);

$buyable of type object<Treestoneit\ShoppingCart\Buyable> is not a sub-type of object<Illuminate\Database\Eloquent\Model>. It seems like you assume a concrete implementation of the interface Treestoneit\ShoppingCart\Buyable to be always present.

        $newItem->fill([
            'quantity' => $quantity,
            'options' => $options,
        ]);

        $item = $this->items()->first(function (CartItem $cartItem) use ($newItem) {
            return $cartItem->getIdentifierAttribute() === $newItem->getIdentifierAttribute();
        });

        // If the item already exists in the cart, we'll
        // just update the quantity by the given value.
        if ($item) {
            $item->increment('quantity', $quantity);

            return $this;
        }

        if (! $this->cart->exists) {
            $this->cart->save();
        }

        // We persist the new item to the database and add it to the items
        // collection. Eloquent doesn't do this by default, so we'll do it ourselves.
        $this->cart->items->add(
            $this->cart->items()->save($newItem)
        );

        $this->cart->push();

        $this->refreshCart();

        return $this;
    }

    /**
     * Change the quantity of an item in the cart.
     *
     * @param  int  $item
     * @param  int  $quantity
     * @return \Treestoneit\ShoppingCart\CartManager
     * @throws \Exception
     */
    public function update(int $item, int $quantity): self
    {
        return $this->updateQuantity($item, $quantity);
    }

    /**
     * Change the quantity of an item in the cart.
     *
     * @param  int  $item
     * @param  int  $quantity
     * @return \Treestoneit\ShoppingCart\CartManager
     * @throws \Exception
     */
    public function updateQuantity(int $item, int $quantity): self
    {
        if ($quantity <= 0) {
            return $this->remove($item);
        }

        if (! $this->items()->contains($item)) {
            return $this;
        }

        $this->items()->find($item)->update(['quantity' => $quantity]);

        return $this;
    }

    /**
     * Update the options of an item in the cart.
     *
     * @param  int  $item
     * @param  array  $options
     * @return \Treestoneit\ShoppingCart\CartManager
     */
    public function updateOptions(int $item, array $options): self
    {
        $this->items()->find($item)->update(['options' => $options]);

        return $this;
    }

    /**
     * Update an option of an item in the cart.
     *
     * @param  int  $item
     * @param  string  $option
     * @param $value
     * @return \Treestoneit\ShoppingCart\CartManager
     */
    public function updateOption(int $item, string $option, $value): self
    {
        return $this->updateOptions($item, [$option => $value]);
    }

    /**
     * Remove an item from the cart.
     *
     * @param  int  $item
     * @return static
     * @throws \Exception
     */
    public function remove(int $item): self
    {
        $key = $this->items()->search(function (CartItem $i) use ($item) {
            return $i->getKey() == $item;
        });

        if ($key === false) {
            return $this;
        }

        $this->items()->pull($key)->delete();

        if ($this->items()->isEmpty()) {
            return $this->destroy();
        }

        return $this;
    }

    /**
     * Destroy the cart instance.
     *
     * @return static
     */
    public function destroy()
    {
        $this->cart->delete();

        $this->refreshCart(new Cart());

        return $this;
    }

    /**
     * Toggle the session key, and recalculate totals.
     *
     * @param  \Treestoneit\ShoppingCart\Models\Cart|null  $cart
     * @return static
     */
    public function refreshCart(Cart $cart = null): self
    {
        if ($cart) {
            $this->cart = $cart;
        }

        $cart = $cart ?? $this->cart;

        if ($cart->exists) {
            $cart->loadMissing('items.buyable');

            Session::put('cart', $cart->getKey());
        } else {
            Session::forget('cart');
        }

        $this->clearCached();

It seems like clearCached() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        return $this;
    }

    /**
     * Persist the cart contents to the database.
     *
     * @return static
     */
    protected function persist(): self
    {
        Session::put('cart', $this->cart->getKey());

        return $this;
    }
}