Returns the camel cased name of the Blueprint.
Used for route names.
If the $actionName parameter is provided
then it will be concatenated onto the end of the route.

@param string $actionName
@return string
346448
public function getRouteName($actionName = null) {
        $name = Str::camel($this->pluralName);

        return $actionName == null ? $name : $name . '.' . $actionName;
    }
827732
public function getRouteByName($routeName)
    {
        if (!empty($this->routeNameMap[$routeName])) {
            return $this->routeNameMap[$routeName];
        }

        return null;
    }
856410
public function actionTypeTemplate($schemaName = null)
    {
        if ($schemaName === null) {
            $schemaName = 'public';
        }
        return [
            'exists' => (new Query())
                ->select('typname')
                ->from('pg_type')
                ->where('typname=:value', [':value' => 'action_type'])->exists($this->db),
            'up' => "CREATE TYPE $schemaName.action_type AS ENUM ('INSERT', 'SELECT', 'UPDATE', 'DELETE', 'TRUNCATE')",
            'down' => "DROP TYPE $schemaName.action_type",
        ];
    }
698020
protected function getRouteName($name)
    {
        $name = Str::replaceFirst($this->getDefaultNamespace(trim($this->rootNamespace(), '\\')).'\\', '', $name);
        $name = 'Api\\'.Str::replaceLast('Controller', '', $name);
        $names = explode('\\', $name);
        foreach ($names as $key => $value) {
            $names[$key] = snake_case($value);
        }
        if ($this->option('parent') && count($names) >= 2) {
            $model = str_plural(array_pop($names));
            $parent = str_plural(array_pop($names));
            array_push($names, $parent, $model);
        } elseif (($this->option('model') || $this->option('resource')) && count($names) >= 1) {
            $model = str_plural(array_pop($names));
            array_push($names, $model);
        }
        $name = implode('.', $names);

        return str_replace('\\', '.', $name);
    }
685888
protected function getsignalName( $triggerName, $operationName )
    {
        if ( !isset( self::$signalMapping[$operationName][$triggerName] ) )
        {
            return $triggerName . '_' . $operationName;
        }

        return self::$signalMapping[$operationName][$triggerName];
    }
938377
protected function actionPath($s)
    {
        $s = preg_replace('#(.)(?=[A-Z])#', '$1-', $s);
        $s = strtolower($s);
        $s = rawurlencode($s);

        return $s;
    }
832234
@Override
    public String fromActionNameToPath(final String actionName) {
        if (!actionName.endsWith(actionSuffix)) {
            throw new IllegalArgumentException(actionName);
        }
        String name = actionName.substring(0, actionName.length() - actionSuffix.length());
        return adjustViewRootPath() + "/" + name.replace(PACKAGE_SEPARATOR, '/') + viewExtension;
    }
609557
public function name()
    {
        if ($name = $this->route->getName()) {
            return $name;
        }

        $name = $this->route->getActionName();

        if ($name === 'Closure') {
            return null;
        }

        $namespace = array_get($this->route->getAction(), 'namespace');

        return str_replace($namespace . '\\', '', $name);
    }
488676
public function baseName($baseName = null)
    {
        if ($baseName !== null) {
            $this->baseName = rtrim($baseName, '/') . '/';
        }

        return $this->baseName;
    }
401719
protected function getModelRouteNameSegment($routeName = null)
    {
        $routeName = $routeName ?: $this->getRouteName();

        $combinedPrefix = config('cms-core.route.name-prefix')
                        . config('cms-models.route.name-prefix')
                        . static::MODEL_ROUTE_NAME_PREFIX;

        if ( ! starts_with($routeName, $combinedPrefix)) {
            return false;
        }

        return substr($routeName, strlen($combinedPrefix));
    }
