WorkflowApplicable::canPublish() - Code Metrics - Inspection of "Tentative fix for saving records with new workflow" - symbiote/silverstripe-advancedworkflow - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#342)

unknown

created 2018-01-31 01:31 UTC

WorkflowApplicable::canPublish() C

↳ Parent: WorkflowApplicable

Complexity

Conditions	7
Paths	9

Size

Total Lines	34
Code Lines	17

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	34
rs	6.7272
c	0
b	0
f	0
cc	7
eloc	17
nc	9
nop	0

<?php

namespace Symbiote\AdvancedWorkflow\Extensions;

use SilverStripe\Control\Controller;
use SilverStripe\Control\Director;
use SilverStripe\Forms\DropdownField;
use SilverStripe\Forms\FieldList;
use SilverStripe\Forms\FormAction;
use SilverStripe\Forms\GridField\GridField;
use SilverStripe\Forms\GridField\GridFieldConfig_Base;
use SilverStripe\Forms\GridField\GridFieldDetailForm;
use SilverStripe\Forms\GridField\GridFieldEditButton;
use SilverStripe\Forms\HiddenField;
use SilverStripe\Forms\ListboxField;
use SilverStripe\Forms\ReadonlyField;
use SilverStripe\Forms\Tab;
use SilverStripe\Forms\TabSet;
use SilverStripe\ORM\CMSPreviewable;
use SilverStripe\ORM\DataExtension;
use SilverStripe\Security\Permission;
use SilverStripe\Security\Security;
use Symbiote\AdvancedWorkflow\DataObjects\WorkflowDefinition;
use Symbiote\AdvancedWorkflow\DataObjects\WorkflowInstance;
use Symbiote\AdvancedWorkflow\Services\WorkflowService;
use Symbiote\QueuedJobs\Service\AbstractQueuedJob;

/**
 * DataObjects that have the WorkflowApplicable extension can have a
 * workflow definition applied to them. At some point, the workflow definition is then
 * triggered.
 *
 * @author  [email protected]
 * @license BSD License (http://silverstripe.org/bsd-license/)
 * @package advancedworkflow
 */
class WorkflowApplicable extends DataExtension
{
    private static $has_one = [

        'WorkflowDefinition' => WorkflowDefinition::class,
    ];

    private static $many_many = [

        'AdditionalWorkflowDefinitions' => WorkflowDefinition::class
    ];

    private static $dependencies = [

        'workflowService' => '%$' . WorkflowService::class,
    ];

    /**
     * Temporary record of items having workflow applied / removed to it.
     * These records should not have canPublish() = false immediately applied until refreshed.
     *
     * @var array
     */
    protected static $itemsChangingWorkflow = [];

    /**
     *
     * Used to flag to this extension if there's a WorkflowPublishTargetJob running.
     * @var boolean
     */
    public $isPublishJobRunning = false;

    /**
     *
     * @param boolean $truth
     */
    public function setIsPublishJobRunning($truth)
    {
        $this->isPublishJobRunning = $truth;
    }

    /**
     *
     * @return boolean
     */
    public function getIsPublishJobRunning()
    {
        return $this->isPublishJobRunning;
    }

    /**
     *
     * @see {@link $this->isPublishJobRunning}
     * @return boolean
     */
    public function isPublishJobRunning()
    {
        $propIsSet = $this->getIsPublishJobRunning() ? true : false;
        return class_exists(AbstractQueuedJob::class) && $propIsSet;
    }

    /**
     * @var WorkflowService
     */
    public $workflowService;

    /**
     *
     * A cache var for the current workflow instance
     *
     * @var WorkflowInstance
     */
    protected $currentInstance;

    public function updateSettingsFields(FieldList $fields)
    {
        $this->updateFields($fields);
    }

    public function updateCMSFields(FieldList $fields)
    {
        if (!$this->owner->hasMethod('getSettingsFields')) {
            $this->updateFields($fields);
        }

        // Instantiate a hidden form field to pass the triggered workflow definition through,
        // allowing a dynamic form action.

        $fields->push(HiddenField::create(
            'TriggeredWorkflowID'
        ));
    }

