WorkflowInstance::userHasAccess() - Code Metrics - Inspection of "Converted to PSR-2" - silverstripe-australia/advancedworkflow - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#230)

by Helpful
created 2015-12-17 10:16 UTC
WorkflowInstance::userHasAccess() D

↳ Parent: WorkflowInstance
Complexity

Conditions	9
Paths	15
Size

Total Lines	25
Code Lines	13
Duplication

Lines	0
Ratio	0 %
Metric	Value
dl	0
loc	25
rs	4.9091
cc	9
eloc	13
nc	15
nop	1
<?php
/**
 * A WorkflowInstance is created whenever a user 'starts' a workflow.
 *
 * This 'start' is triggered automatically when the user clicks the relevant
 * button (eg 'apply for approval'). This creates a standalone object
 * that maintains the state of the workflow process.
 *
 * @method WorkflowDefinition Definition()
 * @method WorkflowActionInstance CurrentAction()
 * @method Member Initiator()
 *
 * @author  [email protected]
 * @license BSD License (http://silverstripe.org/bsd-license/)
 * @package advancedworkflow
 */
class WorkflowInstance extends DataObject
namespace YourVendor;

class YourClass { }
{

    private static $db = array(

        'Title'                => 'Varchar(128)',
        'WorkflowStatus'    => "Enum('Active,Paused,Complete,Cancelled','Active')",
        'TargetClass'        => 'Varchar(64)',
        'TargetID'            => 'Int',
    );

    private static $has_one = array(

        'Definition'    => 'WorkflowDefinition',
        'CurrentAction' => 'WorkflowActionInstance',
        'Initiator'        => 'Member',
    );

    private static $has_many = array(

        'Actions'        => 'WorkflowActionInstance',
    );

    /**
     * The list of users who are responsible for performing the current WorkflowAction
     *
     * @var array
     */
    private static $many_many = array(

        'Users'            => 'Member',
        'Groups'        => 'Group'
    );

    private static $summary_fields = array(

        'Title',
        'WorkflowStatus',
        'Created'
    );

    /**
     * Get the CMS view of the instance. This is used to display the log of
     * this workflow, and options to reassign if the workflow hasn't been
     * finished yet
     *
     * @return \FieldList
     */
    public function getCMSFields()
    {
        $fields = new FieldList();

        if (Permission::check('REASSIGN_ACTIVE_WORKFLOWS')) {
            if ($this->WorkflowStatus == 'Paused' || $this->WorkflowStatus == 'Active') {
<?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.");
        }
    }

}
                $cmsUsers = Member::mapInCMSGroups();

                $fields->push(new HiddenField('DirectUpdate', '', 1));

