ElementVirtual::LinkedElementRelation() - Code Metrics - Inspection of "Make ElementVirtual work with TagField & inline" - dnadesign/silverstripe-elemental-virtual - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#49)

unknown

created 2021-12-16 06:48 UTC

ElementVirtual::LinkedElementRelation() A

↳ Parent: ElementVirtual

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	6
c	1
b	0
f	0
dl	0
loc	9
rs	10
cc	1
nc	1
nop	0

<?php

namespace DNADesign\ElementalVirtual\Model;

use TractorCow\AutoComplete\AutoCompleteField;
use SilverStripe\ElementalVirtual\Forms\ElementalGridFieldAddExistingAutocompleter;
filter:
    dependency_paths: ["lib/*"]
use DNADesign\Elemental\Models\BaseElement;
use SilverStripe\Forms\FieldList;
use SilverStripe\Forms\LiteralField;
use SilverStripe\Forms\Tab;
use SilverStripe\Forms\TabSet;
use SilverStripe\ORM\FieldType\DBField;
use SilverStripe\ORM\FieldType\DBHTMLText;

/**
 * Virtual Linked Element.
 *
 * As elemental is based on a natural has_one relation to an object,
 * this allows the same element to be linked to multiple pages.
 *
 * {@see ElementalGridFieldAddExistingAutocompleter}
 */
class ElementVirtual extends BaseElement
{
    private static $icon = 'font-icon-block-link';


    private static $has_one = [

        'LinkedElement' => BaseElement::class
    ];

    /**
     * @var string
     */
    private static $description = 'Reused element';


    private static $table_name = 'ElementVirtual';


    private static $singular_name = 'virtual block';

    
    private static $inline_editable = true;


    /**
     * @param BaseElement
     * @param boolean $isSingleton
     * @param DataModel $model
filter:
    dependency_paths: ["lib/*"]
     */
    public function __construct($record = null, $isSingleton = false, $model = null)
    {
        parent::__construct($record, $isSingleton, $model);
        parent::__construct($record, $isSingleton, /** @scrutinizer ignore-type */ $model);

        $this->LinkedElement()->setVirtualOwner($this);
               LinkedElement()->setVirtualOwner($this);
    }

    public function getCMSFields()
    {
        $invalid = $this->isInvalidPublishState();

        $this->beforeUpdateCMSFields(function (FieldList $fields) use ($invalid) {
            $fields->removeByName('Title');

            if ($invalid) {
                $warning = _t(
                    __CLASS__ . '.InvalidPublishStateWarning',
                    'Error: The original element is not published. This element will not work on the live site until you click the link below and publish it.'
                );

                $fields->addFieldToTab('Root.Main', LiteralField::create('WarningHeader', '<p class="message error">' . $warning . '</p>'));
            }

            $availableBlocks = BaseElement::get()->filter('AvailableGlobally', 1)->exclude('ClassName', get_class($this));
            $fields->replaceField(
                'LinkedElementID',
                TagField::create("LinkedElementRelation", $this->fieldLabel('LinkedElement'), $availableBlocks)
filter:
    dependency_paths: ["lib/*"]
                    // Bug: TagField (react) setIsMultiple results in empty (https://github.com/silverstripe/silverstripe-tagfield/issues/195)
    //                ->setIsMultiple(false)
                    ->setCanCreate(false)
            );
            
            if($this->LinkedElementID){
                $message = sprintf(
                    '<p>%s</p><p><a href="%2$s" target="_blank">Click here to edit the original</a></p>',
                    _t(__CLASS__ . '.VirtualDescription', 'This is a virtual copy of an element.'),
                    $this->LinkedElement()->getEditLink()
                );
                $fields->addFieldToTab('Root.Main', LiteralField::create('Existing', $message));
            }
        });

        return parent::getCMSFields();
    }

    /**
     * Create an intermediary UnsavedRelationList to have TagField save the LinkedElement into
     * @return UnsavedRelationList
     */
    public function LinkedElementRelation()
    {
        $this->LinkedElementRelation = UnsavedRelationList::create(
filter:
    dependency_paths: ["lib/*"]
            get_class($this),
            'LinkedElementRelation',
            BaseElement::class
        );
        $this->LinkedElementRelation->add($this->LinkedElementID);
        return $this->LinkedElementRelation;
    }

    /**
     * Transfer LinkedElement from UnsavedRelationList to has_one LinkedElementID
     */
    public function onBeforeWrite()
    {
        if($this->LinkedElementRelation && $this->LinkedElementRelation->first()){
            $this->LinkedElementID = $this->LinkedElementRelation->first()->ID;

        }
        
        return parent::onBeforeWrite();
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
    }

    /**
     * @return string
     */
    public function getType()
    {
        return sprintf(
            _t(__CLASS__ . '.BlockType', 'Virtual Block')
        );
    }

    /**
     * Detect when a user has published a linked element but has not published
     * the LinkedElement.
     *
     * @return boolean
     */
    public function isInvalidPublishState()
    {
        $element = $this->LinkedElement();

        return (!$element->isPublished() && $this->isPublished());
        return (!$element->isPublished() && $this->/** @scrutinizer ignore-call */ isPublished());
    }

    /**
     * Get a unique anchor name.
     *
     * @return string
     */
    public function getAnchor()
    {
        $linkedElement = $this->LinkedElement();

        if ($linkedElement && $linkedElement->exists()) {
            return $linkedElement->getAnchor();
        }

        return 'e' . $this->ID;
    }

    /**
     * @return string
     */
    public function getSummary()
    {
        if ($linked = $this->LinkedElement()) {
            return $linked->getSummary();
        }
    }

    /**
     * @return string
     */
    public function getTitle()
    {
        if ($linked = $this->LinkedElement()) {
            return $linked->Title;
        }
    }

    /**
     * Override to render template based on LinkedElement
     *
     * @return string|null HTML
     */
    public function forTemplate($holder = true)
    {
        if ($linked = $this->LinkedElement()) {
            return $linked->forTemplate($holder);
        }
        return null;
    }

    protected function provideBlockSchema()
    {
        $blockSchema = parent::provideBlockSchema();
        $blockSchema['content'] = $this->getSummary();
        return $blockSchema;
    }
}


dnadesign / silverstripe-elemental-virtual

Pull Request — master (#49)

ElementVirtual::LinkedElementRelation() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like