Add actions inside Pipeline based on the configuration provided by Symfony Configuration
@param Pipeline $pipeline
@param string $actionName
@param array $actionConfiguration
321187
public function buildAction($pipeline, $actionName, $actionConfiguration = [])
    {
        $triggeredByEvents = is_array($actionConfiguration) && array_key_exists("triggered_by_events", $actionConfiguration) ? $actionConfiguration["triggered_by_events"] : [];

        if (empty($triggeredByEvents)) {
            // default behavior : auto-wiring action to the same event name
            $triggeredByEvents = [$actionName];
        }

        // create the action and the action creator
        $action = new Action($actionName);
        $actionCreator = new ActionCreator($action);
        foreach ($triggeredByEvents as $triggeredByEvent) {
            $event = $pipeline->hasIncomingEvent($triggeredByEvent) ? $pipeline->getIncomingEvent($triggeredByEvent) : new Event($triggeredByEvent);
            $actionCreator->addTriggeredByEvent($event);
            $pipeline->addIncomingEvent($event);
        }
        $pipeline->addAction($action);
        $pipeline->addActionCreator($actionCreator);
    }
1042847
public function updateAction(array $siteConfigurations)
    {
        foreach ($siteConfigurations as $siteConfiguration) {
            if ($this->persistenceManager->isNewObject($siteConfiguration)) {
                $this->siteConfigurationRepository->add($siteConfiguration);
            } else {
                $this->siteConfigurationRepository->update($siteConfiguration);
            }
        }

        $this->emitSiteConfigurationChanged();

        $this->addFlashMessage('Configuration has been updated.', 'Update', null, [], 1417109043);
        $this->redirect('index');
    }
816616
public function performTransition(WorkflowTransition $transition)
    {
        // first make sure that the transition is valid to execute!
        $action          = $this->CurrentAction();
        $allTransitions  = $action->BaseAction()->Transitions();

        $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::class, $transition->NextActionID);
        $action = $definition->getInstanceForWorkflow();
        $action->WorkflowID   = $this->ID;
        $action->write();

        $this->CurrentActionID = $action->ID;
        $this->write();
        $this->components = array(); // manually clear the has_one cache

        $action->actionStart($transition);

        $transition->extend('onTransition');
        $this->execute();
    }
1065790
protected function addMapping(ActionMapping $mapping) {
        if ($this->configured) throw new IllegalStateException('Configuration is frozen');

        if ($mapping->isDefault()) {
            if ($this->defaultMapping) throw new StrutsConfigException('Only one action mapping can be marked as "default" within a module.');
            $this->defaultMapping = $mapping;
        }

        $name = $mapping->getName();
        if (strlen($name)) {
            if (isset($this->mappings['names'][$name])) throw new StrutsConfigException('All action mappings must have unique name attributes, non-unique name: "'.$name.'"');
            $this->mappings['names'][$name] = $mapping;
        }

        $path = $mapping->getPath();
        if (!strEndsWith($path, '/'))
            $path .= '/';
        if (isset($this->mappings['paths'][$path])) throw new StrutsConfigException('All action mappings must have unique path attributes, non-unique path: "'.$mapping->getPath().'"');
        $this->mappings['paths'][$path] = $mapping;
    }
144915
public final <T extends Action> void addSimpleActionBinding(String actionPath, Class<T> actionClass) {
		this.addActionBinding(new SimpleActionBinding<>(actionPath, actionClass));
	}
12473
public function handleEvent(ActionEvent $event)
    {
        $response = $this->process($event->getAction(), $event->getEnvironment());
        $event->setResponse($response);
    }
534934
public function startAction($actionName)
    {
        $startStopwatch = $this->stopwatch && empty($this->actionStack);

        $this->actionStack[] = ['name' => $actionName, 'time' => microtime(true), 'subtrahend' => 0];
        $this->lastActionIndex++;
        if ($startStopwatch) {
            $this->stopwatch->start($this->getStopwatchName(), $this->sectionName);
        }
    }
