DMSDocumentCart

Complexity

Total Complexity

27

Size/Duplication

Total Lines	294
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes

0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	4
A	getItems()	0	4	1
A	addItem()	0	6	1
A	getItem()	0	4	1
A	removeItem()	0	6	1
A	removeItemByID()	0	6	1
A	updateItemQuantity()	0	15	3
A	emptyCart()	0	6	1
A	isCartEmpty()	0	6	1
A	setBackUrl()	0	6	1
A	getBackUrl()	0	4	1
A	setReceiverInfo()	0	6	1
A	getReceiverInfo()	0	4	1
A	getReceiverInfoNice()	0	4	2
A	getBackend()	0	4	1
A	isInCart()	0	4	1
A	saveSubmission()	0	18	1
A	getSummary()	0	4	1
A	isViewOnly()	0	4	1
A	setViewOnly()	0	5	1
A	getLink()	0	4	1

<?php
/**
 * Class DMSDocumentCart represents the shopping cart.
 *
 */
class DMSDocumentCart extends ViewableData

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

{
    /**
     * A handle to the classes' {@link DMSCartBackendInterface}
     *
     * @var DMSCartBackendInterface
     */
    protected $backend;

    /**
     * Variable to control whether a cart is being updated or not
     *
     * @var bool
     */
    private $viewOnly = false;

    /**
     * Instantiate a cart backend either by that provided, or a session default
     *
     * @param DMSCartBackendInterface $backend

Should the type for parameter $backend not be DMSCartBackendInterface|null?

     * @throws DMSDocumentCartException If a backend was provided but doesn't implement the backend interface
     */
    public function __construct($backend = null)
    {
        parent::__construct();
        if ($backend && !($backend instanceof DMSCartBackendInterface)) {
            throw new DMSDocumentCartException('Backend must implement DMSCartBackendInterface!');
        }
        $this->backend = ($backend) ?: DMSSessionBackend::singleton();
    }

    /**
     * Returns all the cart items as an array
     *
     * @return ArrayList
     */
    public function getItems()
    {
        return ArrayList::create($this->backend->getItems());
    }

    /**
     * Add an {@link DMSRequestItem} object into the cart.
     *
     * @param DMSRequestItem $item
     *
     * @return DMSDocumentCart
     */
    public function addItem(DMSRequestItem $item)
    {
        $this->backend->addItem($item);

        return $this;
    }

    /**
     * Get a {@link DMSRequestItem} object from the cart.
     *
     * @param int $itemID The ID of the item
     *
     * @return DMSRequestItem|boolean
     */
    public function getItem($itemID)
    {
        return $this->backend->getItem($itemID);
    }

    /**
     * Removes a {@link DMSRequestItem} from the cart by it's id
     *
     * @param DMSRequestItem $item
     *
     * @return DMSDocumentCart
     */
    public function removeItem(DMSRequestItem $item)
    {
        $this->backend->removeItem($item);

        return $this;
    }

    /**
     * Removes a {@link DMSRequestItem} from the cart by it's id
     *
     * @param int $itemID
     *
     * @return DMSDocumentCart
     */
    public function removeItemByID($itemID)
    {
        $this->backend->removeItemByID($itemID);

        return $this;
    }

    /**
     * Adjusts (increments, decrements or amends) the quantity of an {@link DMSRequestItem}.'
     * A positive $quantity increments the total, whereas a negative value decrements the total. A cart item
     * is removed completely if it's value reaches <= 0.
     *
     * @param int $itemID
     * @param int $quantity
     *
     * @return DMSDocumentCart
     */
    public function updateItemQuantity($itemID, $quantity)
    {
        if ($item = $this->getItem($itemID)) {
            $currentQuantity = $item->getQuantity();
            $newQuantity = $currentQuantity + $quantity;
            if ($newQuantity <= 0) {
                $this->removeItemByID($itemID);
            } else {
                $item->setQuantity($newQuantity);
                $this->addItem($item);

It seems like $item defined by $this->getItem($itemID) on line 113 can also be of type boolean; however, DMSDocumentCart::addItem() does only seem to accept object<DMSRequestItem>, maybe add an additional type check?

            }
        }

        return $this;
    }

    /**
     * Completely empties a cart
     *
     * @return DMSDocumentCart
     */
    public function emptyCart()
    {
        $this->backend->emptyCart();

        return $this;
    }

    /**
     * Checks if a cart is empty.
     * Returns true if cart is empty, false otherwise.
     *
     * @return boolean
     */
    public function isCartEmpty()
    {
        $items = $this->getItems();

        return !$items->exists();
    }

    /**
     * Set the backURL to be a Session variable for the current Document Cart
     *
     * @param string $backURL
     *
     * @return DMSDocumentCart
     */
    public function setBackUrl($backURL)
    {
        $this->backend->setBackUrl($backURL);

        return $this;
    }

    /**
     * Returns the backURL for the current Document Cart
     *
     * @return string
     */
    public function getBackUrl()
    {
        return $this->backend->getBackUrl();
    }

    /**
     * Sets the recipients info as an array (e.g. array('Name'=>'Joe','Surname'=>'Soap'))
     *
     * @param array $receiverInfo
     *
     * @return DMSDocumentCart
     */
    public function setReceiverInfo($receiverInfo)
    {
        $this->backend->setReceiverInfo($receiverInfo);

        return $this;
    }

    /**
     * Retrieves the recipients info as an array (e.g. array('Name'=>'Joe','Surname'=>'Soap'))
     *
     * @return array
     */
    public function getReceiverInfo()
    {
        return $this->backend->getReceiverInfo();
    }

    /**
     * Returns the recipients in a Viewable format
     *
     * @return ArrayData|bool
     */
    public function getReceiverInfoNice()
    {
        return (is_array($this->getReceiverInfo())) ? ArrayData::create($this->getReceiverInfo()) : false;
    }

    /**
     * Gets the backend handler
     *
     * @return DMSSessionBackend
     */
    public function getBackend()
    {
        return $this->backend;
    }

    /**
     * Checks if an item exists within a cart. Returns true (if exists) or false.
     *
     * @param int $itemID
     *
     * @return bool
     */
    public function isInCart($itemID)
    {
        return (bool) $this->getItem($itemID);
    }

    /**
     * Persists a cart submission to the database
     *
     * @param Form $form
     *
     * @return int
     */
    public function saveSubmission(Form $form)
    {
        $submission = DMSDocumentCartSubmission::create();
        $form->saveInto($submission);
        $return = $submission->write();
        $this->getItems()->each(function ($row) use ($submission) {
            $values = array(
                'Quantity' => $row->getQuantity(),
                'DocumentID' => $row->getDocument()->ID,
            );
            $submissionItem = DMSDocumentCartSubmissionItem::create($values);
            $submission->Items()->add($submissionItem);

The method Items does not exist on object<DMSDocumentCartSubmission>? Since you implemented __call, maybe consider adding a @method annotation.

            $row->getDocument()->incrementPrintRequest();
        });

        return $return;
    }

    /**
     * Returns true if the cart is being updated. False otherwise
     * @return bool
     */
    public function isViewOnly()
    {
        return $this->viewOnly;
    }

    /**
     * Sets the updating flag
     *
     * @param bool $viewOnly
     * @return DMSDocumentCart
     */
    public function setViewOnly($viewOnly)
    {
        $this->viewOnly = (bool) $viewOnly;
        return $this;
    }

    /**
     * Displays a view-only table of the cart items.
     *
     * @return HTMLText
     */
    public function getSummary()
    {
        return $this->renderWith('DMSDocumentCartSummary');
    }

    /**
     * Utility method to link to the current controllers action
     *
     * @param string $action

Should the type for parameter $action not be string|null?

     * @return string

Should the return type not be string|null?

     */
    public function getLink($action = null)
    {
        return DMSDocumentCartController::create()->Link($action);
    }
}