SilverStripe\ORM\Versioning\ChangeSet

Complexity

Total Complexity

63

Size/Duplication

Total Lines	549
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	15

Importance

Changes	1
Bugs	0	Features	0

19 Methods

Rating	Name	Duplication	Size	Complexity
B	publish()	0	37	6
B	addObject()	0	31	4
A	removeObject()	0	16	2
A	implicitKey()	0	7	2
B	calculateImplicit()	0	46	5
B	sync()	0	35	4
A	isSynced()	0	20	3
A	canView()	0	4	1
A	canEdit()	0	4	1
A	canCreate()	0	4	1
A	canDelete()	0	4	1
A	canPublish()	0	10	3
A	hasChanges()	0	11	3
A	canRevert()	0	13	3
A	can()	0	16	3
A	getCMSFields()	0	15	3
F	getDescription()	0	108	16
A	getChangesCount()	0	4	1
A	fieldLabels()	0	8	1

<?php

namespace SilverStripe\ORM\Versioning;

use SilverStripe\Forms\FieldList;
use SilverStripe\Forms\TabSet;
use SilverStripe\Forms\TextField;
use SilverStripe\Forms\ReadonlyField;
use SilverStripe\i18n\i18n;
use SilverStripe\ORM\HasManyList;
use SilverStripe\ORM\ValidationException;
use SilverStripe\ORM\DB;
use SilverStripe\ORM\DataObject;
use SilverStripe\ORM\UnexpectedDataException;
use SilverStripe\Security\Member;
use SilverStripe\Security\Permission;
use BadMethodCallException;
use Exception;
use LogicException;

/**
 * The ChangeSet model tracks several VersionedAndStaged objects for later publication as a single
 * atomic action
 *
 * @method HasManyList Changes()
 * @method Member Owner()
 * @property string $Name
 * @property string $State
 * @property bool $IsInferred
 */
class ChangeSet extends DataObject
{

    private static $singular_name = 'Campaign';

    private static $plural_name = 'Campaigns';

    /** An active changeset */
    const STATE_OPEN = 'open';

    /** A changeset which is reverted and closed */
    const STATE_REVERTED = 'reverted';

    /** A changeset which is published and closed */
    const STATE_PUBLISHED = 'published';

    private static $table_name = 'ChangeSet';

    private static $db = array(
        'Name'  => 'Varchar',
        'State' => "Enum('open,published,reverted','open')",
        'IsInferred' => 'Boolean(0)' // True if created automatically
    );

    private static $has_many = array(
        'Changes' => 'SilverStripe\ORM\Versioning\ChangeSetItem',
    );

    private static $defaults = array(
        'State' => 'open'
    );

    private static $has_one = array(
        'Owner' => 'SilverStripe\\Security\\Member',
    );

    private static $casting = array(
        'Description' => 'Text',
    );

    /**
     * List of classes to set apart in description
     *
     * @config
     * @var array
     */
    private static $important_classes = array(
        'SilverStripe\\CMS\\Model\\SiteTree',
        'SilverStripe\\Assets\\File',
    );

    private static $summary_fields = [
        'Name' => 'Title',
        'ChangesCount' => 'Changes',
        'Description' => 'Description',
    ];

    /**
     * Default permission to require for publishers.
     * Publishers must either be able to use the campaign admin, or have all admin access.
     *
     * Also used as default permission for ChangeSetItem default permission.
     *
     * @config
     * @var array
     */
    private static $required_permission = array('CMS_ACCESS_CampaignAdmin', 'CMS_ACCESS_LeftAndMain');

