SpeckCatalog\Model\Choice\Relational

Complexity

Total Complexity

39

Size/Duplication

Total Lines	216
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

58.7%

Importance

Changes	12
Bugs	4	Features	3

21 Methods

Rating	Name	Duplication	Size	Complexity
A	getKey()	0	4	1
A	getPrice()	0	7	2
B	getRecursivePrice()	0	21	5
A	getAdjustedPrice()	0	5	1
A	getParentProductPrice()	0	7	2
B	getAdjustmentPrice()	0	14	5
A	getItemNumber()	0	6	2
A	getProductTypeId()	0	6	2
A	getManufacturer()	0	6	2
A	getProduct()	0	4	1
A	setProduct()	0	5	1
A	getOptions()	0	4	1
A	addOption()	0	6	1
A	setOptions()	0	10	2
A	getParentOptions()	0	4	1
A	setParentOptions()	0	5	1
A	getAddPrice()	0	11	3
A	setAddPrice()	0	5	1
A	getParent()	0	4	1
A	setParent()	0	6	1
A	__toString()	0	11	3

<?php

namespace SpeckCatalog\Model\Choice;

use SpeckCatalog\Model\AbstractModel;
use SpeckCatalog\Model\Choice as Base;

class Relational extends Base
{
    protected $parent;
    protected $product;
    protected $options;
    protected $parentOptions;
    protected $addPrice;

    public function getKey()
    {
        return $this->choiceId;
    }

    public function getPrice()
    {
        if ($this->has('product')) {
            return $this->getProduct()->getPrice();
        }
        return 0;
    }

    public function getRecursivePrice($parentProductPrice = 0, $retailPrice = false)
    {
        if ($this->has('product')) {
            $productPrice = $this->getProduct()->getRecursivePrice($retailPrice);
            return $productPrice + $this->getAdjustmentPrice($productPrice);
        } else {
            $adjustedPrice = $this->getAdjustedPrice($retailPrice);
            $adjustmentPrice = $adjustedPrice - $parentProductPrice;

            $price = 0;
            if ($this->has('options')) {
                foreach ($this->getOptions() as $option) {
                    $price += $option->getRecursivePrice($adjustedPrice, $retailPrice);
                }
            }

            return ($adjustmentPrice + $price) >= -$parentProductPrice
                ? $adjustmentPrice + $price
                : -$parentProductPrice;
        }
    }

    public function getAdjustedPrice($retailPrice = false)
    {
        $parentProductPrice = $this->getParentProductPrice($retailPrice);
        return $parentProductPrice + $this->getAdjustmentPrice($parentProductPrice);
    }

    public function getParentProductPrice($retailPrice = false)
    {
        if ($this->has('parent')) {
            return $this->getParent()->getAdjustedPrice($retailPrice);

It seems like you code against a specific sub-type and not the parent class SpeckCatalog\Model\AbstractModel as the method getAdjustedPrice() does only exist in the following sub-classes of SpeckCatalog\Model\AbstractModel: SpeckCatalog\Model\Choice\Relational, SpeckCatalog\Model\Option\Relational. Maybe you want to instanceof check for one of these explicitly?

        }
        return 0;
    }


    public function getAdjustmentPrice($parentPrice)
    {
        if ($this->getPriceDiscountFixed()) {
            return -$this->getPriceDiscountFixed();
        } elseif ($this->getPriceDiscountPercent()) {
            return $parentPrice * -($this->getPriceDiscountPercent()/100);
        } elseif ($this->getPriceNoCharge()) {
            return -$parentPrice;
        } elseif ($this->getPriceOverrideFixed()) {
            return $this->getPriceOverrideFixed() - $parentPrice;
        } else {
            return 0;
        }
    }


    public function getItemNumber()
    {
        if ($this->getProduct()) {
            return $this->getProduct()->getItemNumber();
        }
    }


    public function getProductTypeId()
    {
        if ($this->getProduct()) {
            return $this->getProduct()->getProductTypeId();
        }
    }

    public function getManufacturer()
    {
        if ($this->getProduct()) {
            return $this->getProduct()->getManufacturer();
        }
    }


    /**
     * @return product
     */
    public function getProduct()
    {
        return $this->product;
    }

    /**
     * @param $product
     * @return self
     */
    public function setProduct($product)
    {
        $this->product = $product;
        return $this;
    }

    /**
     * @return options
     */
    public function getOptions()
    {
        return $this->options;
    }

    public function addOption($option)
    {
        $option->setParent($this);
        $this->options[] = $option;
        return $this;
    }

    /**
     * @param $options
     * @return self
     */
    public function setOptions($options)
    {
        $this->options = array();

        foreach ($options as $option) {
            $this->addOption($option);
        }

        return $this;
    }

    /**
     * @return parentOptions
     */
    public function getParentOptions()
    {
        return $this->parentOptions;
    }

    /**
     * @param $parentOptions
     * @return self
     */
    public function setParentOptions($parentOptions)
    {
        $this->parentOptions = $parentOptions;
        return $this;
    }

    public function getAddPrice($retailPrice = false)
    {
        if ($this->addPrice) {
            return $this->addPrice;
        } elseif ($this->has('product')) {
            $productPrice = $this->getProduct()->getPrice($retailPrice);
            return $productPrice + $this->getAdjustmentPrice($productPrice);
        } else {
            return $this->getAdjustedPrice($retailPrice) - $this->getParentProductPrice($retailPrice);
        }
    }

    /**
     * @param $addPrice
     * @return self
     */
    public function setAddPrice($addPrice)
    {
        $this->addPrice = $addPrice;
        return $this;
    }

    /**
     * @return parent
     */
    public function getParent()
    {
        return $this->parent;
    }

    /**
     * @param $parent
     * @return self
     */
    public function setParent(AbstractModel $parent)
    {
        $this->parent = $parent;
        $this->setOptionId($parent->getOptionId());

It seems like you code against a specific sub-type and not the parent class SpeckCatalog\Model\AbstractModel as the method getOptionId() does only exist in the following sub-classes of SpeckCatalog\Model\AbstractModel: SpeckCatalog\Model\Choice, SpeckCatalog\Model\Choice\Relational, SpeckCatalog\Model\Option, SpeckCatalog\Model\OptionImage, SpeckCatalog\Model\OptionImage\Relational, SpeckCatalog\Model\Option\Relational. Maybe you want to instanceof check for one of these explicitly?

        return $this;
    }

    public function __toString()
    {
        if ($this->getOverrideName()) {
            $str = $this->getOverrideName();
        } elseif ($this->has('product')) {
            $str = $this->getProduct()->getName();
        } else {
            $str = 'Unnamed Choice';
        }
        return $str;
    }
}