WorkflowActionInstance - Code Metrics - symbiote/silverstripe-advancedworkflow - Measure and Improve Code Quality continuously with Scrutinizer

WorkflowActionInstance A
last analyzed 2019-12-18 23:33 UTC

↳ Parent: Project
Complexity

Total Complexity
Size/Duplication

Total Lines	263
Duplicated Lines	0 %
Coupling/Cohesion

Components	1
Dependencies	6
Importance

Changes
Metric	Value
wmc	35
lcom	1
cbo	6
dl	0
loc	263
rs	9.6
c	0
b	0
f	0
18 Methods

Rating	Name	Size	Complexity
A	fieldLabels()	11	1
A	updateWorkflowFields()	19	3
A	updateFrontendWorkflowFields()	12	2
A	getFrontEndDataObject()	13	2
A	updateFrontEndWorkflowActions()	8	2
A	getRequiredFields()	11	2
A	setFrontendFormRequirements()	8	2
A	doFrontEndAction()	13	3
A	getTitle()	4	1
A	getValidTransitions()	19	4
A	actionStart()	4	1
A	actionComplete()	6	1
A	canEditTarget()	16	5
A	canViewTarget()	4	1
A	canPublishTarget()	8	2
A	canView()	4	1
A	canEdit()	4	1
A	canDelete()	4	1
<?php

namespace Symbiote\AdvancedWorkflow\DataObjects;

use SilverStripe\Control\HTTPRequest;
use SilverStripe\Forms\Form;
use SilverStripe\Forms\ReadonlyField;
use SilverStripe\Forms\TextareaField;
use SilverStripe\ORM\ArrayList;
use SilverStripe\ORM\DataObject;
use SilverStripe\ORM\FieldType\DBField;
use SilverStripe\Security\Member;

/**
 * A workflow action attached to a {@link WorkflowInstance} that has been run,
 * and is either currently running, or has finished.
 *
 * Each step of the workflow has one of these created for it - it refers back
 * to the original action definition, but is unique for each step of the
 * workflow to ensure re-entrant behaviour.
 *
 * @license BSD License (http://silverstripe.org/bsd-license/)
 * @package advancedworkflow
 */
class WorkflowActionInstance extends DataObject
{
    private static $db = array(

        'Comment'  => 'Text',
        'Finished' => 'Boolean'
    );

    private static $has_one = array(

        'Workflow'   => WorkflowInstance::class,
        'BaseAction' => WorkflowAction::class,
        'Member'     => Member::class,
    );

    private static $summary_fields = array(

        'BaseAction.Title',
        'Comment',
        'Created',
        'Member.Name',
    );

    private static $table_name = 'WorkflowActionInstance';


    public function fieldLabels($includerelations = true)
    {
        $labels = parent::fieldLabels($includerelations);
        $labels['BaseAction.Title'] = _t('WorkflowActionInstance.Title', 'Title');
        $labels['Comment'] = _t('WorkflowAction.CommentLabel', 'Comment');
        $labels['Member.Name'] = _t('WorkflowAction.Author', 'Author');
        $labels['Finished'] = _t('WorkflowAction.FinishedLabel', 'Finished');
        $labels['BaseAction.Title'] = _t('WorkflowAction.TITLE', 'Title');

        return $labels;
    }

    /**
     * Gets fields for when this is part of an active workflow
     */
    public function updateWorkflowFields($fields)
    {
        $fieldDiff = $this->Workflow()->getTargetDiff();


        foreach ($fieldDiff as $field) {
            $display = ReadonlyField::create(
                'workflow-' . $field->Name,
                $field->Title,
                DBField::create_field('HTMLText', $field->Diff)
            )
                ->addExtraClass('workflow-field-diff')
                ->setTemplate(__CLASS__ . '/ReadonlyField');
            $fields->push($display);
        }

        if ($this->BaseAction()->AllowCommenting) {
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 { }
            $fields->push(new TextareaField('Comment', _t('WorkflowAction.COMMENT', 'Comment')));
        }
    }

