Class luya\cms\frontend\controllers\BlockController

                public function __call($name, $params)
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $object) {
        if ($object->hasMethod($name)) {
            return call_user_func_array([$object, $name], $params);
        }
    }
    throw new UnknownMethodException('Calling unknown method: ' . get_class($this) . "::$name()");
}

            

                public function __clone()
{
    $this->_events = [];
    $this->_eventWildcards = [];
    $this->_behaviors = null;
}

            

                public function __construct($id, $module, $config = [])
{
    $this->id = $id;
    $this->module = $module;
    parent::__construct($config);
}

            

                public function __get($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        // read property, e.g. getName()
        return $this->$getter();
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canGetProperty($name)) {
            return $behavior->$name;
        }
    }
    if (method_exists($this, 'set' . $name)) {
        throw new InvalidCallException('Getting write-only property: ' . get_class($this) . '::' . $name);
    }
    throw new UnknownPropertyException('Getting unknown property: ' . get_class($this) . '::' . $name);
}

            

                public function __isset($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        return $this->$getter() !== null;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canGetProperty($name)) {
            return $behavior->$name !== null;
        }
    }
    return false;
}

            

                public function __set($name, $value)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        // set property
        $this->$setter($value);
        return;
    } elseif (strncmp($name, 'on ', 3) === 0) {
        // on event: attach event handler
        $this->on(trim(substr($name, 3)), $value);
        return;
    } elseif (strncmp($name, 'as ', 3) === 0) {
        // as behavior: attach behavior
        $name = trim(substr($name, 3));
        $this->attachBehavior($name, $value instanceof Behavior ? $value : Yii::createObject($value));
        return;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canSetProperty($name)) {
            $behavior->$name = $value;
            return;
        }
    }
    if (method_exists($this, 'get' . $name)) {
        throw new InvalidCallException('Setting read-only property: ' . get_class($this) . '::' . $name);
    }
    throw new UnknownPropertyException('Setting unknown property: ' . get_class($this) . '::' . $name);
}

            

                public function __unset($name)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        $this->$setter(null);
        return;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canSetProperty($name)) {
            $behavior->$name = null;
            return;
        }
    }
    throw new InvalidCallException('Unsetting an unknown or read-only property: ' . get_class($this) . '::' . $name);
}

            

                public function actions()
{
    return [];
}

            

                public function afterAction($action, $result)
{
    $event = new ActionEvent($action);
    $event->result = $result;
    $this->trigger(self::EVENT_AFTER_ACTION, $event);
    return $event->result;
}

            

                public function asJson($data)
{
    $this->response->format = Response::FORMAT_JSON;
    $this->response->data = $data;
    return $this->response;
}

            

                public function asXml($data)
{
    $this->response->format = Response::FORMAT_XML;
    $this->response->data = $data;
    return $this->response;
}

            

                public function attachBehavior($name, $behavior)
{
    $this->ensureBehaviors();
    return $this->attachBehaviorInternal($name, $behavior);
}

            

                public function attachBehaviors($behaviors)
{
    $this->ensureBehaviors();
    foreach ($behaviors as $name => $behavior) {
        $this->attachBehaviorInternal($name, $behavior);
    }
}

            

                public function beforeAction($action)
{
    if (parent::beforeAction($action)) {
        if ($this->enableCsrfValidation && Yii::$app->getErrorHandler()->exception === null && !$this->request->validateCsrfToken()) {
            throw new BadRequestHttpException(Yii::t('yii', 'Unable to verify your data submission.'));
        }
        return true;
    }
    return false;
}

            

                public function behaviors()
{
    return [];
}

            

                public function bindActionParams($action, $params)
{
    if ($action instanceof InlineAction) {
        $method = new \ReflectionMethod($this, $action->actionMethod);
    } else {
        $method = new \ReflectionMethod($action, 'run');
    }
    $args = [];
    $missing = [];
    $actionParams = [];
    $requestedParams = [];
    foreach ($method->getParameters() as $param) {
        $name = $param->getName();
        if (array_key_exists($name, $params)) {
            $isValid = true;
            if (PHP_VERSION_ID >= 80000) {
                $isArray = ($type = $param->getType()) instanceof \ReflectionNamedType && $type->getName() === 'array';
            } else {
                $isArray = $param->isArray();
            }
            if ($isArray) {
                $params[$name] = (array)$params[$name];
            } elseif (is_array($params[$name])) {
                $isValid = false;
            } elseif (
                PHP_VERSION_ID >= 70000
                && ($type = $param->getType()) !== null
                && $type->isBuiltin()
                && ($params[$name] !== null || !$type->allowsNull())
            ) {
                $typeName = PHP_VERSION_ID >= 70100 ? $type->getName() : (string)$type;
                if ($params[$name] === '' && $type->allowsNull()) {
                    if ($typeName !== 'string') { // for old string behavior compatibility
                        $params[$name] = null;
                    }
                } else {
                    switch ($typeName) {
                        case 'int':
                            $params[$name] = filter_var($params[$name], FILTER_VALIDATE_INT, FILTER_NULL_ON_FAILURE);
                            break;
                        case 'float':
                            $params[$name] = filter_var($params[$name], FILTER_VALIDATE_FLOAT, FILTER_NULL_ON_FAILURE);
                            break;
                        case 'bool':
                            $params[$name] = filter_var($params[$name], FILTER_VALIDATE_BOOLEAN, FILTER_NULL_ON_FAILURE);
                            break;
                    }
                    if ($params[$name] === null) {
                        $isValid = false;
                    }
                }
            }
            if (!$isValid) {
                throw new BadRequestHttpException(
                    Yii::t('yii', 'Invalid data received for parameter "{param}".', ['param' => $name])
                );
            }
            $args[] = $actionParams[$name] = $params[$name];
            unset($params[$name]);
        } elseif (
            PHP_VERSION_ID >= 70100
            && ($type = $param->getType()) !== null
            && $type instanceof \ReflectionNamedType
            && !$type->isBuiltin()
        ) {
            try {
                $this->bindInjectedParams($type, $name, $args, $requestedParams);
            } catch (HttpException $e) {
                throw $e;
            } catch (Exception $e) {
                throw new ServerErrorHttpException($e->getMessage(), 0, $e);
            }
        } elseif ($param->isDefaultValueAvailable()) {
            $args[] = $actionParams[$name] = $param->getDefaultValue();
        } else {
            $missing[] = $name;
        }
    }
    if (!empty($missing)) {
        throw new BadRequestHttpException(
            Yii::t('yii', 'Missing required parameters: {params}', ['params' => implode(', ', $missing)])
        );
    }
    $this->actionParams = $actionParams;
    // We use a different array here, specifically one that doesn't contain service instances but descriptions instead.
    if (Yii::$app->requestedParams === null) {
        Yii::$app->requestedParams = array_merge($actionParams, $requestedParams);
    }
    return $args;
}

            

                final protected function bindInjectedParams(\ReflectionType $type, $name, &$args, &$requestedParams)
{
    // Since it is not a builtin type it must be DI injection.
    $typeName = $type->getName();
    if (($component = $this->module->get($name, false)) instanceof $typeName) {
        $args[] = $component;
        $requestedParams[$name] = "Component: " . get_class($component) . " \$$name";
    } elseif ($this->module->has($typeName) && ($service = $this->module->get($typeName)) instanceof $typeName) {
        $args[] = $service;
        $requestedParams[$name] = 'Module ' . get_class($this->module) . " DI: $typeName \$$name";
    } elseif (\Yii::$container->has($typeName) && ($service = \Yii::$container->get($typeName)) instanceof $typeName) {
        $args[] = $service;
        $requestedParams[$name] = "Container DI: $typeName \$$name";
    } elseif ($type->allowsNull()) {
        $args[] = null;
        $requestedParams[$name] = "Unavailable service: $name";
    } else {
        throw new Exception('Could not load required service: ' . $name);
    }
}

            

                public function canGetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (method_exists($this, 'get' . $name) || $checkVars && property_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->canGetProperty($name, $checkVars)) {
                return true;
            }
        }
    }
    return false;
}

            

                public function canSetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (method_exists($this, 'set' . $name) || $checkVars && property_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->canSetProperty($name, $checkVars)) {
                return true;
            }
        }
    }
    return false;
}

            

                public static function className()
{
    return get_called_class();
}

            

                public function createAction($id)
{
    if ($id === '') {
        $id = $this->defaultAction;
    }
    $actionMap = $this->actions();
    if (isset($actionMap[$id])) {
        return Yii::createObject($actionMap[$id], [$id, $this]);
    }
    if (preg_match('/^(?:[a-z0-9_]+-)*[a-z0-9_]+$/', $id)) {
        $methodName = 'action' . str_replace(' ', '', ucwords(str_replace('-', ' ', $id)));
        if (method_exists($this, $methodName)) {
            $method = new \ReflectionMethod($this, $methodName);
            if ($method->isPublic() && $method->getName() === $methodName) {
                return new InlineAction($id, $this, $methodName);
            }
        }
    }
    return null;
}

            

                public function detachBehavior($name)
{
    $this->ensureBehaviors();
    if (isset($this->_behaviors[$name])) {
        $behavior = $this->_behaviors[$name];
        unset($this->_behaviors[$name]);
        $behavior->detach();
        return $behavior;
    }
    return null;
}

            

                public function detachBehaviors()
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $name => $behavior) {
        $this->detachBehavior($name);
    }
}

            

                public function ensureBehaviors()
{
    if ($this->_behaviors === null) {
        $this->_behaviors = [];
        foreach ($this->behaviors() as $name => $behavior) {
            $this->attachBehaviorInternal($name, $behavior);
        }
    }
}

            

                public function findLayoutFile($view)
{
    $module = $this->module;
    $layout = null;
    if (is_string($this->layout)) {
        $layout = $this->layout;
    } elseif ($this->layout === null) {
        while ($module !== null && $module->layout === null) {
            $module = $module->module;
        }
        if ($module !== null && is_string($module->layout)) {
            $layout = $module->layout;
        }
    }
    if ($layout === null) {
        return false;
    }
    if (strncmp($layout, '@', 1) === 0) {
        $file = Yii::getAlias($layout);
    } elseif (strncmp($layout, '/', 1) === 0) {
        $file = Yii::$app->getLayoutPath() . DIRECTORY_SEPARATOR . substr($layout, 1);
    } else {
        $file = $module->getLayoutPath() . DIRECTORY_SEPARATOR . $layout;
    }
    if (pathinfo($file, PATHINFO_EXTENSION) !== '') {
        return $file;
    }
    $path = $file . '.' . $view->defaultExtension;
    if ($view->defaultExtension !== 'php' && !is_file($path)) {
        $path = $file . '.php';
    }
    return $path;
}

            

                public function getBehavior($name)
{
    $this->ensureBehaviors();
    return isset($this->_behaviors[$name]) ? $this->_behaviors[$name] : null;
}

            

                public function getBehaviors()
{
    $this->ensureBehaviors();
    return $this->_behaviors;
}

            

                public function getModuleLayoutViewPath()
{
    if ($this->module->useAppViewPath) {
        return '@app/views/'.$this->module->id.'/';
    }
    
    return '@'.$this->module->id.'/views/';
}

            

                public function getModules()
{
    $modules = [$this->module];
    $module = $this->module;
    while ($module->module !== null) {
        array_unshift($modules, $module->module);
        $module = $module->module;
    }
    return $modules;
}

            

                public function getRoute()
{
    return $this->action !== null ? $this->action->getUniqueId() : $this->getUniqueId();
}

            

                public function getUniqueId()
{
    return $this->module instanceof Application ? $this->id : $this->module->getUniqueId() . '/' . $this->id;
}

            

                public function getView()
{
    if ($this->_view === null) {
        $this->_view = Yii::$app->getView();
    }
    return $this->_view;
}

            

                public function getViewPath()
{
    if ($this->module instanceof Module) {
        if ($this->module->useAppViewPath) {
            return '@app/views/' . $this->module->id . '/' . $this->id;
        } elseif (is_array($this->module->viewMap)) {
            $currentAction = $this->id . '/' . ($this->action ? $this->action->id : $this->defaultAction);
            foreach ($this->module->viewMap as $action => $viewPath) {
                // Special case for map all views of controller
                if ($action === '*') {
                    return $viewPath . '/' . $this->id;
                } elseif (fnmatch($action, $currentAction)) {
                    return $viewPath;
                }
            }
        }
    }
    return parent::getViewPath();
}

            

                public function goBack($defaultUrl = null)
{
    return $this->response->redirect(Yii::$app->getUser()->getReturnUrl($defaultUrl));
}

            

                public function goHome()
{
    return $this->response->redirect(Yii::$app->getHomeUrl());
}

            

                public function hasEventHandlers($name)
{
    $this->ensureBehaviors();
    if (!empty($this->_events[$name])) {
        return true;
    }
    foreach ($this->_eventWildcards as $wildcard => $handlers) {
        if (!empty($handlers) && StringHelper::matchWildcard($wildcard, $name)) {
            return true;
        }
    }
    return Event::hasHandlers($this, $name);
}

            

                public function hasMethod($name, $checkBehaviors = true)
{
    if (method_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->hasMethod($name)) {
                return true;
            }
        }
    }
    return false;
}

            

                public function hasProperty($name, $checkVars = true, $checkBehaviors = true)
{
    return $this->canGetProperty($name, $checkVars, $checkBehaviors) || $this->canSetProperty($name, false, $checkBehaviors);
}

            

                public function init()
{
    parent::init();
    $this->request = Instance::ensure($this->request, Request::className());
    $this->response = Instance::ensure($this->response, Response::className());
}

            

                public function off($name, $handler = null)
{
    $this->ensureBehaviors();
    if (empty($this->_events[$name]) && empty($this->_eventWildcards[$name])) {
        return false;
    }
    if ($handler === null) {
        unset($this->_events[$name], $this->_eventWildcards[$name]);
        return true;
    }
    $removed = false;
    // plain event names
    if (isset($this->_events[$name])) {
        foreach ($this->_events[$name] as $i => $event) {
            if ($event[0] === $handler) {
                unset($this->_events[$name][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            $this->_events[$name] = array_values($this->_events[$name]);
            return true;
        }
    }
    // wildcard event names
    if (isset($this->_eventWildcards[$name])) {
        foreach ($this->_eventWildcards[$name] as $i => $event) {
            if ($event[0] === $handler) {
                unset($this->_eventWildcards[$name][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            $this->_eventWildcards[$name] = array_values($this->_eventWildcards[$name]);
            // remove empty wildcards to save future redundant regex checks:
            if (empty($this->_eventWildcards[$name])) {
                unset($this->_eventWildcards[$name]);
            }
        }
    }
    return $removed;
}

            

                public function on($name, $handler, $data = null, $append = true)
{
    $this->ensureBehaviors();
    if (strpos($name, '*') !== false) {
        if ($append || empty($this->_eventWildcards[$name])) {
            $this->_eventWildcards[$name][] = [$handler, $data];
        } else {
            array_unshift($this->_eventWildcards[$name], [$handler, $data]);
        }
        return;
    }
    if ($append || empty($this->_events[$name])) {
        $this->_events[$name][] = [$handler, $data];
    } else {
        array_unshift($this->_events[$name], [$handler, $data]);
    }
}

            

                public function redirect($url, $statusCode = 302)
{
    // calling Url::to() here because Response::redirect() modifies route before calling Url::to()
    return $this->response->redirect(Url::to($url), $statusCode);
}

            

                public function refresh($anchor = '')
{
    return $this->response->redirect($this->request->getUrl() . $anchor);
}

            

                public function registerAsset($className)
{
    $className::register($this->view);
}

            

                public function render($view, $params = [])
{
    if (!empty($this->module->context) && empty($this->layout)) {
        return $this->renderPartial($view, $params);
    }
    return parent::render($view, $params);
}

            

                public function renderAjax($view, $params = [])
{
    return $this->getView()->renderAjax($view, $params, $this);
}

            

                public function renderContent($content)
{
    $layoutFile = $this->findLayoutFile($this->getView());
    if ($layoutFile !== false) {
        return $this->getView()->renderFile($layoutFile, ['content' => $content], $this);
    }
    return $content;
}

            

                public function renderFile($file, $params = [])
{
    return $this->getView()->renderFile($file, $params, $this);
}

            

                public function renderItem($navItemId, $appendix = null, $setNavItemTypeId = false)
{
    $model = NavItem::find()->where(['id' => $navItemId])->with(['nav'])->one();
    if (!$model) {
        throw new NotFoundHttpException('The requested nav item could not found.');
    }
    Yii::$app->urlManager->contextNavItemId = $navItemId;
    $currentMenu = Yii::$app->menu->current;
    $event = new BeforeRenderEvent();
    $event->menu = $currentMenu;
    foreach ($model->nav->properties as $property) {
        $object = $property->getObject();
        $object->trigger($object::EVENT_BEFORE_RENDER, $event);
        if (!$event->isValid) {
            throw new MethodNotAllowedHttpException('Your are not allowed to see this page.');
            return Yii::$app->end();
        }
    }
    if ($setNavItemTypeId !== false && !empty($setNavItemTypeId)) {
        $model->nav_item_type_id = $setNavItemTypeId;
    }
    $typeModel = $model->getType();
    if (!$typeModel) {
        throw new NotFoundHttpException("The requestd nav item could not be found with the paired type, maybe this version does not exists for this Type.");
    }
    $typeModel->setOptions([
        'navItemId' => $navItemId,
        'restString' => $appendix,
    ]);
    $content = $typeModel->getContent();
    Yii::$app->trigger(self::EVENT_RENDER_CMS_PAGE, new Event(['data' => ['navItemId' => $navItemId]]));
    if ($content instanceof Response) {
        return Yii::$app->end(0, $content);
    }
    // it seems to be a json response as it is an array
    if (is_array($content)) {
        return $content;
    }
    // https://github.com/luyadev/luya/issues/863 - if context controller is not false and the layout variable is not empty, the layout file will be displayed
    // as its already renderd by the module controller itself.
    if ($typeModel->controller !== false && !empty($typeModel->controller->layout)) {
        $this->layout = false;
    }
    // If the user has defined a layout file, this will be ensured and set as layout file.
    $layoutFile = $model->nav->layout_file;
    if (!empty($layoutFile)) {
        $this->layout = StringHelper::startsWith($layoutFile, '@') ? $layoutFile : '/' . ltrim($layoutFile, '/');
    }
    if ($this->view->title === null) {
        if (empty($model->title_tag)) {
            $this->view->title = $model->title;
        } else {
            $this->view->title = $model->title_tag;
        }
    }
    $this->view->registerMetaTag(['property' => 'og:type', 'content' => 'website'], self::META_OG_TYPE);
    $this->view->registerMetaTag(['name' => 'twitter:card', 'content' => 'summary'], self::META_TWITTER_CARD);
    $this->view->registerMetaTag(['property' => 'og:title', 'content' => $this->view->title], self::META_OG_TITLE);
    $this->view->registerMetaTag(['name' => 'twitter:title', 'content' => $this->view->title], self::META_TWITTER_TITLE);
    $this->view->registerMetaTag(['property' => 'og:url', 'content' => Yii::$app->request->absoluteUrl], self::META_OG_URL);
    $this->view->registerMetaTag(['name' => 'twitter:url', 'content' => Yii::$app->request->absoluteUrl], self::META_TWITTER_URL);
    if (!empty($model->description)) {
        $this->view->registerMetaTag(['name' => 'description', 'content' => $model->description], self::META_DESCRIPTION);
        $this->view->registerMetaTag(['property' => 'og:description', 'content' => $model->description], self::META_OG_DESCRIPTION);
        $this->view->registerMetaTag(['name' => 'twitter:description', 'content' => $model->description], self::META_TWITTER_DESCRIPTION);
    }
    if (!empty($model->keywords)) {
        $this->view->registerMetaTag(['name' => 'keywords', 'content' => implode(", ", $currentMenu->keywords)], self::META_KEYWORDS);
    }
    if (!empty($model->image_id)) {
        $image = Yii::$app->storage->getImage($model->image_id);
        if ($image) {
            $this->view->registerMetaTag(['property' => 'og:image', 'content' => $image->applyFilter(LargeThumbnail::identifier())->sourceAbsolute], self::META_OG_IMAGE);
            $this->view->registerMetaTag(['name' => 'twitter:image', 'content' => $image->applyFilter(LargeThumbnail::identifier())->sourceAbsolute], self::META_TWITTER_IMAGE);
        }
    }
    if ($this->module->enableTagParsing) {
        $content = TagParser::convert($content);
    }
    if (Yii::$app->has('adminuser') && !Yii::$app->request->isAjax && !Yii::$app->adminuser->isGuest && $this->module->overlayToolbar === true) {
        $this->view->registerCssFile('//fonts.googleapis.com/icon?family=Material+Icons');
        $this->view->on(View::EVENT_BEGIN_BODY, [$this, 'renderToolbar'], ['content' => $content]);
    }
    return $content;
}

            

                public function renderLayout($view, $params = [])
{
    $content = $this->view->render($view, $params, $this);
    return $this->render($this->getModuleLayoutViewPath().$this->module->moduleLayout, ['content' => $content]);
}

            

                public function renderPartial($view, $params = [])
{
    return $this->getView()->render($view, $params, $this);
}

            

                public function renderToolbar($event)
{
    Yii::info('LUYA CMS Toolbar rendering start', __METHOD__);
    $props = [];
    foreach (Yii::$app->menu->current->model->properties as $prop) {
        $o = $prop->getObject();
        $props[] = ['label' => $o->label(), 'value' => $o->getValue()];
    }
    $menu = Yii::$app->menu;
    // seo keyword frequency
    $seoAlert = 0;
    $keywords = [];
    $content = strip_tags($event->data['content']);
    if (empty($menu->current->description)) {
        $seoAlert++;
    }
    if (empty($menu->current->keywords)) {
        $seoAlert++;
    } else {
        foreach ($menu->current->keywords as $word) {
            if (preg_match_all('/' . preg_quote($word, '/') . '/i', $content, $matches)) {
                $keywords[] = [$word, is_countable($matches[0]) ? count($matches[0]) : 0];
            } else {
                $keywords[] = [$word, 0];
                $seoAlert++;
            }
        }
    }
    // As the view path can not evaluated from controller context, we have to force the viewPath trough
    // the module instance.
    // @see https://github.com/luyadev/luya/issues/1768
    $viewSourcePath = Module::getInstance()->viewPath;
    // echo is used in order to support cases where asset manager is not available
    echo '<style>' . $this->view->renderFile($viewSourcePath . '/inline/toolbar.css') . '</style>';
    // mabye ensure that jquery is loaded,  better put this at the End of body tag
    echo '<script>' . $this->view->renderFile($viewSourcePath . '/inline/toolbar.js') . '</script>';
    echo $this->view->renderFile($viewSourcePath . '/_toolbar.php', [
        'keywords' => $keywords,
        'seoAlertCount' => $seoAlert,
        'menu' => $menu,
        'composition' => Yii::$app->composition,
        'luyaTagParsing' => $event->sender->context->module->enableTagParsing,
        'properties' => $props,
        'theme' => Yii::$app->themeManager->activeTheme,
        'content' => $content,
    ]);
    Yii::info('LUYA CMS Toolbar rendering is finished', __METHOD__);
}

            

                public function run($route, $params = [])
{
    $pos = strpos($route, '/');
    if ($pos === false) {
        return $this->runAction($route, $params);
    } elseif ($pos > 0) {
        return $this->module->runAction($route, $params);
    }
    return Yii::$app->runAction(ltrim($route, '/'), $params);
}

            

                public function runAction($id, $params = [])
{
    $action = $this->createAction($id);
    if ($action === null) {
        throw new InvalidRouteException('Unable to resolve the request: ' . $this->getUniqueId() . '/' . $id);
    }
    Yii::debug('Route to run: ' . $action->getUniqueId(), __METHOD__);
    if (Yii::$app->requestedAction === null) {
        Yii::$app->requestedAction = $action;
    }
    $oldAction = $this->action;
    $this->action = $action;
    $modules = [];
    $runAction = true;
    // call beforeAction on modules
    foreach ($this->getModules() as $module) {
        if ($module->beforeAction($action)) {
            array_unshift($modules, $module);
        } else {
            $runAction = false;
            break;
        }
    }
    $result = null;
    if ($runAction && $this->beforeAction($action)) {
        // run the action
        $result = $action->runWithParams($params);
        $result = $this->afterAction($action, $result);
        // call afterAction on modules
        foreach ($modules as $module) {
            /* @var $module Module */
            $result = $module->afterAction($action, $result);
        }
    }
    if ($oldAction !== null) {
        $this->action = $oldAction;
    }
    return $result;
}

            

                public function setView($view)
{
    $this->_view = $view;
}

            

                public function setViewPath($path)
{
    $this->_viewPath = Yii::getAlias($path);
}

            

                public function trigger($name, Event $event = null)
{
    $this->ensureBehaviors();
    $eventHandlers = [];
    foreach ($this->_eventWildcards as $wildcard => $handlers) {
        if (StringHelper::matchWildcard($wildcard, $name)) {
            $eventHandlers[] = $handlers;
        }
    }
    if (!empty($this->_events[$name])) {
        $eventHandlers[] = $this->_events[$name];
    }
    if (!empty($eventHandlers)) {
        $eventHandlers = call_user_func_array('array_merge', $eventHandlers);
        if ($event === null) {
            $event = new Event();
        }
        if ($event->sender === null) {
            $event->sender = $this;
        }
        $event->handled = false;
        $event->name = $name;
        foreach ($eventHandlers as $handler) {
            $event->data = $handler[1];
            call_user_func($handler[0], $event);
            // stop further handling if the event is handled
            if ($event->handled) {
                return;
            }
        }
    }
    // invoke class-level attached handlers
    Event::trigger($this, $name, $event);
}