    /**
     * Publish this changeset, then closes it.
     *
     * @throws Exception
     * @return bool True if successful
     */
    public function publish()
    {
        // Logical checks prior to publish
        if ($this->State !== static::STATE_OPEN) {
            throw new BadMethodCallException(
                "ChangeSet can't be published if it has been already published or reverted."
            );
        }
        if (!$this->isSynced()) {
            throw new ValidationException(
                "ChangeSet does not include all necessary changes and cannot be published."
            );
        }
        if (!$this->canPublish()) {
            throw new LogicException("The current member does not have permission to publish this ChangeSet.");
        }

        DB::get_conn()->withTransaction(function () {
            foreach ($this->Changes() as $change) {
                /** @var ChangeSetItem $change */
                $change->publish();
            }

            // Once this changeset is published, unlink any objects linking to
            // records in this changeset as unlinked (set RelationID to 0).
            // This is done as a safer alternative to deleting records on live that
            // are deleted on stage.
            foreach ($this->Changes() as $change) {
                /** @var ChangeSetItem $change */
                $change->unlinkDisownedObjects();
            }

            $this->State = static::STATE_PUBLISHED;
            $this->write();
        });
        return true;
    }

    /**
     * Add a new change to this changeset. Will automatically include all owned
     * changes as those are dependencies of this item.
     *
     * @param DataObject $object
     */
    public function addObject(DataObject $object)
    {
        if (!$this->isInDB()) {
            throw new BadMethodCallException("ChangeSet must be saved before adding items");
        }

        if (!$object->isInDB()) {
            throw new BadMethodCallException("Items must be saved before adding to a changeset");
        }

        $references = [
            'ObjectID'    => $object->ID,
            'ObjectClass' => $object->baseClass(),
        ];

        // Get existing item in case already added
        $item = $this->Changes()->filter($references)->first();

        if (!$item) {
            $item = new ChangeSetItem($references);
            $this->Changes()->add($item);
        }

        $item->ReferencedBy()->removeAll();

        $item->Added = ChangeSetItem::EXPLICITLY;

The property Added does not exist on object<SilverStripe\ORM\DataObject>. Since you implemented __set, maybe consider adding a @property annotation.

        $item->write();


        $this->sync();
    }

    /**
     * Remove an item from this changeset. Will automatically remove all changes
     * which own (and thus depend on) the removed item.
     *
     * @param DataObject $object
     */
    public function removeObject(DataObject $object)
    {
        $item = ChangeSetItem::get()->filter([
                'ObjectID' => $object->ID,
                'ObjectClass' => $object->baseClass(),
                'ChangeSetID' => $this->ID
            ])->first();

        if ($item) {
            // TODO: Handle case of implicit added item being removed.

            $item->delete();
        }

        $this->sync();
    }

    /**
     * Build identifying string key for this object
     *
     * @param DataObject $item
     * @return string
     */
    protected function implicitKey(DataObject $item)
    {
        if ($item instanceof ChangeSetItem) {
            return $item->ObjectClass.'.'.$item->ObjectID;
        }
        return $item->baseClass().'.'.$item->ID;
    }

    protected function calculateImplicit()
    {
        /** @var string[][] $explicit List of all items that have been explicitly added to this ChangeSet */
        $explicit = array();

        /** @var string[][] $referenced List of all items that are "referenced" by items in $explicit */
        $referenced = array();

        /** @var string[][] $references List of which explicit items reference each thing in referenced */
        $references = array();

        /** @var ChangeSetItem $item */
        foreach ($this->Changes()->filter(['Added' => ChangeSetItem::EXPLICITLY]) as $item) {
            $explicitKey = $this->implicitKey($item);
            $explicit[$explicitKey] = true;

            foreach ($item->findReferenced() as $referee) {
                try {
                    /** @var DataObject $referee */
                    $key = $this->implicitKey($referee);

                    $referenced[$key] = [
                        'ObjectID' => $referee->ID,
                        'ObjectClass' => $referee->baseClass(),
                    ];

                    $references[$key][] = $item->ID;

                // Skip any bad records
                } catch (UnexpectedDataException $e) {
                }
            }
        }

        /** @var string[][] $explicit List of all items that are either in $explicit, $referenced or both */
        $all = array_merge($referenced, $explicit);

        /** @var string[][] $implicit Anything that is in $all, but not in $explicit, is an implicit inclusion */
        $implicit = array_diff_key($all, $explicit);

        foreach ($implicit as $key => $object) {
            $implicit[$key]['ReferencedBy'] = $references[$key];
        }

        return $implicit;
    }

