ProductVariation::getParent() - Code Metrics - sunnysideup/silverstripe-ecommerce_product_variation - Measure and Improve Code Quality continuously with Scrutinizer

ProductVariation::getParent() A
last analyzed 2018-07-12 04:11 UTC

↳ Parent: ProductVariation
Complexity

Conditions	1
Paths	1
Size

Total Lines
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0
<?php

/**
 *
 */
class ProductVariation extends DataObject implements BuyableModel, EditableEcommerceObject
namespace YourVendor;

class YourClass { }
{
    /**
     * Standard SS variable.
     */
    private static $api_access = array(

        'view' => array(
            'Title',
            'Description',
            'FullName',
            'AllowPurchase',
            'InternalItemID',
            'NumberSold',
            'Price',
            'Weight',
            'Model',
            'Quantifier',
            'Version',
        ),
    );

    /**
     * Standard SS variable.
     */
    private static $db = array(

        'InternalItemID' => 'Varchar(30)',
        'Price' => 'Currency',
        'Weight' => 'Float',
        'Model' => 'Varchar(30)',
        'Quantifier' => 'Varchar(30)',
        'AllowPurchase' => 'Boolean',
        'Sort' => 'Int',
        'NumberSold' => 'Int',
        'Description' => 'Varchar(255)',
        'FullName' => 'Varchar(255)',
        'FullSiteTreeSort' => 'Varchar(110)',
    );

    /**
     * Standard SS variable.
     */
    private static $has_one = array(

        'Product' => 'Product',
        'Image' => 'Product_Image',
    );

    /**
     * Standard SS variable.
     */
    private static $many_many = array(

        'AttributeValues' => 'ProductAttributeValue',
    );

    /**
     * Standard SS variable.
     */
    private static $casting = array(

        'Parent' => 'Product',
        'Title' => 'HTMLText',
        'Link' => 'Text',
        'AllowPurchaseNice' => 'Varchar',
        'CalculatedPrice' => 'Currency',
        'CalculatedPriceAsMoney' => 'Money',
    );

    /**
     * Standard SS variable.
     */
    private static $defaults = array(

        'AllowPurchase' => 1,
    );

    /**
     * Standard SS variable.
     */
    private static $versioning = array(

        'Stage',
    );

    /**
     * Standard SS variable.
     */
    private static $extensions = array(

        "Versioned('Stage')",
    );

    /**
     * Standard SS variable.
     */
    private static $indexes = array(

        'Sort' => true,
        'FullName' => true,
        'FullSiteTreeSort' => true,
    );

    /**
     * Standard SS variable.
     */
    private static $field_labels = array(

        'Description' => 'Title (optional)',
    );

    /**
     * Standard SS variable.
     */
    private static $summary_fields = array(

        'CMSThumbnail' => 'Image',
        'Title' => 'Title',
        'Price' => 'Price',
        'AllowPurchaseNice' => 'For Sale',
    );

    /**
     * Standard SS variable.
     */
    private static $searchable_fields = array(

        'FullName' => array(
            'title' => 'Keyword',
            'field' => 'TextField',
            'filter' => 'PartialMatchFilter',
        ),
        'Price' => array(
            'title' => 'Price',
            'field' => 'NumericField',
        ),
        'InternalItemID' => array(
            'title' => 'Internal Item ID',
            'filter' => 'PartialMatchFilter',
        ),
        'AllowPurchase',
    );

    /**
     * Standard SS variable.
     */
    private static $default_sort = '"AllowPurchase" DESC, "FullSiteTreeSort" ASC, "Sort" ASC, "InternalItemID" ASC, "Price" ASC';


    /**
     * Standard SS variable.
     */
    private static $singular_name = 'Product Variation';

    public function i18n_singular_name()
    {
        return _t('ProductVariation.PRODUCTVARIATION', 'Product Variation');
    }

    /**
     * Standard SS variable.
     */
    private static $plural_name = 'Product Variations';

    public function i18n_plural_name()
    {
        return _t('ProductVariation.PRODUCTVARIATIONS', 'Product Variations');
    }
    public static function get_plural_name()

