ProductQuestion_OrderItemExtension - Code Metrics - sunnysideup/silverstripe-ecommerce_product_questions - Measure and Improve Code Quality continuously with Scrutinizer

ProductQuestion_OrderItemExtension F
last analyzed 2018-07-10 05:58 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	372
Duplicated Lines	13.71 %

Coupling/Cohesion

Components	1
Dependencies	14

Importance

Changes

Metric	Value
wmc	68
lcom	1
cbo	14
dl	51
loc	372
rs	2.96
c	0
b	0
f	0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	updateCMSFields()	0	11	1
A	AllQuestionsAnswered()	12	12	4
A	AllRequiredQuestionsAnswered()	14	14	5
A	ProductQuestionsAnswerNOHTML()	0	4	1
A	getProductQuestionsAnswerNOHTML()	0	4	1
A	canConfigure()	0	8	2
A	HasRequiredQuestions()	0	8	2
A	ConfigureLabel()	0	6	1
A	ConfigureLink()	0	6	1
A	ProductQuestionsAnswerFormLabel()	0	15	4
A	ProductQuestionsAnswerFormLink()	0	11	3
A	HasProductQuestions()	13	13	4
A	ApplicableProductQuestions()	0	4	1
A	ProductQuestions()	12	12	3
A	productQuestionBuyable()	0	8	2
A	ProductQuestionsAnswerFormInCheckoutPage()	0	4	1
B	ProductQuestionsAnswerForm()	0	36	8
B	ProductQuestionsAnswers()	0	23	7
B	updateOrderItemWithProductAnswers()	0	19	7
B	onBeforeWrite()	0	26	10

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 ProductQuestion_OrderItemExtension 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 ProductQuestion_OrderItemExtension, and based on these observations, apply Extract Interface, too.

<?php

/**
 * adds functionality to OrderItems.
 */
class ProductQuestion_OrderItemExtension extends DataExtension
namespace YourVendor;

class YourClass { }
{
    private static $db = array(

        'ProductQuestionsAnswer' => 'HTMLText',
        'JSONAnswers' => 'Text',
    );

    private static $casting = array(

        'ProductQuestionsAnswerNOHTML' => 'Text',
        'ConfigureLabel' => 'Varchar',
        'ConfigureLink' => 'Varchar',
    );

    public function updateCMSFields(FieldList $fields)
    {
        $fields->addFieldsToTab(
            'Root.Questions',
            array(
                ReadOnlyField::create('ProductQuestionsAnswer', _t('ProductQuestions.ANSWERS', 'Answers')),
                ReadOnlyField::create('JSONAnswers', _t('ProductQuestions.JSON_ANSWERS', 'Answers as JSON')),
            )
        );
        return $fields;
    }

    /**
     * @return bool
     */
    public function AllQuestionsAnswered()

    {
        if ($answers = $this->owner->ProductQuestionsAnswers()) {
            foreach ($answers as $productQuestion) {
                if (!$productQuestion->Answer) {
                    return false;
                }
            }
        }

        return true;
    }

    /**
     * @return bool
     */
    public function AllRequiredQuestionsAnswered()

    {
        if ($answers = $this->owner->ProductQuestionsAnswers()) {
            foreach ($answers as $productQuestion) {
                if ($productQuestion->AnswerRequired) {
                    if (!$productQuestion->Answer) {
                        return false;
                    }
                }
            }
        }

        return true;
    }

    /**
     * casted variable.
     *
     * @return string
     */
    public function ProductQuestionsAnswerNOHTML()
    {
        return $this->owner->getProductQuestionsAnswerNOHTML();
    }

    public function getProductQuestionsAnswerNOHTML()
    {
        return strip_tags($this->owner->ProductQuestionsAnswer);

    }

    /**
     * can the order item be configured.
     *
     * @return bool
     */
    public function canConfigure()
    {
        if ($this->owner->Order()->IsSubmitted()) {

            return false;
        }

        return true;
    }

    /**
     * can the order item be configured.
     *
     * @return bool
     */
    public function HasRequiredQuestions()
    {
        if ($this->owner->AllRequiredQuestionsAnswered()) {

            return false;
        }

        return true;
    }

    /**
     * returns a link to configure an OrderItem
     * and adds the relevant requirements.
     *
     * @return string
     */
    public function ConfigureLabel()
    {
        Requirements::javascript('ecommerce_product_questions/javascript/EcomProductQuestions.js');

        return $this->owner->ProductQuestionsAnswerFormLabel();
    }

    /**
     * returns a link to configure an OrderItem
     * and adds the relevant requirements.
     *
     * @return string
     */
    public function ConfigureLink()
    {
        Requirements::javascript('ecommerce_product_questions/javascript/EcomProductQuestions.js');

        return $this->owner->ProductQuestionsAnswerFormLink();
    }