    public function updateFields(FieldList $fields)
    {
        if (!$this->owner->ID) {
            return $fields;
        }

        $tab = $fields->fieldByName('Root') ? $fields->findOrMakeTab('Root.Workflow') : $fields;

        if (Permission::check('APPLY_WORKFLOW')) {
            $definition = new DropdownField(
                'WorkflowDefinitionID',
                _t('WorkflowApplicable.DEFINITION', 'Applied Workflow')
            );
            $definitions = $this->workflowService->getDefinitions()->map()->toArray();
            $definition->setSource($definitions);
            $definition->setEmptyString(_t('WorkflowApplicable.INHERIT', 'Inherit from parent'));
            $tab->push($definition);

            // Allow an optional selection of additional workflow definitions.

            if ($this->owner->WorkflowDefinitionID) {
                $fields->removeByName('AdditionalWorkflowDefinitions');
                unset($definitions[$this->owner->WorkflowDefinitionID]);
                $tab->push($additional = ListboxField::create(
                    'AdditionalWorkflowDefinitions',
                    _t('WorkflowApplicable.ADDITIONAL_WORKFLOW_DEFINITIONS', 'Additional Workflows')
                ));
                $additional->setSource($definitions);
            }
        }

        // Display the effective workflow definition.

        if ($effective = $this->getWorkflowInstance()) {
            $title = $effective->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.");
        }
    }

}
            $tab->push(ReadonlyField::create(
                'EffectiveWorkflow',
                _t('WorkflowApplicable.EFFECTIVE_WORKFLOW', 'Effective Workflow'),
                $title
            ));
        }

        if ($this->owner->ID) {
            $config = new GridFieldConfig_Base();
            $config->addComponent(new GridFieldEditButton());
            $config->addComponent(new GridFieldDetailForm());

            $insts = $this->owner->WorkflowInstances();
            $log = new GridField(
                'WorkflowLog',
                _t('WorkflowApplicable.WORKFLOWLOG', 'Workflow Log'),
                $insts,
                $config
            );

            $tab->push($log);
        }
    }

    public function updateCMSActions(FieldList $actions)
    {
        $active = $this->workflowService->getWorkflowFor($this->owner);
        $c = Controller::curr();
        if ($c && $c->hasExtension(AdvancedWorkflowExtension::class)) {
            if ($active) {
                if ($this->canEditWorkflow()) {
                    $workflowOptions = new Tab(
                        'WorkflowOptions',
                        _t(
                            'SiteTree.WorkflowOptions',
                            'Workflow options',
                            'Expands a view for workflow specific buttons'
                        )
                    );

                    $menu = $actions->fieldByName('ActionMenus');
                    if (!$menu) {
                        // create the menu for adding to any arbitrary non-sitetree object
                        $menu = $this->createActionMenu();
                        $actions->push($menu);
                    }

                    if (!$actions->fieldByName('ActionMenus.WorkflowOptions')) {
                        $menu->push($workflowOptions);
                    }

                    $transitions = $active->CurrentAction()->getValidTransitions();

                    foreach ($transitions as $transition) {
                        if ($transition->canExecute($active)) {
                            $action = FormAction::create('updateworkflow-' . $transition->ID, $transition->Title)
                                ->setAttribute('data-transitionid', $transition->ID);
                            $workflowOptions->push($action);
                        }
                    }

                    // $action = FormAction::create('updateworkflow', $active->CurrentAction() ?

                    // $active->CurrentAction()->Title :

                    // _t('WorkflowApplicable.UPDATE_WORKFLOW', 'Update Workflow'))

                    //  ->setAttribute('data-icon', 'navigation');


                    // $actions->fieldByName('MajorActions') ?

                    // $actions->fieldByName('MajorActions')->push($action) :

                    // $actions->push($action);

                }
            } else {
                // Instantiate the workflow definition initial actions.
                $definitions = $this->workflowService->getDefinitionsFor($this->owner);
                if ($definitions) {
                    $menu = $actions->fieldByName('ActionMenus');
                    if (is_null($menu)) {
                        // Instantiate a new action menu for any data objects.

                        $menu = $this->createActionMenu();
                        $actions->push($menu);
                    }
                    $tab = Tab::create(
                        'AdditionalWorkflows'
                    );
                    $addedFirst = false;
                    foreach ($definitions as $definition) {
                        if ($definition->getInitialAction() && $this->owner->canEdit()) {
                            $action = FormAction::create(
                                "startworkflow-{$definition->ID}",
                                $definition->InitialActionButtonText ?
                                    $definition->InitialActionButtonText :
                                    $definition->getInitialAction()->Title
                            )
                                ->addExtraClass('start-workflow')
                                ->setAttribute('data-workflow', $definition->ID)
                                ->addExtraClass('btn-primary');

                            // The first element is the main workflow definition,
                            // and will be displayed as a major action.
                            if (!$addedFirst) {
                                $addedFirst = true;
                                $action->setAttribute('data-icon', 'navigation');
                                $majorActions = $actions->fieldByName('MajorActions');
                                $majorActions ? $majorActions->push($action) : $actions->push($action);
                            } else {
                                $tab->push($action);
                            }
                        }
                    }
                    // Only display menu if actions pushed to it
                    if ($tab->Fields()->exists()) {
                        $menu->insertBefore($tab, 'MoreOptions');
                    }
                }
            }
        }
    }

    protected function createActionMenu()
    {
        $rootTabSet = new TabSet('ActionMenus');
        $rootTabSet->addExtraClass('ss-ui-action-tabset action-menus');
        return $rootTabSet;
    }

    /**
     * Included in CMS-generated email templates for a NotifyUsersWorkflowAction.
     * Returns an absolute link to the CMS UI for a Page object
     *
     * @return string|null
     */
    public function AbsoluteEditLink()
    {
        $CMSEditLink = null;

        if ($this->owner instanceof CMSPreviewable) {
            $CMSEditLink = $this->owner->CMSEditLink();
        } elseif ($this->owner->hasMethod('WorkflowLink')) {
            $CMSEditLink = $this->owner->WorkflowLink();
        }

        if ($CMSEditLink === null) {
            return null;
        }

        return Controller::join_links(Director::absoluteBaseURL(), $CMSEditLink);
    }

    /**
     * Included in CMS-generated email templates for a NotifyUsersWorkflowAction.
     * Allows users to select a link in an email for direct access to the transition-selection dropdown in the CMS UI.
     *
     * @return string
     */
    public function LinkToPendingItems()
    {
        $urlBase = Director::absoluteBaseURL();
        $urlFrag = 'admin/workflows/WorkflowDefinition/EditForm/field';
        $urlInst = $this->getWorkflowInstance();
        return Controller::join_links($urlBase, $urlFrag, 'PendingObjects', 'item', $urlInst->ID, 'edit');
    }

    /**
     * After a workflow item is written, we notify the
     * workflow so that it can take action if needbe
     */
    public function onAfterWrite()
    {
        // Record changes to the workflow on this record
        $changed = $this->owner->getChangedFields(['WorkflowDefinitionID']);
        if (isset($changed['WorkflowDefinitionID']) &&
            (
                empty($changed['WorkflowDefinitionID']['before'])
                || empty($changed['WorkflowDefinitionID']['before'])
            )
        ) {
            $key = $this->owner->baseClass() . '#' . $this->owner->ID;
            static::$itemsChangingWorkflow[$key] = true;
        }

        // Get workflow instance
        $instance = $this->getWorkflowInstance();
        if ($instance && $instance->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.");
        }
    }

}
            $action = $instance->CurrentAction()->BaseAction()->targetUpdated($instance);
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 { }
        }
    }

    public function WorkflowInstances()
    {
        return WorkflowInstance::get()->filter([
            'TargetClass' => $this->owner->baseClass(),
            'TargetID' => $this->owner->ID
        ]);
    }

    /**
     * Gets the current instance of workflow
     *
     * @return WorkflowInstance
     */
    public function getWorkflowInstance()
    {
        if (!$this->currentInstance) {
            $this->currentInstance = $this->workflowService->getWorkflowFor($this->owner);
class Id
{
    public $id;

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

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
        }

        return $this->currentInstance;
    }


    /**
     * Gets the history of a workflow instance
     *
     * @return DataObjectSet
     */
    public function getWorkflowHistory($limit = null)
    {
        return $this->workflowService->getWorkflowHistoryFor($this->owner, $limit);
    }

    /**
     * Check all recent WorkflowActionIntances and return the most recent one with a Comment
     *
     * @param int $limit
     * @return WorkflowActionInstance|null
     */
    public function RecentWorkflowComment($limit = 10)
    {
        if ($actions = $this->getWorkflowHistory($limit)) {
            foreach ($actions as $action) {
                if ($action->Comment != '') {
                    return $action;
                }
            }
        }
    }

    /**
     * Content can never be directly publishable if there's a workflow applied.
     *
     * If there's an active instance, then it 'might' be publishable
     */
    public function canPublish()
    {
        // Ignore canPublish() if in the middle of having workflow added / removed
        $key = $this->owner->baseClass() . '#' . $this->owner->ID;
        if (isset(static::$itemsChangingWorkflow[$key])) {
            return null;
        }

        // Override any default behaviour, to allow queuedjobs to complete
        if ($this->isPublishJobRunning()) {
            return true;
        }

        if ($active = $this->getWorkflowInstance()) {
            $publish = $active->canPublishTarget($this->owner);

            if (!is_null($publish)) {
                return $publish;
            }
        }

        // use definition to determine if publishing directly is allowed
        $definition = $this->workflowService->getDefinitionFor($this->owner);

        if ($definition) {
            if (!Security::getCurrentUser()) {
                return false;
            }
            $member = Security::getCurrentUser();

            $canPublish = $definition->canWorkflowPublish($member, $this->owner);

            return $canPublish;
        }
    }

    /**
     * Can only edit content that's NOT in another person's content changeset
     */
    public function canEdit($member)
    {
        // Override any default behaviour, to allow queuedjobs to complete
        if ($this->isPublishJobRunning()) {
            return true;
        }

        if ($active = $this->getWorkflowInstance()) {
            return $active->canEditTarget($this->owner);

        }
    }

    /**
     * Can a user edit the current workflow attached to this item?
     */
    public function canEditWorkflow()
    {
        $active = $this->getWorkflowInstance();
        if ($active) {
            return $active->canEdit();
        }
        return false;
    }
}


