ElementVirtualLinked_Controller

Complexity

Total Complexity

11

Size/Duplication

Total Lines	68
Duplicated Lines	35.29 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	2
A	WidgetHolder()	0	4	1
A	__call()	0	10	2
A	hasMethod()	8	9	2
A	hasAction()	8	9	2
A	checkAccessAction()	8	9	2

<?php

/**
 * Virtual Linked Element.
 *
 * As elemental is based on widgets which have a natural has_one relation to an
 * object, this is a workaround for allowing the same element to be linked to
 * multiple pages.
 *
 * {@see ElementalGridFieldAddExistingAutocompleter}
 *
 * @package elemental
 */
class ElementVirtualLinked extends BaseElement

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

{
    /**
     * @var string
     */
    private static $title = 'Virtual linked Block';

Consider using a different property name as you override a private property of the parent class.

The property $title is not used and could be removed.

    /**
     * @var string
     */
    private static $singular_name = 'Virtual linked Block';

Consider using a different property name as you override a private property of the parent class.

The property $singular_name is not used and could be removed.

    private static $has_one = array(

Consider using a different property name as you override a private property of the parent class.

The property $has_one is not used and could be removed.

        'LinkedElement' => 'BaseElement'
    );

    public function getTitle()

The return type could not be reliably inferred; please add a @return annotation.

    {
        return $this->LinkedElement()->getTitle();

The method LinkedElement() does not exist on ElementVirtualLinked. Did you maybe mean getVirtualLinkedElements()?

    }

    public function i18n_singular_name()
    {
        return _t(__CLASS__, $this->LinkedElement()->config()->title);

The method LinkedElement() does not exist on ElementVirtualLinked. Did you maybe mean getVirtualLinkedElements()?

    }

    public function __construct($record = null, $isSingleton = false, $model = null)
    {
        parent::__construct($record, $isSingleton, $model);
        $this->LinkedElement()->setVirtualOwner($this);

The method LinkedElement() does not exist on ElementVirtualLinked. Did you maybe mean getVirtualLinkedElements()?

    }

    public function getCMSFields()

The return type could not be reliably inferred; please add a @return annotation.

    {
        $message = sprintf(
            '<p>%s</p><p><a href="%2$s">%2$s</a></p>',
            _t('ElementVirtualLinked.DESCRIBE', 'This is a virtual copy of a block. To edit, visit'),
            $this->LinkedElement()->getEditLink()

The method LinkedElement() does not exist on ElementVirtualLinked. Did you maybe mean getVirtualLinkedElements()?

        );

        $fields = new FieldList(
            new TabSet('Root', $main = new Tab('Main'))
        );

        if ($this->isInvalidPublishState()) {
            $warning = 'Error: The original block is not published. This block will not work on the live site until you click the link below and publish it.';
            $main->push(new LiteralField('WarningHeader', '<p class="message error">' .$warning. '</p>'));
        }
        $main->push(new LiteralField('Existing', $message));

        $this->extend('updateCMSFields', $fields);

        return $fields;
    }


    /**
     * Detect when a user has published a ElementVirtualLinked block
     * but has not published the LinkedElement block.
     */
    public function isInvalidPublishState()
    {
        $block = $this->LinkedElement();

The method LinkedElement() does not exist on ElementVirtualLinked. Did you maybe mean getVirtualLinkedElements()?

        return (!$block->isPublished() && $this->isPublished());

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

    }

    public function getCMSPublishedState()

The return type could not be reliably inferred; please add a @return annotation.

    {
        if ($this->isInvalidPublishState()) {
            $colour = '#C00';
            $text = 'Error';
            $html = new HTMLText('PublishedState');
            $html->setValue(sprintf(
                '<span style="color: %s;">%s</span>',
                $colour,
                htmlentities($text)
            ));
            return $html;
        }

        $publishedState = null;
        foreach ($this->extension_instances as $instance) {
            if (method_exists($instance, 'getCMSPublishedState')) {
                $instance->setOwner($this);
                $publishedState = $instance->getCMSPublishedState();
                $instance->clearOwner();
                break;
            }
        }
        return $publishedState;
    }
}

class ElementVirtualLinked_Controller extends BaseElement_Controller

PSR1 recommends that each class should be in its own file to aid autoloaders.

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

{

    protected $controllerClass;

    public function __construct($widget)
    {
        parent::__construct($widget);

        $controllerClass = get_class($this->LinkedElement()) . '_Controller';

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

        if (class_exists($controllerClass)) {
            $this->controllerClass = $controllerClass;
        } else {
            $this->controllerClass = 'BaseElement_Controller';
        }
    }

    /**
     * Returns the current widget in scope rendered into its' holder
     *
     * @return HTML

Should the return type not be HTMLText?

     */
    public function WidgetHolder()
    {
        return $this->renderWith("ElementHolder_VirtualLinked");
    }

    public function __call($method, $arguments)
    {
        try {
            $retVal = parent::__call($method, $arguments);
        } catch (Exception $e) {
            $controller = new $this->controllerClass($this->LinkedElement());

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

            $retVal = call_user_func_array(array($controller, $method), $arguments);
        }
        return $retVal;
    }

    public function hasMethod($action)

The return type could not be reliably inferred; please add a @return annotation.

This method seems to be duplicated in your project.

    {
        if (parent::hasMethod($action)) {
            return true;
        }

        $controller = new $this->controllerClass($this->LinkedElement());

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

        return $controller->hasMethod($action);
    }

    public function hasAction($action)

The return type could not be reliably inferred; please add a @return annotation.

This method seems to be duplicated in your project.

    {
        if (parent::hasAction($action)) {
            return true;
        }

        $controller = new $this->controllerClass($this->LinkedElement());

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

        return $controller->hasAction($action);
    }

    public function checkAccessAction($action)

The return type could not be reliably inferred; please add a @return annotation.

This method seems to be duplicated in your project.

    {
        if (parent::checkAccessAction($action)) {
            return true;
        }

        $controller = new $this->controllerClass($this->LinkedElement());

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

        return $controller->checkAccessAction($action);
    }
}