    {
        $obj = Injector::inst()->get('ProductVariation');

        return $obj->i18n_plural_name();
    }

    /**
     * How is the title build up?
     *
     * @var array
     **/
    private static $title_style_option = array(
        'default' => array(
            'ShowType' => true,
            'BetweenTypeAndValue' => ': ',
            'BetweenVariations' => ', ',
        ),
    );

    /**
     * change the way the title of the variation is displayed
     * @param string $code                key
     * @param string $showType            do we show the type (e.g. colour, size)?
     * @param string $betweenTypeAndValue e.g. a semi-colon (:)
     * @param string $betweenVariations   e.g. a comma (,)
     */
    public static function add_title_style_option($code, $showType, $betweenTypeAndValue, $betweenVariations)
    {
        self::$title_style_option[$code] = array(
                'ShowType' => $showType,
                'BetweenTypeAndValue' => $betweenTypeAndValue,
                'BetweenVariations' => $betweenVariations,
            );
        Config::inst()->update('ProductVariation', 'current_style_option_code', $code);
    }

    /**
     * remove style option by key
     * @param  string $code               key
     */
    public static function remove_title_style_option($code)
    {
        unset(self::$title_style_option[$code]);
    }

    private static $current_style_option_code = 'default';


    public static function get_current_style_option_array()

    {
        return self::$title_style_option[Config::inst()->get('ProductVariation', 'current_style_option_code')];
    }

    /**
     * Standard SS method.
     *
     * @return FieldSet
     */
    public function getCMSFields()
    {
        //backup in case there are no products.
        if (Product::get()->count() == 0) {
            return parent::getCMSFields();
        }
        $product = $this->Product();

        if (class_exists('CMSEditLinkField')) {
            $productField = CMSEditLinkField::create(
                'ProductID',
                $this->Product()->i18n_singular_name(),

                $this->Product()

            );
        } else {
            $productCount = Product::get()->count();
            if ($productCount > 500) {
                user_error('We recommend you install https://github.com/briceburg/silverstripe-pickerfield');
                $productField = ReadonlyField::create(
                    'ProductIDTitle',
                    _t('ProductVariation.PRODUCT', 'Product'),
                    $this->Product() ? $this->Product()->Title : _t('ProductVariation.NO_PRODUCT', 'none')

                );
            } else {
                $productField = new DropdownField('ProductID', _t('ProductVariation.PRODUCT', 'Product'), Product::get()->map('ID', 'Title')->toArray());
                $productField->setEmptyString('(Select one)');
            }
        }
        $fields = new FieldList(
            new TabSet(
                'Root',
                new Tab(
                    'Main',
                    $productField,
                    $fullNameLinkField = ReadOnlyField::create('FullNameLink', _t('ProductVariation.FULLNAME', 'Full Name'), '<a href="'.$this->Link().'">'.$this->FullName.'</a>'),
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                    new NumericField('Price', _t('ProductVariation.PRICE', 'Price')),
                    new CheckboxField('AllowPurchase', _t('ProductVariation.ALLOWPURCHASE', 'Allow Purchase ?'))
                ),
                new Tab(
                    'Details',
                    new TextField('InternalItemID', _t('ProductVariation.INTERNALITEMID', 'Internal Item ID')),
                    new TextField('Description', _t('ProductVariation.DESCRIPTION', 'Description (optional)'))
                ),
                new Tab(
                    'Image',
                    new Product_ProductImageUploadField('Image')
                )
            )
        );
        $fullNameLinkField->dontEscape = true;
        if ($this->EcomConfig()->ProductsHaveWeight) {
            $fields->addFieldToTab('Root.Details', new NumericField('Weight', _t('ProductVariation.WEIGHT', 'Weight')));
        }
        if ($this->EcomConfig()->ProductsHaveModelNames) {
            $fields->addFieldToTab('Root.Details', new TextField('Model', _t('ProductVariation.MODEL', 'Model')));
        }
        if ($this->EcomConfig()->ProductsHaveQuantifiers) {
            $fields->addFieldToTab('Root.Details', new TextField('Quantifier', _t('ProductVariation.QUANTIFIER', 'Quantifier (e.g. per kilo, per month, per dozen, each)')));
        }
        $fields->addFieldToTab('Root.Details', new ReadOnlyField('FullSiteTreeSort', _t('Product.FULLSITETREESORT', 'Full sort index')));
        if ($product) {
            $types = $product->VariationAttributes();
            if ($this->ID) {
                $values = $this->AttributeValues();

                foreach ($types as $type) {
                    $isReadonlyField = false;
                    $rightTitle = '';
                    $field = $type->getDropDownField();
                    if ($field) {
                        $value = $values->find('TypeID', $type->ID);
                        if ($value) {
                            $isReadonlyField = true;
                        } else {
                            if ($this->HasBeenSold()) {
                                $isReadonlyField = true;
                                $rightTitle = _t(
                                    'ProductVariation.ALREADYPURCHASED',
                                    'NOT SET (you can not select a value now because it has already been purchased).'
                                );
                            } else {
                                $field = $type->getDropDownField();
                                if ($field instanceof DropdownField) {
                                    $field->setEmptyString('');
                                }
                            }
                        }
                    } else {
                        $isReadonlyField = true;
                        $rightTitle = _t('ProductVariation.NOVALUESTOSELECT', 'No values to select');
                    }
                    if ($isReadonlyField) {
                        if (class_exists('CMSEditLinkField')) {
                            $field = CMSEditLinkField::create("Type{$type->ID}", $type->Name, $value)
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
                                ->setDescription($rightTitle);
                        } else {
                            $field->setValue($value->ID);
                            $field = $field->performReadonlyTransformation();
                            $field->setName("Type{$type->ID}");
                            $field->setDescription($rightTitle);
                        }
                    }
                    $fields->addFieldToTab('Root.Attributes', $field);
                }
            } else {
                foreach ($types as $type) {
                    $field = $type->getDropDownField();
                    $fields->addFieldToTab('Root.Attributes', $field);
                }
            }
        }
        $fields->addFieldToTab(
            'Root.Main',
            new LiteralField(
                'AddToCartLink',
                '<p class="message good"><a href="'.$this->AddLink().'">'._t('Product.ADD_TO_CART', 'add to cart').'</a></p>'
            )
        );
        $this->extend('updateCMSFields', $fields);

        return $fields;
    }