    /**
     * returns the link to edit the products.
     *
     * @return string
     */
    public function ProductQuestionsAnswerFormLabel()
    {
        if ($this->owner->HasProductQuestions()) {
            $buyable = $this->productQuestionBuyable();
            if ($buyable) {
                if ($label = $buyable->CustomConfigureLabel()) {
                    return $label;
                }
            }

            return _t('ProductQuestion.CONFIGURE', 'Configure');
        }

        return '';
    }

    /**
     * returns the link to edit the products.
     *
     * @return string
     */
    public function ProductQuestionsAnswerFormLink()
    {
        if ($this->owner->HasProductQuestions()) {
            $buyable = $this->productQuestionBuyable();
            if ($buyable) {
                return $buyable->ProductQuestionsAnswerFormLink($this->owner->ID);

            }
        }

        return '';
    }

    /**
     * cache only!
     *
     * @var array
     */
    private static $_has_product_questions = array();

    /**
     * Does the buyable associated with the orderitem
     * have product questions?
     *
     * @return bool
     */
    public function HasProductQuestions()

    {
        if (!isset(self::$_has_product_questions[$this->owner->ID])) {
            $productQuestions = $this->owner->ProductQuestions();
            if ($productQuestions && $productQuestions->count()) {
                self::$_has_product_questions[$this->owner->ID] = true;

            } else {
                self::$_has_product_questions[$this->owner->ID] = false;
            }
        }

        return self::$_has_product_questions[$this->owner->ID];
    }

    /**
     * cache only!
     *
     * @var array
     */
    private static $_product_questions = array();

    /**
     * @alias for ProductQuestions
     */
    public function ApplicableProductQuestions()
    {
        return $this->ProductQuestions();
    }

    /**
     * @return DataList | Null
     */
    public function ProductQuestions()

    {
        if (!isset(self::$_product_questions[$this->owner->ID])) {
            if ($buyable = $this->owner->productQuestionBuyable()) {
                self::$_product_questions[$this->owner->ID] = $buyable->ApplicableProductQuestions();

            } else {
                self::$_product_questions[$this->owner->ID] = null;
            }
        }

        return self::$_product_questions[$this->owner->ID];
    }

    /**
     * cache only!
     *
     * @var array
     */
    private static $_product_question_product = null;

    /**
     * @return Product | Null
     */
    public function productQuestionBuyable()
    {
        if (!isset(self::$_product_question_product[$this->owner->ID])) {
            self::$_product_question_product[$this->owner->ID] = $this->owner->Buyable();

        }

        return self::$_product_question_product[$this->owner->ID];
    }

    /**
     *
     * @return Form
     */
    public function ProductQuestionsAnswerFormInCheckoutPage()
    {
        return ModelAsController::controller_for($this->owner->Buyable())->ProductQuestionsAnswerForm($this->owner);
    }

