WorkflowServiceInner::executeMigration() - Code Metrics - Inspection of "allow usage of simplified method args in WorkflowS..." - kaliop-uk/ezworkflowenginebundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — main ( 4b1d5b...63f1e2 )

by Gaetano
created 2022-11-22 11:51 UTC
WorkflowServiceInner::executeMigration() B

↳ Parent: WorkflowServiceInner
Complexity

Conditions	11
Paths	10
Size

Total Lines	32
Code Lines	16
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	11
eloc	16
nc	10
nop	7
dl	0
loc	32
rs	7.3166
c	0
b	0
f	0
How to fix Complexity

<?php

namespace Kaliop\eZWorkflowEngineBundle\Core;

use Kaliop\eZMigrationBundle\API\Value\MigrationDefinition;
use Kaliop\eZMigrationBundle\API\Value\Migration;
use Kaliop\eZMigrationBundle\API\EnumerableReferenceResolverInterface;
use Kaliop\eZMigrationBundle\Core\MigrationService;
use Kaliop\eZMigrationBundle\Core\ReferenceResolver\PrefixBasedResolverInterface;
use Kaliop\eZWorkflowEngineBundle\API\Value\WorkflowDefinition;

class WorkflowServiceInner extends MigrationService implements PrefixBasedResolverInterface, EnumerableReferenceResolverInterface
{
    protected $eventPrefix = 'ez_workflow.';
    protected $eventEntity = 'workflow';
    protected $referenceRegexp = '/^workflow:/';
    protected $currentWorkflowName;

    public function addMigration(MigrationDefinition $migrationDefinition)
    {
        throw new \Exception("Unsupported operation: direct adding of workflows");
    }

    public function skipMigration(MigrationDefinition $migrationDefinition)
    {
        throw new \Exception("Unsupported operation: tagging of workflows as skipped");
    }

    /**
     * Reimplemented to make sure we always return a WorkflowDefinition
     * @param MigrationDefinition $migrationDefinition this should be a WorkflowDefinition really
     * @return WorkflowDefinition
     * @throws \Exception
     */
    public function parseMigrationDefinition(MigrationDefinition $migrationDefinition)
    {
        foreach ($this->DefinitionParsers as $definitionParser) {
            if ($definitionParser->supports($migrationDefinition->name)) {
                // parse the source file
                $migrationDefinition = $definitionParser->parseMigrationDefinition($migrationDefinition);

                // and make sure we know how to handle all steps
                foreach ($migrationDefinition->steps as $step) {
                    if (!isset($this->executors[$step->type])) {
                        return new WorkflowDefinition(
                            $migrationDefinition->name,
                            $migrationDefinition->path,
                            $migrationDefinition->rawDefinition,
                            MigrationDefinition::STATUS_INVALID,
                            array(),
                            "Can not handle workflow step of type '{$step->type}'",
                            isset($migrationDefinition->signalName) ? $migrationDefinition->signalName : null,
                            isset($migrationDefinition->runAs) ? $migrationDefinition->runAs : false,
                            isset($migrationDefinition->useTransaction) ? $migrationDefinition->useTransaction : false,
                            isset($migrationDefinition->avoidRecursion) ? $migrationDefinition->avoidRecursion : false
                        );
                    }
                }

                return $migrationDefinition;
            }
        }

        throw new \Exception("No parser available to parse workflow definition '{$migrationDefinition->name}'");
    }

    /**
     * Reimplemented to add more parameters to be stored in the context
     *
     * @param MigrationDefinition $migrationDefinition
     * @param array $migrationContext Supported array keys are: adminUserLogin, defaultLanguageCode, userContentType,
     *                                userGroupContentType useTransaction, workflow
     *                                was: bool $useTransaction when set to false, no repo transaction will be used to wrap the migration
     * @param string $defaultLanguageCode Deprecated - use $migrationContext['defaultLanguageCode']
     * @param string|int|false|null $adminLogin Deprecated - use $migrationContext['adminLogin']; when false, current user is used; when null, hardcoded admin account
     * @param bool $force Deprecated - use $migrationContext['forceExecution']; when true, execute a migration if it was already in status DONE or SKIPPED (would throw by default)
     * @param bool|null $forceSigchildEnabled Deprecated
     * @param null|array $workflowParameters Deprecated - use $migrationContext['workflow']
     * @throws \Exception
     *
     * @todo treating a null and false $adminLogin values differently is prone to hard-to-track errors.
     *       Shall we use instead -1 to indicate the desire to not-login-as-admin-user-at-all ?
     */
    public function executeMigration(MigrationDefinition $migrationDefinition, $migrationContext = true,
        $defaultLanguageCode = null, $adminLogin = null, $force = false, $forceSigchildEnabled = null, $workflowParameters = null)
    {
        if ($migrationDefinition->status == MigrationDefinition::STATUS_TO_PARSE) {
            $migrationDefinition = $this->parseMigrationDefinition($migrationDefinition);
        }

        if ($migrationDefinition->status == MigrationDefinition::STATUS_INVALID) {
            /// @todo !important name of entity should be gotten dynamically (migration vs. workflow)
            throw new \Exception("Can not execute migration '{$migrationDefinition->name}': {$migrationDefinition->parsingError}");
        }

        // BC: handling of legacy method call signature
        if (!is_array($migrationContext)) {
            $useTransaction = $migrationContext;
            $migrationContext = $this->migrationContextFromParameters($defaultLanguageCode, $adminLogin, $forceSigchildEnabled, $workflowParameters);
            $migrationContext = /** @scrutinizer ignore-deprecated */ $this->migrationContextFromParameters($defaultLanguageCode, $adminLogin, $forceSigchildEnabled, $workflowParameters);
        } else {
            if ($defaultLanguageCode !== null || $adminLogin !== null || $force !== false || $forceSigchildEnabled !== null
                || $workflowParameters !== null
            ) {
                throw new \Exception("Invalid call to executeMigration: argument types mismatch");
            }
            $useTransaction = array_key_exists('useTransaction', $migrationContext) ? $migrationContext['useTransaction'] : true;
            $migrationContext['workflow'] = $this->workflowMigrationContextFromParameters(
                array_key_exists('workflow', $migrationContext) ? $migrationContext['workflow'] : null
            );
        }

        // set migration as begun - has to be in own db transaction
        $migration = $this->storageHandler->startMigration($migrationDefinition, $force);

        $this->executeMigrationInner($migration, $migrationDefinition, $migrationContext, 0, $useTransaction, $adminLogin);
    }