    /**
     * link to edit the record.
     *
     * @param string | Null $action - e.g. edit
     *
     * @return string
     */
    public function CMSEditLink($action = null)
    {
        return Controller::join_links(
            Director::baseURL(),
            '/admin/product-config/ProductVariation/EditForm/field/ProductVariation/item/'.$this->ID.'/',
            $action
        );
    }

    /**
     * Use the sort order of the variation attributes to order the attribute values.
     * This ensures that when VariationAttributes is used for a table header
     * and AttributeValues are used for the table rows then the columns will be
     * in the same order.
     *
     * @return DataObjectSet

     */
    public function AttributeValuesSorted()
    {
        $values = parent::AttributeValues();
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}
        $types = $this->Product()->VariationAttributes();

        $result = ArrayList::create();
        foreach ($types as $type) {
            $result->push($values->find('TypeID', $type->ID));
        }

        return $result;
    }

    /**
     * standard SS method.
     */
    public function populateDefaults()
    {
        parent::populateDefaults();
        $this->AllowPurchase = 1;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
    }

    /**
     * Puts together a title for the Product Variation.
     *
     * @return string

     */
    public function Title()
    {
        return $this->getTitle();
    }
    public function TitleWithHTML($noProductTitle = false)
    {
        return $this->getTitle(true, $noProductTitle);
    }
    public function getTitle($withHTML = false, $noProductTitle = false)
    {
        $array = array(
            'Values' => $this->AttributeValues(),

            'Product' => $this->Product(),

            'Description' => $this->Description,
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
            'InternalItemID' => $this->InternalItemID,
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
            'Price' => $this->Price,
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
            'WithProductTitle' => $noProductTitle ? false : true,
        );
        $html = $this->customise($array)->renderWith('ProductVariationItem');
        if ($withHTML) {
            return $html;
        } else {
            //@todo: reverse the ampersands, etc...
            return Convert::raw2att(trim(preg_replace('/\s+/', ' ', strip_tags($html))));
        }
    }

    /**
     * shorthand.
     *
     * @return string

     */
    public function FullDescription()
    {
        return $this->Title(true, false);

    }

    /**
     * shorthand.
     *
     * @return string

     */
    public function ImgAltTag()
    {
        return $this->Title(false, false);

    }

    /**
     * returns YES or NO for the CMS Fields.
     *
     * @return string
     */
    public function AllowPurchaseNice()
    {
        return $this->obj('AllowPurchase')->Nice();
    }

    protected $currentStageOfRequest = '';

    /**
     * when we save this object, should we save the parent
     * as well?
     *
     * @var bool
     */
    protected $saveParentProduct = false;

    /**
     * By setting this to TRUE
     * the parent (product) will be save when this object will be saved.
     *
     * @param bool $b
     */
    public function setSaveParentProduct($b)
    {
        $this->saveParentProduct = $b;
    }

    /**
     * standard SS method
     * sets the FullName + FullSiteTreeSort of the variation.
     */
    public function onBeforeWrite()
    {
        //$this->currentStageOfRequest = Versioned::current_stage();

        //Versioned::set_reading_mode("");

        $this->prepareFullFields();
        parent::onBeforeWrite();
    }

    /**
     * sets the FullName and FullSiteTreeField to the latest values
     * This can be useful as you can compare it to the ones saved in the database.
     * Returns true if the value is different from the one in the database.
     *
     * @return bool
     */
    public function prepareFullFields()
    {
        $fullName = '';
        if ($this->InternalItemID) {
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
            $fullName .= $this->InternalItemID.': ';
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        }
        $fullName .= $this->getTitle(false, true);
        if ($product = $this->MainParentGroup()) {
            $product->prepareFullFields();
            $fullName .= ' ('.$product->FullName.')';
            $this->FullSiteTreeSort = $product->FullSiteTreeSort.','.$this->Sort;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        }
        $this->FullName = strip_tags($fullName);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        if ($this->EcomConfig()->ProductsHaveWeight) {
            if (!$this->Weight) {
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                if ($product && $product->Weight) {
                    $this->Weight = $product->Weight;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                }
            }
        }
        if (($this->dbObject('FullName') != $this->FullName) || ($this->dbObject('FullSiteTreeSort') != $this->FullSiteTreeSort)) {
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
            return true;
        }

        return false;
    }

    /**
     * Standard SS Method.
     */
    public function onAfterWrite()