                $fields->push(new HeaderField('InstanceReassignHeader', _t('WorkflowInstance.REASSIGN_HEADER', 'Reassign workflow')));
                $fields->push(new CheckboxSetField('Users', _t('WorkflowDefinition.USERS', 'Users'), $cmsUsers));
                $fields->push(new TreeMultiselectField('Groups', _t('WorkflowDefinition.GROUPS', 'Groups'), 'Group'));
            }
        }

        if ($this->canEdit()) {
            $action = $this->CurrentAction();
            if ($action->exists()) {
                $actionFields = $this->getWorkflowFields();
                $fields->merge($actionFields);

                $transitions = $action->getValidTransitions();
                if ($transitions) {
                    $fields->replaceField('TransitionID', DropdownField::create("TransitionID", "Next action", $transitions->map()));
                }
            }
        }

        $items = WorkflowActionInstance::get()->filter(array(
            'Finished'        => 1,
            'WorkflowID'    => $this->ID
        ));

        $grid = new GridField(
            'Actions',
            _t('WorkflowInstance.ActionLogTitle', 'Log'),
            $items
        );

        $fields->push($grid);

        return $fields;
    }

    public function fieldLabels($includerelations = true)
    {
        $labels = parent::fieldLabels($includerelations);
        $labels['Title'] = _t('WorkflowInstance.TitleLabel', 'Title');
        $labels['WorkflowStatus'] = _t('WorkflowInstance.WorkflowStatusLabel', 'Workflow Status');
        $labels['TargetClass'] = _t('WorkflowInstance.TargetClassLabel', 'Target Class');
        $labels['TargetID'] = _t('WorkflowInstance.TargetIDLabel', 'Target');

        return $labels;
    }

    /**
     * See if we've been saved in context of managing the workflow directly
     */
    public function onBeforeWrite()
    {
        parent::onBeforeWrite();

        $vars = $this->record;

        if (isset($vars['DirectUpdate'])) {
            // Unset now so that we don't end up in an infinite loop!
            unset($this->record['DirectUpdate']);
            $this->updateWorkflow($vars);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

    /**
     * Update the current state of the workflow
     *
     * Typically, this is triggered by someone modifiying the workflow instance via the modeladmin form
     * side of things when administering things, such as re-assigning or manually approving a stuck workflow
     *
     * Note that this is VERY similar to AdvancedWorkflowExtension::updateworkflow
     * but without the formy bits. These two implementations should PROBABLY
     * be merged
     *
     * @todo refactor with AdvancedWorkflowExtension
     *
     * @param type $data
     * @return
     */
    public function updateWorkflow($data)
    {
        $action = $this->CurrentAction();

        if (!$this->getTarget() || !$this->getTarget()->canEditWorkflow()) {
            return;
        }

        $allowedFields = $this->getWorkflowFields()->saveableFields();
        unset($allowedFields['TransitionID']);
        foreach ($allowedFields as $field) {
            $fieldName = $field->getName();
            $action->$fieldName = $data[$fieldName];
        }
        $action->write();

        $svc = singleton('WorkflowService');
        if (isset($data['TransitionID']) && $data['TransitionID']) {
            $svc->executeTransition($this->getTarget(), $data['TransitionID']);
        } else {
            // otherwise, just try to execute the current workflow to see if it
            // can now proceed based on user input
            $this->execute();
        }
    }

    /**
     * Get the target-object that this WorkflowInstance "points" to.
     *
     * Workflows are not restricted to being active on SiteTree objects,
     * so we need to account for being attached to anything.
     *
     * Sets Versioned::set_reading_mode() to allow fetching of Draft _and_ Published
     * content.
     *
     * @return (null | DataObject)

     */
    public function getTarget()
    {
        if ($this->TargetID && $this->TargetClass) {
<?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.");
        }
    }

}
            $versionable = Injector::inst()->get($this->TargetClass)->has_extension('Versioned');
<?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 ($versionable) {
                Versioned::set_reading_mode("Stage.Stage");
            }

            // Default
            return DataObject::get_by_id($this->TargetClass, $this->TargetID);
<?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.");
        }
    }

}
        }
    }

    /**
     *
     * @see {@link {$this->getTarget()}
     * @return (null | DataObject)

     */
    public function Target()
    {
        return $this->getTarget();
    }

    /**
     * Start a workflow based on a particular definition for a particular object.
     *
     * The object is optional; if not specified, it is assumed that this workflow
     * is simply a task based checklist type of workflow.
     *
     * @param WorkflowDefinition $definition
     * @param DataObject $for
     */
    public function beginWorkflow(WorkflowDefinition $definition, DataObject $for=null)
    {
        if (!$this->ID) {
            $this->write();
        }

        if ($for && ($for->hasExtension('WorkflowApplicable') || $for->hasExtension('FileWorkflowApplicable'))) {
            $this->TargetClass = ClassInfo::baseDataClass($for);
<?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->TargetID = $for->ID;
<?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.");
        }
    }

}
        }

        // lets create the first WorkflowActionInstance.
        $action = $definition->getInitialAction()->getInstanceForWorkflow();
        $action->WorkflowID   = $this->ID;
<?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.");
        }
    }

}
        $action->write();

        $title = $for && $for->hasField('Title') ?
                sprintf(_t('WorkflowInstance.TITLE_FOR_DO', '%s - %s'), $definition->Title, $for->Title) :
<?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.");
        }
    }

}
                sprintf(_t('WorkflowInstance.TITLE_STUB', 'Instance #%s of %s'), $this->ID, $definition->Title);