    /**
     * @return Form

     */
    public function ProductQuestionsAnswerForm($controller = null, $name = 'productquestionsanswerselect')
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        $productQuestions = $this->owner->ProductQuestions();
        $buyable = $this->productQuestionBuyable();
        $backURL = Session::get('BackURL');
        if ($backURL || empty($_GET['BackURL'])) {
if (rand(1, 6) > 3) {
//print "Check failed";
} else {
    print "Check succeeded";
}
            //do nothing
        } else {
            $backURL = $_GET['BackURL'];
        }
        if ($productQuestions && $productQuestions->count()) {
            $requiredfields = array();
            $fields = new FieldList(
                new HiddenField('OrderItemID', 'OrderItemID', $this->owner->ID),

                new HiddenField('BackURL', 'BackURL', $backURL)
            );
            $values = array();
            if ($this->owner->JSONAnswers) {
                $values = json_decode($this->owner->JSONAnswers);

            }
            foreach ($productQuestions as $productQuestion) {
                $value = empty($values->{$productQuestion->ID}) ? null : $values->{$productQuestion->ID};
                $fields->push($productQuestion->getFieldForProduct($buyable, $value)); //TODO: perhaps use a dropdown instead (eliminates need to use keyboard)
            }
            $actions = new FieldList(
                array(
                    new FormAction('addproductquestionsanswer', _t('ProductQuestion.ANSWER_QUESTION', 'Update Selection')),
                )
            );
            $validator = new RequiredFields($requiredfields);
            $form = new Form($controller, $name, $fields, $actions, $validator);
            Requirements::themedCSS('Cart');

            return $form;
        }
    }

    /**
     * @return ArrayList | NULL

     */
    public function ProductQuestionsAnswers()
    {
        if ($this->owner->HasProductQuestions()) {
            $al = new ArrayList();
            $values = json_decode($this->owner->JSONAnswers);

            if ($questions = $this->owner->ProductQuestions()) {
                foreach ($questions as $question) {
                    $newQuestion = clone $question;
                    $answer = empty($values->{$question->ID}) ? null : $values->{$question->ID};
                    if ($answer) {
                        $newQuestion->Answer = $answer;
                    } elseif ($newQuestion->AnswerRequired) {
                        $newQuestion->Answer = null;
                    } else {
                        $newQuestion->Answer = $newQuestion->DefaultAnswer;
                    }
                    $al->push($newQuestion);
                }

                return $al;
            }
        }
    }

    /**
     * @param array $answers
     *                       ID = ProductQuestion.ID
     *                       "ID" => "Answer" (String)
     * @param bool  $write
     */
    public function updateOrderItemWithProductAnswers($answers, $write = true)
    {
        if ($this->owner->canEdit()) {
            $this->owner->ProductQuestionsAnswer = '';

            if (is_array($answers) && count($answers)) {
                foreach ($answers as $productQuestionID => $productQuestionAnswer) {
                    $question = ProductQuestion::get()->byID(intval($productQuestionID));
                    if ($question) {
if (rand(1, 6) > 3) {
//print "Check failed";
} else {
    print "Check succeeded";
}
                    }
                    //$form->addErrorMessage("ProductQuestions", $message, $type);

                }
                $this->owner->ProductQuestionsAnswer = $this->owner->renderWith('ProductQuestionsAnswers')->getValue();
            }
            $this->owner->JSONAnswers = json_encode($answers);

            if ($write) {
                $this->owner->write();
            }
        }
    }

    public function onBeforeWrite()
    {
        parent::onBeforeWrite();
        if (!empty($this->owner->Parameters)) {
            if (!empty($this->owner->Parameters['productquestions'])) {
                $answers = array();
                $params = $this->owner->Parameters['productquestions'];

                $params = urldecode($params);
                $items = explode('|', $params);
                if ($items && is_array($items) && count($items)) {

                    foreach ($items as $item) {
                        if ($item) {
                            $itemArray = explode('=', $item);
                            if (is_array($itemArray) && count($itemArray) == 2) {
                                $key = intval(str_replace(array('ProductQuestions[', ']'), '', $itemArray[0]));
                                $value = convert::raw2sql($itemArray[1]);
                                $answers[$key] = $value;
                            }
                        }
                    }
                }
                unset($this->owner->Parameters);
                $this->updateOrderItemWithProductAnswers($answers, false);
            }
        }
    }
}


1		<?php
2
3		/**
4		* adds functionality to OrderItems.
5		*/
6		class ProductQuestion_OrderItemExtension extends DataExtension
		0 ignored issues – show Coding Style Compatibility introduced 2017-01-03 01:10 UTC by Report Bug Copy Issue Report PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions. You can fix this by adding a namespace to your class: namespace YourVendor; class YourClass { } When choosing a vendor namespace, try to pick something that is not too generic to avoid conflicts with other libraries. Loading history...
7		{
8		private static $db = array(
		0 ignored issues – show Unused Code introduced 2017-01-03 01:10 UTC by Report Bug Copy Issue Report The property `$db` is not used and could be removed. This check marks private properties in classes that are never used. Those properties can be removed. Loading history...
9		'ProductQuestionsAnswer' => 'HTMLText',
10		'JSONAnswers' => 'Text',
11		);
12
13		private static $casting = array(
		0 ignored issues – show Unused Code introduced 2017-01-03 01:10 UTC by Report Bug Copy Issue Report The property `$casting` is not used and could be removed. This check marks private properties in classes that are never used. Those properties can be removed. Loading history...
14		'ProductQuestionsAnswerNOHTML' => 'Text',
15		'ConfigureLabel' => 'Varchar',
16		'ConfigureLink' => 'Varchar',
17		);
18
19		public function updateCMSFields(FieldList $fields)
20		{
21		$fields->addFieldsToTab(
22		'Root.Questions',
23		array(
24		ReadOnlyField::create('ProductQuestionsAnswer', _t('ProductQuestions.ANSWERS', 'Answers')),
25		ReadOnlyField::create('JSONAnswers', _t('ProductQuestions.JSON_ANSWERS', 'Answers as JSON')),
26		)
27		);
28		return $fields;
29		}
30
31		/**
32		* @return bool
33		*/
34	View Code Duplication	public function AllQuestionsAnswered()
		0 ignored issues – show Duplication introduced 2017-08-15 05:48 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...
35		{
36		if ($answers = $this->owner->ProductQuestionsAnswers()) {

sunnysideup / silverstripe-ecommerce_product_questions

ProductQuestion_OrderItemExtension F last analyzed 2018-07-10 05:58 UTC