// 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);
    }
}
    {
        parent::onAfterWrite();
        //clean up data???

        //todo: what is this for?
        if (isset($_POST['ProductAttributes']) && is_array($_POST['ProductAttributes']) && $this->canEdit()) {
            $productAttributesArray = array();
            foreach ($_POST['ProductAttributes'] as $key => $value) {
                $productAttributesArray[$key] = intval($value);
            }
            $this->AttributeValues()->setByIDList(array_values($productAttributesArray));

        }
        unset($_POST['ProductAttributes']);
        if ($this->saveParentProduct) {
            if ($product = $this->Product()) {

                $product->write();
                $product->publish('Stage', 'Live');
            }
        }
    }

    /**
     * Standard SS Method
     * Remove links to Attribute Values.
     */
    public function onBeforeDelete()
    {
        parent::onBeforeDelete();
        $this->AttributeValues()->removeAll();

    }

    /**
     * this is used by TableListField to access attribute values.
     *
     * @return DataObject
     */
    public function AttributeProxy()
    {
        $do = new DataObject();
        if ($this->AttributeValues()->exists()) {

            foreach ($this->AttributeValues() as $value) {

                $do->{'Val'.$value->Type()->ID} = $value->Value;
            }
        }

        return $do;
    }

    //GROUPS AND SIBLINGS

    /**
     * We use this function to make it more universal.
     * For a buyable, a parent could refer to a ProductGroup OR a Product.
     *
     * @return DataObject | Null
     **/
    public function Parent()
    {
        return $this->getParent();
    }
    public function getParent()

    {
        return $this->Product();

    }

    /**
     * Returns the direct parent (group) for the product.
     **/
    public function MainParentGroup()

    {
        return $this->Product();

    }

    /**
     * Returns Buybales in the same group.
     **/
    public function Siblings()
    {
        return self::get()->Filter(array('ProductID' => $this->ProductID));
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
    }

    //IMAGES
    /**
     * returns a "BestAvailable" image if the current one is not available
     * In some cases this is appropriate and in some cases this is not.
     * For example, consider the following setup
     * - product A with three variations
     * - Product A has an image, but the variations have no images
     * With this scenario, you want to show ONLY the product image
     * on the product page, but if one of the variations is added to the
     * cart, then you want to show the product image.
     * This can be achieved bu using the BestAvailable image.
     *
     * @return Image | Null
     */
    public function BestAvailableImage()
    {
        $image = $this->Image();
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
        if ($image && $image->exists()) {
            return $image;
        }
        if ($product = $this->Product()) {

            return $product->BestAvailableImage();
        }
    }

    /**
     * Little hack to show thumbnail in summary fields in modeladmin in CMS.
     *
     * @return string (HTML = formatted image)
     */
    public function CMSThumbnail()
    {
        if ($image = $this->Image()) {
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            if ($image->exists()) {
                return $image->Thumbnail();
            }
        }

        return '['._t('product.NOIMAGE', 'no image').']';
    }

    /**
     * Returns a link to a default image.
     * If a default image is set in the site config then this link is returned
     * Otherwise, a standard link is returned.
     *
     * @return string

     */
    public function DefaultImageLink()
    {
        $this->EcomConfig()->DefaultImageLink();
    }

    /**
     * returns the default image of the product.
     *
     * @return Image | Null
     */
    public function DefaultImage()
    {
        return $this->Product()->DefaultImage();

    }

    /**
     * returns a product image for use in templates
     * e.g. $DummyImage.Width();.
     *
     * @return Product_Image
     */
    public function DummyImage()
    {
        return new Product_Image();
    }

    // VERSIONING

    /**
     * Action to return specific version of a product.
     * This is really useful for sold products where you want to retrieve the actual version that you sold.
     *
     * @TODO: this is not correct yet, as the versions of product and productvariation are muddled up!
     *
     * @param HTTPRequest $request
     */
    public function viewversion($request)
    {
        $version = intval($request->param('ID'));
        $product = $this->Product();

        if ($product) {
            $this->redirect($product->Link('viewversion/'.$product->ID.'/'.$version.'/'));
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
        } else {
            $page = DataObject::get_one(
                'ErrorPage',
                array('ErrorCode' => '404')
            );
            if ($page) {
                $this->redirect($page->Link());
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }

                return;
            }
        }

        return array();
    }

    /**
     * Action to return specific version of a product variation.
     * This can be any product to enable the retrieval of deleted products.
     * This is really useful for sold products where you want to retrieve the actual version that you sold.
     *
     * @param int $id
     * @param int $version
     *
     * @return DataObject | Null

     */
    public function getVersionOfBuyable($id = 0, $version = 0)
    {
        if (!$id) {
            $id = $this->ID;
        }
        if (!$version) {
            $version = $this->Version;

        }

        return OrderItem::get_version($this->ClassName, $id, $version);
    }

    //ORDER ITEM

    /**
     * returns the order item associated with the buyable.
     * ALWAYS returns one, even if there is none in the cart.
     * Does not write to database.
     *
     * @return OrderItem (no kidding)
     **/
    public function OrderItem()
    {
        //work out the filter
        $filter = array();
        $updatedFilters = $this->extend('updateItemFilter', $filter);
        if ($updatedFilters !== null && is_array($updatedFilters) && count($updatedFilters)) {
            foreach ($updatedFilters as $updatedFilter) {
                if (is_array($updatedFilter)) {
                    $filter = array_merge($filter, $updatedFilter);
                } else {
                    $filter[] = $updatedFilter;
                }
            }
        }
        //make the item and extend
        $item = ShoppingCart::singleton()->findOrMakeItem($this, $filter);
        $this->extend('updateDummyItem', $item);

        return $item;
    }

    /**
     * @var string
     */
    protected $defaultClassNameForOrderItem = 'ProductVariation_OrderItem';

    /**
     * you can overwrite this function in your buyable items (such as Product).
     *
     * @return string
     **/
    public function classNameForOrderItem()
    {
        $className = $this->defaultClassNameForOrderItem;
        $updatedClassName = $this->extend('updateClassNameForOrderItem', $className);
        if ($updatedClassName != null && is_array($updatedClassName) && count($updatedClassName)) {
            $className = $updatedClassName[0];
        }

        return $className;
    }

    /**
     * You can set an alternative class name for order item using this method.
     *
     * @param string $ClassName
/**
 * @param array $germany
 * @param array $ireland
 */