<?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->Title           = $title;
<?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->DefinitionID    = $definition->ID;
<?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->CurrentActionID = $action->ID;
<?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->InitiatorID     = Member::currentUserID();
<?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->write();

        $this->Users()->addMany($definition->Users());
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 { }
        $this->Groups()->addMany($definition->Groups());
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 { }
    }

    /**
     * Execute this workflow. In rare cases this will actually execute all actions,
     * but typically, it will stop and wait for the user to input something
     *
     * The basic process is to get the current action, and see whether it has been finished
     * by some process, if not it attempts to execute it.
     *
     * If it has been finished, we check to see if there's some transitions to follow. If there's
     * only one transition, then we execute that immediately.
     *
     * If there's multiple transitions, we just stop and wait for the user to manually
     * trigger a transition.
     *
     * If there's no transitions, we make the assumption that we've finished the workflow and
     * mark it as such.
     *
     *
     */
    public function execute()
    {
        if (!$this->CurrentActionID) {
<?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.");
        }
    }

}
            throw new Exception(
                sprintf(_t('WorkflowInstance.EXECUTE_EXCEPTION', 'Attempted to start an invalid workflow instance #%s!'), $this->ID)
            );
        }

        $action     = $this->CurrentAction();
        $transition = false;

        // if the action has already finished, it means it has either multiple (or no
        // transitions at the time), so a subsequent check should be run.
        if ($action->Finished) {
<?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.");
        }
    }

}
            $transition = $this->checkTransitions($action);
        } else {
            $result = $action->BaseAction()->execute($this);
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 the action was successful, then the action has finished running and
            // next transition should be run (if only one).
            // input.
            if ($result) {
                $action->MemberID = Member::currentUserID();
<?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.");
        }
    }

}
                $action->Finished = true;
<?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.");
        }
    }

}
                $action->write();
                $transition = $this->checkTransitions($action);
            }
        }

        // if the action finished, and there's only one available transition then
        // move onto that step - otherwise check if the workflow has finished.
        if ($transition) {
            $this->performTransition($transition);
        } else {
            // see if there are any transitions available, even if they are not valid.
            if ($action->Finished && !count($action->BaseAction()->Transitions())) {
<?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->WorkflowStatus  = 'Complete';
<?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->CurrentActionID = 0;
<?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.");
        }
    }

}
            } else {
                $this->WorkflowStatus = 'Paused';
<?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->write();
        }
    }

    /**
     * Evaluate all the transitions of an action and determine whether we should
     * follow any of them yet.
     *
     * @param  WorkflowActionInstance $action
     * @return WorkflowTransition
     */
    protected function checkTransitions(WorkflowActionInstance $action)
    {
        $transitions = $action->getValidTransitions();
        // if there's JUST ONE transition, then we need should
        // immediately follow it.
        if ($transitions && $transitions->count() == 1) {
            return $transitions->First();
        }
    }

    /**
     * Transitions a workflow to the next step defined by the given transition.
     *
     * After transitioning, the action is 'executed', and next steps
     * determined.
     *
     * @param WorkflowTransition $transition
     */
    public function performTransition(WorkflowTransition $transition)
    {
        // first make sure that the transition is valid to execute!
        $action          = $this->CurrentAction();
        $allTransitions  = $action->BaseAction()->Transitions();
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 { }

        $valid = $allTransitions->find('ID', $transition->ID);
        if (!$valid) {
            throw new Exception(
                sprintf(_t('WorkflowInstance.WORKFLOW_TRANSITION_EXCEPTION', 'Invalid transition state for action #%s'), $action->ID)
            );
        }

        $action->actionComplete($transition);

        $definition = DataObject::get_by_id('WorkflowAction', $transition->NextActionID);
<?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.");
        }
    }

}
        $action = $definition->getInstanceForWorkflow();
        $action->WorkflowID   = $this->ID;
        $action->write();

        $this->CurrentActionID = $action->ID;