    /**
     * Reimplemented to store the name of the current executing workflow
     * @param Migration $migration
     * @param MigrationDefinition $migrationDefinition
     * @param array $migrationContext
     * @param int $stepOffset
     * @param bool $useTransaction Deprecated - replaced by $migrationContext['useTransaction']. When set to false, no repo transaction will be used to wrap the migration
     * @param string|int|false|null $adminLogin Deprecated - $migrationContext['adminLogin']. Used only for committing db transaction if needed. If false or null, hardcoded admin is used
     * @throws \Exception
     */
    protected function executeMigrationInner(Migration $migration, MigrationDefinition $migrationDefinition,
        $migrationContext, $stepOffset = 0, $useTransaction = true, $adminLogin = null)
    {
        $previousWorkflowName = $this->currentWorkflowName;
        $this->currentWorkflowName = $migration->name;
        try {
            parent::executeMigrationInner($migration, $migrationDefinition, $migrationContext, $stepOffset,
                $useTransaction, $adminLogin);
            $this->currentWorkflowName = $previousWorkflowName;
        } catch (\Exception $e) {
            $this->currentWorkflowName = $previousWorkflowName;
            throw $e;
        }
    }

    /**
     * Reimplemented to store in the context the current user at start of workflow
     *
     * @param null $defaultLanguageCode

     * @param null $adminLogin

     * @param array $workflowParameters
     * @return array
     * @deprecated kept for BC
     */
    protected function migrationContextFromParameters($defaultLanguageCode = null, $adminLogin = null, $forceSigchildEnabled = null, $workflowParameters = null)
    {
        $properties = parent::migrationContextFromParameters($defaultLanguageCode, $adminLogin, $forceSigchildEnabled);
        $properties = /** @scrutinizer ignore-deprecated */ parent::migrationContextFromParameters($defaultLanguageCode, $adminLogin, $forceSigchildEnabled);

        $properties['workflow'] = $this->workflowMigrationContextFromParameters($workflowParameters);

        return $properties;
    }

    protected function workflowMigrationContextFromParameters($workflowParameters = null)
    {
        if (!is_array($workflowParameters)) {
            /// @todo log warning
            $workflowParameters = array();
        }

        $workflowParameters = array_merge(
            $workflowParameters,
            array(
                'original_user' => $this->repository->getCurrentUser()->login,
                'start_time' => time()
            )
        );

        return $workflowParameters;
    }

    /**
     * When restoring the context of the original workflow, we will be running as anon, whereas the original
     * workflow might have been started either as an admin or as then-current user. We need special handling for the
     * latter case
     *
     * @param string $migrationName
     * @param array $context
     */
    public function restoreContext($migrationName, array $context)
    {
        if (array_key_exists('adminUserLogin', $context['context']) && $context['context']['adminUserLogin'] === false) {
            if (isset($context['context']['workflow']['original_user'])) {
                $context['context']['adminUserLogin'] = $context['context']['workflow']['original_user'];
            }
        }

        parent::restoreContext($migrationName, $context);
    }

    ### reference resolver interface

    public function getRegexp()
    {
        return $this->referenceRegexp;
    }

    public function isReference($stringIdentifier)
    {
        if (!is_string($stringIdentifier)) {
            return false;
        }

        return (bool)preg_match($this->referenceRegexp, $stringIdentifier);
    }

    /**
     * @param string $stringIdentifier
     * @return mixed
     * @throws \Exception if the given Identifier is not a reference
     */
    public function getReferenceValue($stringIdentifier)
    {
        $context = $this->getCurrentContext($this->currentWorkflowName);
        if (!is_array($context) || !isset($context['context']['workflow']) || !is_array($context['context']['workflow'])) {

            throw new \Exception('Can not resolve reference to a workflow parameter as workflow context is missing');
        }

        $identifier = preg_replace($this->referenceRegexp, '', $stringIdentifier);

        if (!array_key_exists($identifier, $context['context']['workflow'])) {
            throw new \Exception("No workflow reference set with identifier '$identifier'");
        }

        return $context['context']['workflow'][$identifier];
    }

    /**
     * @param string $stringIdentifier
     * @return mixed $stringIdentifier if not a reference, otherwise the reference vale
     * @throws \Exception if the given Identifier is not a reference
     */
    public function resolveReference($stringIdentifier)
    {
        if ($this->isReference($stringIdentifier)) {
            return $this->getReferenceValue($stringIdentifier);
        }
        return $stringIdentifier;
    }

    public function listReferences()
    {
        $context = $this->getCurrentContext($this->currentWorkflowName);
        if (!is_array($context) || !isset($context['context']['workflow']) || !is_array($context['context']['workflow'])) {

            throw new \Exception('Can not resolve reference to a workflow parameter as workflow context is missing');
        }

        return $context['context']['workflow'];
    }
}

kaliop-uk / ezworkflowenginebundle

Push — main ( 4b1d5b...63f1e2 )

WorkflowServiceInner::executeMigration() B

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like