895301
public function handleEvent(ActionEvent $event)
    {
        if (!$this->scopeDeterminator->currentScopeIsBackend()) {
            return;
        }

        $environment = $event->getEnvironment();
        $basic       = $environment->getDataDefinition()->getBasicDefinition();
        $action      = $event->getAction();

        if (null !== $event->getResponse()
            || ('showAll' !== $action->getName())
            || !$this->wantToHandle($basic->getMode(), $action)
        ) {
            return;
        }

        if (false !== ($response = $this->process($action, $environment))) {
            $event->setResponse($response);
        }
    }
1002656
public function & SetActionName ($actionName) {
		/** @var $this \MvcCore\Request */
		$this->actionName = $actionName;
		$routerClass = self::$routerClass;
		$router = & $routerClass::GetInstance();
		$this->params[$router::URL_PARAM_ACTION] = $actionName;
		return $this;
	}
1186883
public function setActionOption($actionName, $optionName, $optionValue)
    {
        $this->getAction($actionName)->setOption($optionName, $optionValue);

        return $this;
    }
1224209
public function isAdminActionAllowed(ViewInterface $view, string $actionName)
    {
        $configuration = $view->getAdminConfiguration();

        return key_exists($actionName, $configuration->getParameter('actions'));
    }
456021
private function determineControllerAndAction(&$controller, &$actionName)
    {
        $request = $this->getRequest();
        $this->invokePluginsHook(
            'beforeControllerSelected',
            array($this, $request)
        );

        $controllerDiKey = $request->getController();
        try {
            $controller = $this->getServiceProvider()->getServiceInstance($controllerDiKey);
        } catch (Exception $e) {
            throw new ResourceNotFoundException(sprintf(
                'No such controller found "%s".',
                $this->getRequest()->getController()
            ));
        }
        $actionName = $request->getAction();
        if (!method_exists($controller, $actionName)) {
            throw new ResourceNotFoundException(sprintf(
                '%s does not have method %s',
                $controllerDiKey,
                $actionName
            ));
        }
        $this->invokePluginsHook(
            'afterControllerSelected',
            array($this, $request, $controller, $actionName)
        );
        $controller->initialize($request, $this);
    }
1212867
public function configure(ResourceActionEvent $event)
    {
        $data = $event->getData();
        $this->crud->update(ResourceNode::class, $data);

        $event->setResponse(new JsonResponse($data));
        $event->stopPropagation();
    }
758923
public function configureBatchActions(AdminInterface $admin, array $actions)
    {
        /** @var AbstractAdmin $admin */
        if ($admin->hasRoute('edit') && $admin->hasAccess('edit') && $admin->getList()->has('enabled')) {
            $actions['enable'] = [
            ];

            $actions['disable'] = [
            ];
        }

        return $actions;
    }
1004511
private function translateActionName($actionName)
    {
        switch ($actionName) {
            case 'create':
                return Item::CREATE;
            case 'cut':
                return Item::CUT;
            case 'copy':
                return Item::COPY;
            case 'deepcopy':
                return Item::DEEP_COPY;
            default:
        }
        return null;
    }
984652
public function matchesControllerActionPair($controllerObjectName, $actionName)
    {
        $controllerActionPairs = $this->getControllerActionPairs();
        return isset($controllerActionPairs[$controllerObjectName]) && in_array($actionName, $controllerActionPairs[$controllerObjectName]);
    }
950138
public function execute(Config $config, IO $io, Repository $repository, Config\Action $action) : void
    {
        $originalHookArguments = $io->getArguments();
        $currentGitTag         = $repository->getInfoOperator()->getCurrentTag();

        $io->write('<info>Executing Dummy action</info>');
        $io->write($this->getArgumentOutput($originalHookArguments));
        $io->write('  Current git-tag: <comment>' . $currentGitTag . '</comment>');

        throw new ActionFailed(
            'The \'Debug\' action is only for debugging purposes, ' .
            'please remove the \'Debug\' action from your config'
        );
    }