1			<?php
2
3			namespace Symbiote\AdvancedWorkflow\Extensions;
4
5			use SilverStripe\Control\Controller;
6			use SilverStripe\Control\Director;
7			use SilverStripe\Forms\DropdownField;
8			use SilverStripe\Forms\FieldList;
9			use SilverStripe\Forms\FormAction;
10			use SilverStripe\Forms\GridField\GridField;
11			use SilverStripe\Forms\GridField\GridFieldConfig_Base;
12			use SilverStripe\Forms\GridField\GridFieldDetailForm;
13			use SilverStripe\Forms\GridField\GridFieldEditButton;
14			use SilverStripe\Forms\HiddenField;
15			use SilverStripe\Forms\ListboxField;
16			use SilverStripe\Forms\ReadonlyField;
17			use SilverStripe\Forms\Tab;
18			use SilverStripe\Forms\TabSet;
19			use SilverStripe\ORM\CMSPreviewable;
20			use SilverStripe\ORM\DataExtension;
21			use SilverStripe\Security\Permission;
22			use SilverStripe\Security\Security;
23			use Symbiote\AdvancedWorkflow\DataObjects\WorkflowDefinition;
24			use Symbiote\AdvancedWorkflow\DataObjects\WorkflowInstance;
25			use Symbiote\AdvancedWorkflow\Services\WorkflowService;
26			use Symbiote\QueuedJobs\Service\AbstractQueuedJob;
27
28			/**
29			* DataObjects that have the WorkflowApplicable extension can have a
30			* workflow definition applied to them. At some point, the workflow definition is then
31			* triggered.
32			*
33			* @author [email protected]
34			* @license BSD License (http://silverstripe.org/bsd-license/)
35			* @package advancedworkflow
36			*/
37			class WorkflowApplicable extends DataExtension
38			{
39			private static $has_one = [
			0 ignored issues – show Unused Code introduced 2017-10-01 23:10 UTC by Report Bug Copy Issue Report The property `$has_one` is not used and could be removed. This check marks private properties in classes that are never used. Those properties can be removed. Loading history...

symbiote / silverstripe-advancedworkflow

GitHub Access Token became invalid

Pull Request — master (#342)

WorkflowApplicable::canPublish() C

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like