    /**
     * Add implicit changes that should be included in this changeset
     *
     * When an item is created or changed, all it's owned items which have
     * changes are implicitly added
     *
     * When an item is deleted, it's owner (even if that owner does not have changes)
     * is implicitly added
     */
    public function sync()
    {
        // Start a transaction (if we can)
        DB::get_conn()->withTransaction(function () {

            // Get the implicitly included items for this ChangeSet
            $implicit = $this->calculateImplicit();

            // Adjust the existing implicit ChangeSetItems for this ChangeSet
            /** @var ChangeSetItem $item */
            foreach ($this->Changes()->filter(['Added' => ChangeSetItem::IMPLICITLY]) as $item) {
                $objectKey = $this->implicitKey($item);

                // If a ChangeSetItem exists, but isn't in $implicit, it's no longer required, so delete it
                if (!array_key_exists($objectKey, $implicit)) {
                    $item->delete();
                } // Otherwise it is required, so update ReferencedBy and remove from $implicit
                else {
                    $item->ReferencedBy()->setByIDList($implicit[$objectKey]['ReferencedBy']);
                    unset($implicit[$objectKey]);
                }
            }

            // Now $implicit is all those items that are implicitly included, but don't currently have a ChangeSetItem.
            // So create new ChangeSetItems to match

            foreach ($implicit as $key => $props) {
                $item = new ChangeSetItem($props);
                $item->Added = ChangeSetItem::IMPLICITLY;
                $item->ChangeSetID = $this->ID;

The property ChangeSetID does not exist on object<SilverStripe\ORM\Versioning\ChangeSetItem>. Since you implemented __set, maybe consider adding a @property annotation.

                $item->ReferencedBy()->setByIDList($props['ReferencedBy']);
                $item->write();
            }
        });
    }

    /** Verify that any objects in this changeset include all owned changes */
    public function isSynced()
    {
        $implicit = $this->calculateImplicit();

        // Check the existing implicit ChangeSetItems for this ChangeSet

        foreach ($this->Changes()->filter(['Added' => ChangeSetItem::IMPLICITLY]) as $item) {
            $objectKey = $this->implicitKey($item);

            // If a ChangeSetItem exists, but isn't in $implicit -> validation failure
            if (!array_key_exists($objectKey, $implicit)) {
                return false;
            }
            // Exists, remove from $implicit
            unset($implicit[$objectKey]);
        }

        // If there's anything left in $implicit -> validation failure
        return empty($implicit);
    }

    public function canView($member = null)
    {
        return $this->can(__FUNCTION__, $member);
    }

    public function canEdit($member = null)
    {
        return $this->can(__FUNCTION__, $member);
    }

    public function canCreate($member = null, $context = array())
    {
        return $this->can(__FUNCTION__, $member, $context);
    }

    public function canDelete($member = null)
    {
        return $this->can(__FUNCTION__, $member);
    }

    /**
     * Check if this item is allowed to be published
     *
     * @param Member $member
     * @return bool
     */
    public function canPublish($member = null)
    {
        foreach ($this->Changes() as $change) {
            /** @var ChangeSetItem $change */
            if (!$change->canPublish($member)) {
                return false;
            }
        }
        return true;
    }

    /**
     * Determine if there are changes to publish
     *
     * @return bool
     */
    public function hasChanges()
    {
        // All changes must be publishable
        /** @var ChangeSetItem $change */
        foreach ($this->Changes() as $change) {
            if ($change->hasChange()) {
                return true;
            }
        }
        return false;
    }

    /**
     * Check if this changeset (if published) can be reverted
     *
     * @param Member $member
     * @return bool
     */
    public function canRevert($member = null)
    {
        // All changes must be publishable
        foreach ($this->Changes() as $change) {
            /** @var ChangeSetItem $change */
            if (!$change->canRevert($member)) {

It seems like $member defined by parameter $member on line 392 can be null; however, SilverStripe\ORM\Versioning\ChangeSetItem::canRevert() does not accept null, maybe add an additional type check?

                return false;
            }
        }

        // Default permission
        return $this->can(__FUNCTION__, $member);
    }