1354564
protected function isActionAllowed($actionName)
    {
        switch ($actionName) {
            // autocomplete action is mapped to list action for access permissions
            case 'autocomplete':
            // embeddedList action is mapped to list action for access permissions
            case 'embeddedList':
                $actionName = 'list';
                break;
            // newAjax action is mapped to new action for access permissions
            case 'newAjax':
                $actionName = 'new';
                break;
            default:
                break;
        }

        // Get item for edit/show or custom actions => security voters may apply
        $easyadmin = $this->request->attributes->get('easyadmin');
        $subject = $easyadmin['item'] ?? null;
        $this->get(AdminAuthorizationChecker::class)->checksUserAccess($this->entity, $actionName, $subject);

        return parent::isActionAllowed($actionName);
    }
208593
protected function getRealAssetName($assetName)
    {
        $prefix = 0 === strpos($assetName, '?') ? '?' : '';
        $assetName = ltrim($assetName, '?');

        if (null !== $this->replacementManager && $this->replacementManager->hasReplacement($assetName)) {
            $assetName = $this->replacementManager->getReplacement($assetName);
        }

        return $prefix.$assetName;
    }
293561
function splitActionName(actionName) {
    if(actionName.indexOf('_') > 0) return actionName.split('_')
    else return actionName.split(/(?=[A-Z])/).map(p => p.toLowerCase())
}
1123055
public function getActionName()
        {
            if (null === $this->_action) {
                $this->_action = $this->getParam($this->getActionKey());
            }

            return $this->_action;
        }
731153
public function getActionModel($actionName) {
		if (isset($this->actions[$actionName])) {
			return $this->actions[$actionName]['model'];
		}

		return mull;
	}
1020452
public function getActionRequestByName($actionName)
    {
        // If action name level separator is in the string, we split
        $actionNameFirstPart = $actionNameSecondPart = "";
        if (strpos($actionName, self::API_NAME_LEVEL_SEPARATOR) === 0) {
            throw new BadApiConfigurationException(
                sprintf(
                    '[%s] Action name \'%s\' is not well formed. It should contain two parts separated by \'%s\'.',
                    $actionName,
                    self::API_NAME_LEVEL_SEPARATOR,
                    $this->getApiName()
                )
            );
        } else {
            $actionParts = explode(self::API_NAME_LEVEL_SEPARATOR, $actionName);
            if (isset($actionParts[0]) && isset($actionParts[1])) {
                $actionNameFirstPart  = $actionParts[0];
                $actionNameSecondPart = $actionParts[1];
            }
        }

        // Action is configured?
        if (!isset($this->actions[$actionNameFirstPart][$actionNameSecondPart])) {
            if ($this->getInitAllActions()) {
                throw new NotConfiguredActionException(
                    sprintf(
                        '[%s] No action configured with the following name: %s%s%s. Given action name was: %s',
                        $this->getApiName(),
                        $actionNameFirstPart,
                        self::API_NAME_LEVEL_SEPARATOR,
                        $actionNameSecondPart,
                        $actionName
                    ),
                    $actionName
                );
            } else {
                // We check if the requested action has a configuration
                if (!isset($this->actionsConfig[$actionNameFirstPart])
                    && !isset($this->actionsConfig[$actionNameFirstPart][$actionNameSecondPart])
                ) {
                    throw new NotConfiguredActionException(
                        sprintf(
                            '[%s] No action configuration found for the following action name: %s',
                            $this->getApiName(),
                            $actionName
                        ),
                        $actionName
                    );
                }

                // If configuration is found, then we create the action
                $this->setActionRequest(
                    $this->actionsConfig[$actionNameFirstPart][$actionNameSecondPart],
                    $actionNameFirstPart,
                    $actionNameSecondPart,
                    $this->actionsCommonConfig
                );
            }
        }

        // Returning action object
        return $this->actions[$actionNameFirstPart][$actionNameSecondPart];
    }
152318
public static function generateCapabilityName(string $controllerName, string $action): string
    {
        $result = 'cap__' . $controllerName . '__' . $action;

        return $result;
    }