    public function updateFrontendWorkflowFields($fields)
    {
        if ($this->BaseAction()->AllowCommenting) {
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 { }
            $fields->push(new TextareaField(
                'WorkflowActionInstanceComment',
                _t('WorkflowAction.FRONTENDCOMMENT', 'Comment')
            ));
        }

        $ba = $this->BaseAction();
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 { }
        $fields = $ba->updateFrontendWorkflowFields($fields, $this->Workflow());
$myVar = 'Value';
$higher = false;

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

    /**
     * Gets Front-End DataObject
     *
     * Use the DataObject as defined in the WorkflowAction, otherwise fall back to the
     * context object.
     *
     * Useful for situations where front end workflow deals with multiple data objects
     *
     * @return DataObject
     */
    public function getFrontEndDataObject()
    {
        $obj = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $ba = $this->BaseAction();
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 ($ba->hasMethod('getFrontEndDataObject')) {
            $obj = $ba->getFrontEndDataObject();
        } else {
            $obj = $this->Workflow()->getTarget();

        }

        return $obj;
    }

    public function updateFrontEndWorkflowActions($actions)
    {
        $ba = $this->BaseAction();
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 ($ba->hasMethod('updateFrontEndWorkflowActions')) {
            $ba->updateFrontEndWorkflowActions($actions);
        }
    }

    public function getRequiredFields()
    {
        $validator = null;
        $ba = $this->BaseAction();
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 ($ba->hasMethod('getRequiredFields')) {
            $validator = $ba->getRequiredFields();
        }

        return $validator;
    }

    public function setFrontendFormRequirements()
    {
        $ba = $this->BaseAction();
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 ($ba->hasMethod('setFrontendFormRequirements')) {
            $ba->setFrontendFormRequirements();
        }
    }

    public function doFrontEndAction(array $data, Form $form, HTTPRequest $request)
    {
        //Save Front End Workflow notes, then hand over to Workflow Action
        if (isset($data["WorkflowActionInstanceComment"])) {
            $this->Comment = $data["WorkflowActionInstanceComment"];
<?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();
        }

        $ba = $this->BaseAction();
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 ($ba->hasMethod('doFrontEndAction')) {
            $ba->doFrontEndAction($data, $form, $request);
        }
    }


    /**
     * Gets the title of this active action instance
     *
     * @return string
     */
    public function getTitle()
    {
        return $this->BaseAction()->Title;
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 { }
    }

    /**
     * Returns all the valid transitions that lead out from this action.
     *
     * This is called if this action has finished, and the workflow engine wants
     * to run the next action.
     *
     * If this action returns only one valid transition it will be immediately
     * followed; otherwise the user will decide which transition to follow.
     *
     * @return ArrayList
     */
    public function getValidTransitions()
    {
        $available = $this->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     = new ArrayList();

        // iterate through the transitions and see if they're valid for the current state of the item being
        // workflowed
        if ($available) {
            foreach ($available as $transition) {
                if ($transition->isValid($this->Workflow())) {

                    $valid->push($transition);
                }
            }
        }

        $this->extend('updateValidTransitions', $valid);

        return $valid;
    }

    /**
     * Called when this instance is started within the workflow
     */
    public function actionStart(WorkflowTransition $transition)
    {
        $this->extend('onActionStart', $transition);
    }

    /**
     * Called when this action has been completed within the workflow
     */
    public function actionComplete(WorkflowTransition $transition)
    {
        $this->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.");
        }
    }

}
        $this->write();
        $this->extend('onActionComplete', $transition);
    }


    /**
     * Can documents in the current workflow state be edited?
     *
     * @param  DataObject $target
     * @return bool
     */
    public function canEditTarget(DataObject $target)
    {
        $absolute = $this->BaseAction()->canEditTarget($target);
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 (!is_null($absolute)) {
            return $absolute;
        }
        switch ($this->BaseAction()->AllowEditing) {
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 { }
            case 'By Assignees':
                return $this->Workflow()->canEdit();

            case 'No':
                return false;
            case 'Content Settings':
            default:
                return null;
        }
    }

    /**
     * Does this action restrict viewing of the document?
     *
     * @param  DataObject $target
     * @return bool
     */
    public function canViewTarget(DataObject $target)
    {
        return $this->BaseAction()->canViewTarget($target);
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 { }
    }

    /**
     * Does this action restrict the publishing of a document?
     *
     * @param  DataObject $target
     * @return bool
     */
    public function canPublishTarget(DataObject $target)
    {
        $absolute = $this->BaseAction()->canPublishTarget($target);
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 (!is_null($absolute)) {
            return $absolute;
        }
        return false;
    }

    public function canView($member = null)
    {
        return $this->Workflow()->canView($member);

    }

    public function canEdit($member = null)
    {
        return $this->Workflow()->canEdit($member);

    }

    public function canDelete($member = null)
    {
        return $this->Workflow()->canDelete($member);

    }
}

symbiote / silverstripe-advancedworkflow

GitHub Access Token became invalid

WorkflowActionInstance A last analyzed 2019-12-18 23:33 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

18 Methods

Duplication Side-by-Side

Filter issues like

WorkflowActionInstance A
last analyzed 2019-12-18 23:33 UTC