    /**
     * Default permissions for this changeset
     *
     * @param string $perm
     * @param Member $member
     * @param array $context
     * @return bool
     */
    public function can($perm, $member = null, $context = array())
    {
        if (!$member) {
            $member = Member::currentUser();
        }

        // Allow extensions to bypass default permissions, but only if
        // each change can be individually published.
        $extended = $this->extendedCan($perm, $member, $context);

It seems like $member can be null; however, extendedCan() does not accept null, maybe add an additional type check?

        if ($extended !== null) {
            return $extended;
        }

        // Default permissions
        return (bool)Permission::checkMember($member, $this->config()->required_permission);
    }

    public function getCMSFields()
    {
        $fields = new FieldList(new TabSet('Root'));
        if ($this->IsInferred) {
            $fields->addFieldToTab('Root.Main', ReadonlyField::create('Name', $this->fieldLabel('Name')));
        } else {
            $fields->addFieldToTab('Root.Main', TextField::create('Name', $this->fieldLabel('Name')));
        }
        if ($this->isInDB()) {
            $fields->addFieldToTab('Root.Main', ReadonlyField::create('State', $this->fieldLabel('State')));
        }

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

    /**
     * Gets summary of items in changeset
     *
     * @return string
     */
    public function getDescription()
    {
        // Initialise list of items to count
        $counted = [];
        $countedOther = 0;
        foreach ($this->config()->important_classes as $type) {
            if (class_exists($type)) {
                $counted[$type] = 0;
            }
        }

        // Check each change item
        /** @var ChangeSetItem $change */
        foreach ($this->Changes() as $change) {
            $found = false;
            foreach ($counted as $class => $num) {
                if (is_a($change->ObjectClass, $class, true)) {
                    $counted[$class]++;
                    $found = true;
                    break;
                }
            }
            if (!$found) {
                $countedOther++;
            }
        }

        // Describe set based on this output
        $counted = array_filter($counted);

        // Empty state
        if (empty($counted) && empty($countedOther)) {
            return '';
        }

        // Put all parts together
        $parts = [];
        foreach ($counted as $class => $count) {
            $parts[] = DataObject::singleton($class)->i18n_pluralise($count);
        }

        // Describe non-important items
        if ($countedOther) {
            if ($counted) {

The expression $counted of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

                $parts[] = i18n::pluralise(
                    _t('ChangeSet.DESCRIPTION_OTHER_ITEM', 'other item'),
                    _t('ChangeSet.DESCRIPTION_OTHER_ITEMS', 'other items'),
                    $countedOther
                );
            } else {
                $parts[] = i18n::pluralise(
                    _t('ChangeSet.DESCRIPTION_ITEM', 'item'),
                    _t('ChangeSet.DESCRIPTION_ITEMS', 'items'),
                    $countedOther
                );
            }
        }

        // Figure out how to join everything together
        if (empty($parts)) {
            return '';
        }
        if (count($parts) === 1) {
            return $parts[0];
        }

        // Non-comma list
        if (count($parts) === 2) {
            return _t(
                'ChangeSet.DESCRIPTION_AND',
                '{first} and {second}',
                [
                    'first' => $parts[0],
                    'second' => $parts[1],
                ]
            );
        }

        // First item
        $string = _t(
            'ChangeSet.DESCRIPTION_LIST_FIRST',
            '{item}',
            ['item' => $parts[0]]
        );

        // Middle items
        for ($i = 1; $i < count($parts) - 1; $i++) {
            $string = _t(
                'ChangeSet.DESCRIPTION_LIST_MID',
                '{list}, {item}',
                [
                    'list' => $string,
                    'item' => $parts[$i]
                ]
            );
        }

        // Oxford comma
        $string = _t(
            'ChangeSet.DESCRIPTION_LIST_LAST',
            '{list}, and {item}',
            [
                'list' => $string,
                'item' => end($parts)
            ]
        );
        return $string;
    }

    /**
     * Required to support count display in react gridfield column
     *
     * @return int
     */
    public function getChangesCount()
    {
        return $this->Changes()->count();
    }

    public function fieldLabels($includerelations = true)
    {
        $labels = parent::fieldLabels($includerelations);
        $labels['Name'] = _t('ChangeSet.NAME', 'Name');
        $labels['State'] = _t('ChangeSet.STATE', 'State');

        return $labels;
    }
}