<?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->write();
        $this->components = array(); // manually clear the has_one cache

        $action->actionStart($transition);

        $transition->extend('onTransition');
        $this->execute();
    }

    /**
     * Returns a list of all Members that are assigned to this instance, either directly or via a group.
     *
     * @todo   This could be made more efficient.
     * @return ArrayList
     */
    public function getAssignedMembers()

    {
        $list    = new ArrayList();
        $groups  = $this->Groups();
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 { }

        $list->merge($this->Users());
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 { }

        foreach ($groups as $group) {
            $list->merge($group->Members());
        }

        $list->removeDuplicates();
        return $list;
    }

    /**
     *
     * @param \Member $member
     * @return boolean
     */
    public function canView($member=null)
    {
        $extended = $this->extendedCan(__FUNCTION__, $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) {
            return $extended;
        }

        $hasAccess = $this->userHasAccess($member);
        /*
         * If the next action is AssignUsersToWorkflowAction, execute() resets all user+group relations.
         * Therefore current user no-longer has permission to view this WorkflowInstance in PendingObjects Gridfield, even though;
         * - She had permissions granted via the workflow definition to run the preceeding Action that took her here.
         */
        if (!$hasAccess) {
            if ($this->getMostRecentActionForUser($member)) {
                return true;
            }
        }
        return $hasAccess;
    }

    /**
     *
     * @param \Member $member
     * @return boolean
     */
    public function canEdit($member = null)
    {
        $extended = $this->extendedCan(__FUNCTION__, $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) {
            return $extended;
        }

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

    /**
     *
     * @param \Member $member
     * @return boolean
     */
    public function canDelete($member = null)
    {
        $extended = $this->extendedCan(__FUNCTION__, $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) {
            return $extended;
        }

        if (Permission::checkMember($member, "DELETE_WORKFLOW")) {
            return true;
        }
        return false;
    }

    /**
     * Checks whether the given user is in the list of users assigned to this
     * workflow
     *
     * @param $memberID
     */
    protected function userHasAccess($member)
    {
        if (!$member) {
            if (!Member::currentUserID()) {
                return false;
            }
            $member = Member::currentUser();
        }

        if (Permission::checkMember($member, "ADMIN")) {
            return true;
        }

        // This method primarily "protects" access to a WorkflowInstance, but assumes access only to be granted to users assigned-to that WorkflowInstance.
        // However; lowly authors (users entering items into a workflow) are not assigned - but we still wish them to see their submitted content.
        $inWorkflowGroupOrUserTables = ($member->inGroups($this->Groups()) || $this->Users()->find('ID', $member->ID));
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 { }
        // This method is used in more than just the ModelAdmin. Check for the current controller to determine where canView() expectations differ
        if ($this->getTarget() && Controller::curr()->getAction() == 'index' && !$inWorkflowGroupOrUserTables) {
            if ($this->getVersionedConnection($this->getTarget()->ID, $member->ID)) {
                return true;
            }
            return false;
        }
        return $inWorkflowGroupOrUserTables;
    }

    /**
     * Can documents in the current workflow state be edited?
     */
    public function canEditTarget()
    {
        if ($this->CurrentActionID) {
<?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->CurrentAction()->canEditTarget($this->getTarget());
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
        }
    }

    /**
     * Does this action restrict viewing of the document?
     *
     * @return boolean
     */
    public function canViewTarget()
    {
        $action = $this->CurrentAction();
        if ($action) {
            return $action->canViewTarget($this->getTarget());
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
        }
        return true;
    }

    /**
     * Does this action restrict the publishing of a document?
     *
     * @return boolean
     */
    public function canPublishTarget()
    {
        if ($this->CurrentActionID) {
<?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->CurrentAction()->canPublishTarget($this->getTarget());
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
        }
    }

    /**
     * Get the current set of transitions that are valid for the current workflow state,
     * and are available to the current user.
     *
     * @return array
     */
    public function validTransitions()
    {
        $action    = $this->CurrentAction();
        $transitions = $action->getValidTransitions();

        // Filter by execute permission
        $self = $this;
        return $transitions->filterByCallback(function ($transition) use ($self) {
            return $transition->canExecute($self);
        });
    }

    /* UI RELATED METHODS */

    /**
     * Gets fields for managing this workflow instance in its current step
     *
     * @return FieldList
     */
    public function getWorkflowFields()
    {
        $action    = $this->CurrentAction();
        $options   = $this->validTransitions();
        $wfOptions = $options->map('ID', 'Title', ' ');
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $fields    = new FieldList();

        $fields->push(new HeaderField('WorkflowHeader', $action->Title));
<?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.");
        }
    }

}

        $fields->push(HiddenField::create('TransitionID', ''));
        // Let the Active Action update the fields that the user can interact with so that data can be
        // stored for the workflow.
        $action->updateWorkflowFields($fields);

        return $fields;
    }

    /**
     * Gets Front-End form fields from current Action
     *
     * @return FieldList
     */
    public function getFrontEndWorkflowFields()
    {
        $action = $this->CurrentAction();

        $fields = new FieldList();
        $action->updateFrontEndWorkflowFields($fields);

        return $fields;
    }

    /**
     * Gets Transitions for display as Front-End Form Actions
     *
     * @return FieldList
     */
    public function getFrontEndWorkflowActions()
    {
        $action    = $this->CurrentAction();
        $options   = $action->getValidTransitions();
        $actions   = new FieldList();

        foreach ($options as $option) {
            $btn = new FormAction("transition_{$option->ID}", $option->Title);

            // add cancel class to passive actions, this prevents js validation (using jquery.validate)
            if ($option->Type == 'Passive') {
                $btn->addExtraClass('cancel');
            }

            // disable the button if canExecute() returns false
            if (!$option->canExecute($this)) {
                $btn = $btn->performReadonlyTransformation();
                $btn->addExtraClass('hide');
            }

            $actions->push($btn);
        }

        $action->updateFrontEndWorkflowActions($actions);

        return $actions;
    }

    /**
     * Gets Front-End DataObject
     *
     * @return DataObject
     */
    public function getFrontEndDataObject()
    {
        $action = $this->CurrentAction();
        $obj = $action->getFrontEndDataObject();

        return $obj;
    }

    /**
     * Gets Front-End DataObject
     *
     * @return DataObject
     */
    public function getFrontEndRequiredFields()
    {
        $action = $this->CurrentAction();
        $validator = $action->getRequiredFields();

        return $validator;
    }

    public function setFrontendFormRequirements()
    {
        $action = $this->CurrentAction();
        $action->setFrontendFormRequirements();
    }

    public function doFrontEndAction(array $data, Form $form, SS_HTTPRequest $request)
    {
        $action = $this->CurrentAction();
        $action->doFrontEndAction($data, $form, $request);
    }

    /*
     * We need a way to "associate" an author with this WorkflowInstance and its Target() to see if she is "allowed" to view WorkflowInstances within GridFields
     * @see {@link $this->userHasAccess()}
     *
     * @param number $recordID
     * @param number $userID
     * @param number $wasPublished
     * @return boolean
     */
    public function getVersionedConnection($recordID, $userID, $wasPublished = 0)
    {
        // Turn this into an array and run through implode()
        $filter = "RecordID = {$recordID} AND AuthorID = {$userID} AND WasPublished = {$wasPublished}";
        $query = new SQLQuery();

        $query->setFrom('"SiteTree_versions"')->setSelect('COUNT("ID")')->setWhere($filter);
        $query->firstRow();
        $hasAuthored = $query->execute();
        if ($hasAuthored) {
            return true;
        }
        return false;
    }

    /*
     * Simple method to retrieve the current action, on the current WorkflowInstance
     */
    public function getCurrentAction()
    {
        $join = '"WorkflowAction"."ID" = "WorkflowActionInstance"."BaseActionID"';
        $action = WorkflowAction::get()
                    ->leftJoin('WorkflowActionInstance', $join)
                    ->where('"WorkflowActionInstance"."ID" = '.$this->CurrentActionID)
<?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.");
        }
    }

}
                    ->first();
        if (!$action) {
            return 'N/A';
        }
        return $action->getField('Title');
    }

    /**
     * Tells us if $member has had permissions over some part of the current WorkflowInstance.
     *
     * @param $member
     * @return \WorkflowAction | boolean
     */
    public function getMostRecentActionForUser($member = null)
    {
        if (!$member) {
            if (!Member::currentUserID()) {
                return false;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
            }
            $member = Member::currentUser();
        }

        // WorkflowActionInstances in reverse creation-order so we get the most recent one's first
        $history = $this->Actions()->filter(array(

            'Finished' =>1,
            'BaseAction.ClassName' => 'AssignUsersToWorkflowAction'
        ))->Sort('Created', 'DESC');

        $i=0;
        foreach ($history as $inst) {
            /*
             * This iteration represents the 1st instance in the list - the most recent AssignUsersToWorkflowAction in $history.
             * If there's no match for $member here or on the _previous_ AssignUsersToWorkflowAction, then bail out:
             */
            $assignedMembers = $inst->BaseAction()->getAssignedMembers();
            if ($i<=1 && $assignedMembers->count()>0 && $assignedMembers->find('ID', $member->ID)) {
                return $inst;
            }
            ++$i;
        }
        return false;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }
}

silverstripe-australia / advancedworkflow

Pull Request — master (#230)

WorkflowInstance::userHasAccess() D

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like
