add action into correct section

@param array $cells
@param string $action
@param string $actionKey
767503
public function addActionToCellGroup(&$cells, $action, $actionKey)
    {
        $cellsMap = [
            'primary'   => [
                'view',
                'edit',
                'hide',
                'delete',
                'stat',
            ],
            'secondary' => [
                'viewBig',
                'history',
                'perms',
                'new',
                'move',
                'moveUp',
                'moveDown',
                'moveLeft',
                'moveRight',
                'version',
            ],
        ];
        $classification = in_array($actionKey, $cellsMap['primary']) ? 'primary' : 'secondary';
        $cells[$classification][$actionKey] = $action;
        unset($cells[$actionKey]);
    }
943546
public function setActions($actions): self
    {
        $this->clearActions();

        foreach ($actions as $action) {
            $this->addAction($action);
        }

        return $this;
    }
1218306
protected function add_actions() {
        do_action('app_before_actions');
		$actionMethos = $this->getMethods("/^action_/");
		sort($actionMethos); //Se ordenas las acciones por prioridad
		$actions = array_map(array($this, 'describeActions'), $actionMethos);
		if ($actions) {
            foreach ($actions as $action) {
                add_action($action->tag, array($this, $action->method), $act->priority, 1);
            }
            do_action('app_after_textdomain');
		}
	}
19356
def addAction(self, action, checked=None, autoBuild=True):
        
        # clear the holder
        actions = self._actionGroup.actions()
        if actions and actions[0].objectName() == 'place_holder':
            self._actionGroup.removeAction(actions[0])
            actions[0].deleteLater()
        
        # create an action from the name
        if not isinstance(action, QAction):
            action_name = nativestring(action)
            action = QAction(action_name, self)
            action.setObjectName(action_name)
            action.setCheckable(self.isCheckable())
            
            # auto-check the first option
            if checked or (not self._actionGroup.actions() and checked is None):
                action.setChecked(True)
        
        elif self.isCheckable():
            action.setCheckable(True)
            if not self.currentAction():
                action.setChecked(True)
        
        self._actionGroup.addAction(action)
        
        if autoBuild:
            self.rebuild()
        
        return action
500884
public function addAction(ActionInterface $action, $callback = null)
    {
        $this->queue[] = array(
            'action'   => $action,
            'callback' => $callback,
        );

        return $this;
    }
213768
function addAction(action, ctrl) {
      this.addActionIcon(action, ctrl);
      if (!this.actionExists(action, ctrl)) {
        ctrl.actionListService.requiredActionsList.splice(action.index, 0, action.name);
        ctrl.actionListService.actionsToIndex[action.name] = action.index;
        ctrl.actionListService.onToggle[action.name] = action.onToggle;
        ctrl.actionListService.actionsToDisplay.unshift(action.name);
      }
    }
573990
function _appendActionToUpdaters(node, actionMap) {
  if (node.members && node.members.static.length) {
    node.members.static = node.members.static.map(nd => _appendActionToUpdaters(nd, actionMap));
  }

  const updater = node.name;

  const action = Object.values(actionMap)
    .find(action => action.updaters.find(up => up.name === updater));

  if (!action) {
    return node;
  }
  const actionName = action.name;

  const mdContent = `
  * __Action__: [${BT}${actionName}${BT}](../actions/actions.md#${actionName.toLowerCase()})
  `;

  return _appendListToDescription(node, mdContent);
}
936285
protected function executeCliAction(Config\Action $action) : void
    {
        // since the cli has no straight way to communicate back to php
        // cli hooks have to handle sync stuff by them self
        // so no 'beforeAction' or 'afterAction' is called here
        $runner = new Action\Cli();
        $runner->execute($this->io, $action, $this->arguments);
    }
781662
protected function addTableAction($action, $row, $btn)
    {
        if (empty($this->tableActions)) {
            $this->tableActions = new Collection();
        }
        $path = uri();
        Event::fire('datatables:' . $path . ':before.action.' . $action, [$this->tableActions, $row]);
        Event::fire(new BeforeTableAction($path, $action, $row, $this->tableActions));
        $this->tableActions->push($btn);
        Event::fire('datatables:' . $path . ':after.action.' . $action, [$this->tableActions, $row]);
        Event::fire(new AfterTableAction($path, $action, $row, $this->tableActions));
        Event::fire('datatables.' . get_class($this) . '.after.action.' . $action, [$this->tableActions, $row]);
        return $this;
    }
862556
def _add_action(self, action):
        
        kwargs = self._get_method_params()

        kwargs['action'] = action

        self._bulk_actions.append(kwargs)
654335
protected function executeAction($actionName, $data)
    {
        $actionManager = $this->getActionManager();

        $currentAction = $actionManager->getAction();

        $actionManager->setAction($actionName);
        $actionManager->run($data);

        $actionManager->setAction($currentAction);
    }
558582
protected function writeFailedActions($fileName, $actions)
    {
        $fileName = $this->basePath . '/' . $fileName;
        $this->filesystem->remove($fileName);
        if (!empty($actions)) $this->encode($fileName, $actions);
    }
166023
public function setAction($actionName){
		$this->_action = new Elements\Hidden();
		$this->_action->setName('action');
		$this->_action->setVal($actionName);
		$this->_action->init();
	}
588085
private void writeActions(List<Action> actions)
            throws JsonGenerationException, IOException {
        List<String> actionStrings = new ArrayList<String>();

        for (Action action : actions) {
            actionStrings.add(action.getActionName());
        }
        writeJsonArray(JsonDocumentFields.ACTION, actionStrings);
    }
186992
public void addCommitAction(final Runnable action) throws HibernateException
	{
		if (action == null)
			return; // ignore null actions

		addAction(new BaseSessionEventListener()
		{
			@Override
			public void transactionCompletion(final boolean successful)
			{
				if (successful)
					action.run();
			}
		});
	}
698937
public function add(RouteConditionInterface $condition, ActionInterface $action, ?string $key = null)
    {
        if (empty($key) || is_numeric($key)) {
            $this->routes[] = compact('condition', 'action');
        } else {
            $this->routes[$key] = compact('condition', 'action');
        }
    }
599565
public function addPostAction($action)
    {
        $mbAction = new MbAction($this->shortcodeAction()->getMbPage(), $this->getName());

        $mbAction->setShortcode(true)->actionResolver($action);

        $this->shortcodePostAction = $mbAction;

        return $this;
    }