CheckoutComponentConfig

Complexity

Total Complexity

39

Size/Duplication

Total Lines	207
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

72.81%

Importance

Changes	3
Bugs	1	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	getOrder()	0	4	1
A	getComponents()	0	7	2
A	getFormFields()	0	12	3
A	getRequiredFields()	0	8	2
C	validateData()	0	28	7
A	getData()	0	15	3
A	setData()	0	6	2
B	dependantData()	0	24	6
C	addComponent()	0	24	7
B	getComponentByType()	0	14	5

<?php

use SilverStripe\Omnipay\GatewayInfo;

/**
 * @package shop
 */
class CheckoutComponentConfig extends Object
{
    protected $components;

    protected $order;

    protected $namespaced; //namespace fields according to their component

    public function __construct(Order $order, $namespaced = true)
    {
        $this->components = ArrayList::create();
        $this->order = $order;
        $this->namespaced = $namespaced;
    }

    public function getOrder()
    {
        return $this->order;
    }

    /**
     * @param CheckoutComponent $component
     * @param string            $insertBefore The class of the component to insert this one before
     */
    public function addComponent(CheckoutComponent $component, $insertBefore = null)
    {
        if ($this->namespaced) {
            $component = new CheckoutComponent_Namespaced($component);
        }
        if ($insertBefore) {

The expression $insertBefore of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $existingItems = $this->getComponents();
            $this->components = new ArrayList;
            $inserted = false;
            foreach ($existingItems as $existingItem) {
                if (!$inserted && $existingItem instanceof $insertBefore) {
                    $this->components->push($component);
                    $inserted = true;
                }
                $this->components->push($existingItem);
            }
            if (!$inserted) {
                $this->components->push($component);
            }
        } else {
            $this->getComponents()->push($component);
        }
        return $this;
    }

    /**
     * @return ArrayList Of GridFieldComponent
     */
    public function getComponents()
    {
        if (!$this->components) {
            $this->components = ArrayList::create();
        }
        return $this->components;
    }

    /**
     * Returns the first available component with the given class or interface.
     *
     * @param String ClassName
     *
     * @return GridFieldComponent
     */
    public function getComponentByType($type)
    {
        foreach ($this->components as $component) {
            if ($this->namespaced) {
                if ($component->Proxy() instanceof $type) {
                    return $component->Proxy();
                }
            } else {
                if ($component instanceof $type) {
                    return $component;
                }
            }
        }
    }

    /**
     * Get combined form fields
     *
     * @return FieldList namespaced fields
     */
    public function getFormFields()
    {
        $fields = FieldList::create();
        foreach ($this->getComponents() as $component) {
            if ($cfields = $component->getFormFields($this->order)) {
                $fields->merge($cfields);
            } else {
                user_error("getFields on  " . get_class($component) . " must return a FieldList");
            }
        }
        return $fields;
    }

    public function getRequiredFields()
    {
        $required = array();
        foreach ($this->getComponents() as $component) {
            $required = array_merge($required, $component->getRequiredFields($this->order));
        }
        return $required;
    }

    /**
     * Validate every component against given data.
     *
     * @param  array $data data to validate
     *
     * @return boolean validation result
     * @throws ValidationException
     */
    public function validateData($data)
    {
        $result = ValidationResult::create();
        foreach ($this->getComponents() as $component) {
            try {
                $component->validateData($this->order, $this->dependantData($component, $data));
            } catch (ValidationException $e) {
                //transfer messages into a single result
                foreach ($e->getResult()->messageList() as $code => $message) {
                    if (is_numeric($code)) {
                        $code = null;
                    }
                    if ($this->namespaced) {
                        $code = $component->namespaceFieldName($code);
                    }
                    $result->error($message, $code);
                }
            }
        }

        $this->order->extend('onValidateDataOnCheckout', $result);

        if (!$result->valid()) {
            throw new ValidationException($result);
        }

        return true;
    }

    /**
     * Get combined data
     *
     * @return array map of field names to data values
     */
    public function getData()
    {
        $data = array();

        foreach ($this->getComponents() as $component) {
            $orderdata = $component->getData($this->order);

            if (is_array($orderdata)) {
                $data = array_merge($data, $orderdata);
            } else {
                user_error("getData on  " . $component->name() . " must return an array");
            }
        }
        return $data;
    }

    /**
     * Set data on all components
     *
     * @param array $data map of field names to data values
     */
    public function setData($data)
    {
        foreach ($this->getComponents() as $component) {
            $component->setData($this->order, $this->dependantData($component, $data));
        }
    }

    /**
     * Helper function for saving data from other components.
     */
    protected function dependantData($component, $data)
    {
        if (!$this->namespaced) { //no need to try and get un-namespaced dependant data
            return $data;
        }
        $dependantdata = array();
        foreach ($component->dependsOn() as $dependanttype) {
            $dependant = null;
            foreach ($this->components as $check) {
                if (get_class($check->Proxy()) == $dependanttype) {
                    $dependant = $check;
                    break;
                }
            }
            if (!$dependant) {
                user_error("Could not find a $dependanttype component, as depended by " . $component->name());
            }
            $dependantdata = array_merge(
                $dependantdata,
                $component->namespaceData($dependant->unnamespaceData($data))
            );
        }
        return array_merge($dependantdata, $data);
    }
}

class SinglePageCheckoutComponentConfig extends CheckoutComponentConfig
{
    public function __construct(Order $order)
    {
        parent::__construct($order);
        $this->addComponent(CustomerDetailsCheckoutComponent::create());
        $this->addComponent(ShippingAddressCheckoutComponent::create());
        $this->addComponent(BillingAddressCheckoutComponent::create());
        if (Checkout::member_creation_enabled() && !Member::currentUserID()) {
            $this->addComponent(MembershipCheckoutComponent::create());
        }
        if (count(GatewayInfo::getSupportedGateways()) > 1) {
            $this->addComponent(PaymentCheckoutComponent::create());
        }
        $this->addComponent(NotesCheckoutComponent::create());
        $this->addComponent(TermsCheckoutComponent::create());
    }
}