function finale($germany, $island) {
    return "2:1";
}
     **/
    public function setAlternativeClassNameForOrderItem($className)
    {
        $this->defaultClassNameForOrderItem = $className;
    }

    /**
     * When purchasing this buyable, how many decimals can it have?
     *
     * @return int
     */
    public function QuantityDecimals()
    {
        return 0;
    }

    /**
     * Number of variations sold.
     *
     * @TODO: check if we need to use other class names
     *
     *
     * @return int
     */
    public function HasBeenSold()
    {
        return $this->getHasBeenSold();
    }
    public function getHasBeenSold()

    {
        $dataList = Order::get_datalist_of_orders_with_submit_record($onlySubmittedOrders = true, $includeCancelledOrders = false);
        $dataList = $dataList->innerJoin('OrderAttribute', '"OrderAttribute"."OrderID" = "Order"."ID"');
        $dataList = $dataList->innerJoin('OrderItem', '"OrderAttribute"."ID" = "OrderItem"."ID"');
        $dataList = $dataList->filter(
            array(
                'BuyableID' => $this->ID,
                'buyableClassName' => $this->ClassName
            )
        );

        return $dataList->count();
    }

    //LINKS

    /**
     * Takes you to the Product and filters
     * for the provided variation.
     *
     * @param string $action - OPTIONAL

     *
     * @return string
     */
    public function Link($action = null)
    {
        if (!$action) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $action = 'filterforvariations/'.$this->ID.'/';
        }

        return $this->Product()->Link($action);

    }


    /**
     *
     * @todo TEST!!!!
     * @return string
     */
    public function VersionedLink()
    {
        return Controller::join_links(
             Director::baseURL(),
             EcommerceConfig::get('ShoppingCart_Controller', 'url_segment'),
             'submittedbuyable',
             $this->ClassName,
             $this->ID,
             $this->Version

         );
    }

    /**
     * passing on shopping cart links ...is this necessary?? ...why not just pass the cart?
     *
     * @return string
     */
    public function AddLink()
    {
        return ShoppingCart_Controller::add_item_link($this->ID, $this->ClassName, $this->linkParameters());
    }

    /**
     * link use to add (one) to cart.
     *
     *@return string
     */
    public function IncrementLink()
    {
        //we can do this, because by default add link adds one
        return ShoppingCart_Controller::add_item_link($this->ID, $this->ClassName, $this->linkParameters());
    }

    /**
     * Link used to remove one from cart
     * we can do this, because by default remove link removes one.
     *
     * @return string
     */
    public function DecrementLink()
    {
        return ShoppingCart_Controller::remove_item_link($this->ID, $this->ClassName, $this->linkParameters());
    }

    /**
     * remove one buyable's orderitem from cart.
     *
     * @return string (Link)
     */
    public function RemoveLink()
    {
        return ShoppingCart_Controller::remove_item_link($this->ID, $this->ClassName, $this->linkParameters());
    }

    /**
     * remove all of this buyable's orderitem from cart.
     *
     * @return string (Link)
     */
    public function RemoveAllLink()
    {
        return ShoppingCart_Controller::remove_all_item_link($this->ID, $this->ClassName, $this->linkParameters());
    }

    /**
     * remove all of this buyable's orderitem from cart and go through to this buyble to add alternative selection.
     *
     * @return string (Link)
     */
    public function RemoveAllAndEditLink()
    {
        return ShoppingCart_Controller::remove_all_item_and_edit_link($this->ID, $this->ClassName, $this->linkParameters());
    }

    /**
     * set new specific new quantity for buyable's orderitem.
     *
     * @param float
     *
     * @return string (Link)
     */
    public function SetSpecificQuantityItemLink($quantity)
    {
        return ShoppingCart_Controller::set_quantity_item_link($this->ID, $this->ClassName, array_merge($this->linkParameters(), array('quantity' => $quantity)));
    }

    /**
     * @return string
     */
    public function AddToCartAndGoToCheckoutLink()
    {
        $array = $this->linkParameters();
        $array['BackURL'] = urlencode(CheckoutPage::find_link());

        return ShoppingCart_Controller::add_item_link($this->ID, $this->ClassName, $array);
    }

    /**
     * Here you can add additional information to your product
     * links such as the AddLink and the RemoveLink.
     * One useful parameter you can add is the BackURL link.
     *
     * Usage would be by means of
     * 1. decorating product
     * 2. adding a updateLinkParameters method
     * 3. adding items to the array.
     *
     * You can also extend Product and override this method...
     *
     * @return array
     **/
    protected function linkParameters()
    {
        $array = array();
        $extendedArray = $this->extend('updateLinkParameters', $array, $type);
        if ($extendedArray !== null && is_array($extendedArray) && count($extendedArray)) {
            foreach ($extendedArray as $extendedArrayUpdate) {
                $array = array_merge($array, $extendedArrayUpdate);
            }
        }

        return $array;
    }

    //TEMPLATE STUFF

    /**
     * @return bool
     */
    public function IsInCart()
    {
        return ($this->OrderItem() && $this->OrderItem()->Quantity > 0) ? true : false;
    }

    /**
     * @return EcomQuantityField
     */
    public function EcomQuantityField()
    {
        $obj = new EcomQuantityField($this);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        return $obj;
    }

    /**
     * returns the instance of EcommerceConfigAjax for use in templates.
     * In templates, it is used like this:
     * $EcommerceConfigAjax.TableID.
     *
     * @return EcommerceConfigAjax

     **/
    public function AJAXDefinitions()
    {
        return EcommerceConfigAjax::get_one($this);
    }

    /**
     * @return EcommerceDBConfig
     **/
    public function EcomConfig()
    {
        return EcommerceDBConfig::current_ecommerce_db_config();
    }

    /**
     * Is it a variation?
     *
     * @return bool
     */
    public function IsProductVariation()
    {
        return true;
    }

    /**
     * returns the actual price worked out after discounts, currency conversions, etc...
     *
     * @casted
     *
     * @return float
     */
    public function CalculatedPrice()
    {
        return $this->getCalculatedPrice();
    }
    public function getCalculatedPrice()
    {
        $price = $this->Price;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $updatedPrice = $this->extend('updateCalculatedPrice', $price);
        if ($updatedPrice !== null && is_array($updatedPrice) && count($updatedPrice)) {
            $price = $updatedPrice[0];
        }

        return $price;
    }

    /**
     * How do we display the price?
     *
     * @return Money
     */
    public function CalculatedPriceAsMoney()
    {
        return $this->getCalculatedPriceAsMoney();
    }
    public function getCalculatedPriceAsMoney()
    {
        return EcommerceCurrency::get_money_object_from_order_currency($this->CalculatedPrice());
    }

    //CRUD SETTINGS

    /**
     * Is the product for sale?
     *
     * @return bool
     */
    public function canPurchase(Member $member = null, $checkPrice = true)
    {
        $config = $this->EcomConfig();
        if ($config->ShopClosed) {
            return false;
        }
        $allowpurchase = $this->AllowPurchase;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        if (!$allowpurchase) {
            return false;
        }
        if ($product = $this->Product()) {

            $allowpurchase = $product->canPurchase($member);
            if (!$allowpurchase) {
                return false;
            }
        }
        $price = $this->getCalculatedPrice();
        if ($price == 0 && !$config->AllowFreeProductPurchase) {
            return false;
        }
        $extended = $this->extendedCan('canPurchase', $member);
function notNullable(stdClass $x) { }

// Unsafe
function withoutCheck(stdClass $x = null) {
    notNullable($x);
}

// Safe - Alternative 1: Adding Additional Type-Check
function withCheck(stdClass $x = null) {
    if ($x instanceof stdClass) {
        notNullable($x);
    }
}

// Safe - Alternative 2: Changing Parameter
function withNonNullableParam(stdClass $x) {
    notNullable($x);
}
        if ($extended !== null) {
            $allowpurchase = $extended;
        }

        return $allowpurchase;
    }

    /**
     * standard SS Method
     * we explicitely set this to give access in the API.
     *
     * @return bool
     */
    public function canView($member = null)
    {
        if ($this->ProductID && $this->Product()->exists()) {
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
            return $this->Product()->canEdit($member);

        }

        return $this->canEdit($member);
    }

    /**
     * Shop Admins can edit.
     *
     * @return bool

     */
    public function canEdit($member = null)
    {
        if (!$member) {
            $member = Member::currentUser();
        }
        if ($member && $member->IsShopAdmin()) {
            return true;
        }

        return parent::canEdit($member);
    }

    /**
     * Standard SS method.
     *
     * @return bool

     */
    public function canDelete($member = null)

    {
        $extended = $this->extendedCan(__FUNCTION__, $member);
        if ($extended !== null) {
            return $extended;
        }

        return $this->canEdit($member);
    }

    /**
     * Standard SS method
     * //check if it is in a current cart?
     *
     * @return bool

     */
    public function canDeleteFromLive($member = null)

    {
        $extended = $this->extendedCan(__FUNCTION__, $member);
        if ($extended !== null) {
            return $extended;
        }

        return $this->canEdit($member);
    }

    /**
     * Standard SS method.
     *
     * @return bool

     */
    public function canCreate($member = null)

    {
        $extended = $this->extendedCan(__FUNCTION__, $member);
        if ($extended !== null) {
            return $extended;
        }

        return $this->canEdit($member);
    }

    /**
     * finds similar ("siblings") variations where one
     * attribute value is NOT the same.
     *
     * @return DataList
     */
    public function MostLikeMe()
    {
        $idArray = array();
        foreach ($this->AttributeValues() as $excludeValue) {

            unset($getAnyArray);
            $getAnyArray = array();
            foreach ($this->AttributeValues() as $innerValue) {

                if ($excludeValue->ID != $innerValue->ID) {
                    $getAnyArray[$innerValue->ID] = $innerValue->ID;
                }
                //find a product variation that has the getAnyArray Values
                $items = ProductVariation::get()
                    ->innerJoin(
                        'ProductVariation_AttributeValues',
                        '"ProductVariation"."ID" = "ProductVariationID"'
                    )
                    ->filter(
                        array(
                            'ProductAttributeValueID' => $getAnyArray,
                            'ProductID' => $this->ProductID
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                        )
                    )
                    ->exclude(array('ID' => $this->ID));
                if ($items->count()) {
                    $idArray = array_merge($idArray, $items->column('ID'));
                }
            }
        }

        return ProductVariation::get()->filter(array('ID' => $idArray));
    }
}

sunnysideup / silverstripe-ecommerce_product_variation

ProductVariation::getParent() A last analyzed 2018-07-12 04:11 UTC

Complexity

Size

Duplication

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like

ProductVariation::getParent() A
last analyzed 2018-07-12 04:11 UTC
