Class luya\admin\apis\QueueLogErrorController

                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 actionActiveButton($hash, $id)
{
    $model = $this->findModel($id);
    return $model->handleNgRestActiveButton($hash);
}

            

                public function actionActiveSelection($index)
{
    $class = $this->modelClass;
    $items = $class::findAll(Yii::$app->request->getBodyParam('ids', [0]));
    /** @var NgRestModel $model */
    $model = new $class();
    $activeSelections = $model->getNgRestConfig()->getActiveSelections();
    if (!array_key_exists($index, $activeSelections)) {
        throw new NotFoundHttpException("Unable to find the active selection handler.");
    }
    $object = $activeSelections[$index];
    return $object->handle($items);
}

            

                public function actionActiveWindowCallback()
{
    $config = $this->model->getNgRestConfig();
    $render = new RenderActiveWindowCallback();
    $ngrest = new NgRest($config);
    return $ngrest->render($render);
}

            

                public function actionActiveWindowRender()
{
    // generate ngrest active window
    $render = new RenderActiveWindow();
    $render->setItemId(Yii::$app->request->getBodyParam('itemId', false));
    $render->setActiveWindowHash(Yii::$app->request->getBodyParam('activeWindowHash', false));
    // process ngrest render view with config context
    $ngrest = new NgRest($this->model->getNgRestConfig());
    return [
        'content' => $ngrest->render($render),
        'icon' => $render->getActiveWindowObject()->getIcon(),
        'label' => $render->getActiveWindowObject()->getLabel(),
        'title' => $render->getActiveWindowObject()->getTitle(),
        'requestDate' => time(),
    ];
}

            

                public function actionExport()
{
    $extension = null;
    $mime = null;
    $header = Yii::$app->request->getBodyParam('header', 1);
    $type = Yii::$app->request->getBodyParam('type');
    $attributes = Yii::$app->request->getBodyParam('attributes', []);
    $filter = Yii::$app->request->getBodyParam('filter', null);
    $fields = ArrayHelper::getColumn($attributes, 'value');
    if (!in_array($type, ['xlsx', 'csv'])) {
        throw new InvalidConfigException("Invalid export type");
    }
    switch (strtolower($type)) {
        case "csv":
            $mime = 'application/csv';
            $extension = 'csv';
            break;
        case "xlsx":
            $mime = 'application/vnd.ms-excel';
            $extension = 'xlsx';
            break;
    }
    if (!empty($filter)) {
        $filter = Html::encode($filter);
        $filtersList = $this->model->ngRestFilters();
        if (!array_key_exists($filter, $filtersList)) {
            throw new InvalidCallException("The requested filter '$filter' does not exists in the filter list.");
        }
        $query = $filtersList[$filter]->select($fields)->with($this->getWithRelation('export'));
    } else {
        $query = $this->prepareListQuery()->with($this->getWithRelation('export'))->select($fields);
    }
    $this->appendPoolWhereCondition($query);
    $exportFormatter = $this->model->ngRestExport();
    if (!empty($exportFormatter)) {
        $query = $this->formatExportValues($query, $exportFormatter);
        foreach ($fields as $fieldIndex => $fieldValue) {
            $fields[$fieldIndex] = $this->model->getAttributeLabel($fieldValue);
        }
    }
    $tempData = ExportHelper::$type($query, $fields, (bool) $header, ['sort' => empty($exportFormatter)]);
    $key = uniqid('ngrestexport', true);
    $store = FileHelper::writeFile('@runtime/'.$key.'.tmp', $tempData);
    $menu = Yii::$app->adminmenu->getApiDetail($this->model->ngRestApiEndpoint());
    $route = $menu['route'];
    $route = str_replace("/index", "/export-download", $route);
    if ($store) {
        Yii::$app->session->set('tempNgRestFileName', Inflector::slug($this->model->tableName())  . '-export-'.date("Y-m-d-H-i").'.' . $extension);
        Yii::$app->session->set('tempNgRestFileMime', $mime);
        Yii::$app->session->set('tempNgRestFileKey', $key);
        $url = Url::toRoute(['/'.$route], true);
        $param = http_build_query(['key' => base64_encode($key), 'time' => time()]);
        if (StringHelper::contains('?', $url)) {
            $route = $url . "&" . $param;
        } else {
            $route = $url . "?" . $param;
        }
        return [
            'url' => $route,
        ];
    }
    throw new ErrorException("Unable to write the temporary file. Make sure the runtime folder is writeable.");
}

            

                public function actionFilter($filterName, $query = null)
{
    $model = $this->model;
    $filterName = Html::encode($filterName);
    $filtersList = $model->ngRestFilters();
    if (!array_key_exists($filterName, $filtersList)) {
        throw new InvalidCallException("The requested filter '$filterName' does not exists in the filter list.");
    }
    $this->handleNotifications($this->modelClass, $this->authId);
    $find = $filtersList[$filterName];
    if ($query) {
        foreach ($model->getNgRestPrimaryKey() as $pkName) {
            $searchQuery = $model->ngRestFullQuerySearch($query)->select([$model->tableName() . '.' . $pkName]);
            $find->andWhere(['in', $model->tableName() . '.' . $pkName, $searchQuery]);
        }
    }
    $this->appendPoolWhereCondition($find);
    return new ActiveDataProvider([
        'query' => $find,
        'pagination' => $this->pagination,
        'sort' => [
            'attributes' => $this->generateSortAttributes($model->getNgRestConfig()),
        ]
    ]);
}

            

                public function actionPermissions()
{
    return [];
}

            

                public function actionRelationCall($arrayIndex, $id, $modelClass, $query = null)
{
    $modelClass = base64_decode($modelClass);
    if (!class_exists($modelClass)) {
        throw new InvalidCallException("Unable to find the given class \"$modelClass\".");
    }
    // `findOne((int) $id)`: (int) $id is not required as the value is safed by action param $id
    $model = $modelClass::findOne($id);
    if (!$model) {
        throw new InvalidCallException("Unable to resolve relation call model.");
    }
    /** @var \luya\admin\ngrest\base\NgRestRelationInterface $relation */
    $relation = $model->getNgRestRelationByIndex($arrayIndex);
    if (!$relation) {
        throw new InvalidCallException("Unable to find the given ng rest relation for this index value.");
    }
    $find = $relation->getDataProvider();
    if ($find instanceof ActiveQueryInterface) {
        $find->with($this->getWithRelation('relation-call'));
        $this->appendPoolWhereCondition($find);
    }
    $targetModel = Yii::createObject(['class' => $relation->getTargetModel()]);
    if ($query) {
        foreach ($targetModel->getNgRestPrimaryKey() as $pkName) {
            $searchQuery = $targetModel->ngRestFullQuerySearch($query)->select([$targetModel->tableName() . '.' . $pkName]);
            $find->andWhere(['in', $targetModel->tableName() . '.' . $pkName, $searchQuery]);
        }
    }
    return new ActiveDataProvider([
        'query' => $find,
        'pagination' => $this->pagination,
        'sort' => [
            'attributes' => $this->generateSortAttributes($targetModel->getNgRestConfig()),
        ]
    ]);
}

            

                public function actionSearch($query = null)
{
    if (empty($query)) {
        $query = Yii::$app->request->post('query');
    }
    $find = $this->model->ngRestFullQuerySearch($query);
    $this->appendPoolWhereCondition($find);
    return new ActiveDataProvider([
        'query' => $find->with($this->getWithRelation('search')),
        'pagination' => $this->pagination,
        'sort' => [
            'attributes' => $this->generateSortAttributes($this->model->getNgRestConfig()),
        ]
    ]);
}

            

                public function actionServices()
{
    $settings = [];
    $apiEndpoint = $this->model->ngRestApiEndpoint();
    $userSortSettings = Yii::$app->adminuser->identity->setting->get('ngrestorder.admin/'.$apiEndpoint, false);
    if ($userSortSettings && is_array($userSortSettings)) {
        if ($userSortSettings['sort'] == SORT_DESC) {
            $order = '-'.$userSortSettings['field'];
        } else {
            $order = '+'.$userSortSettings['field'];
        }
        $settings['order'] = $order;
    }
    $userFilter = Yii::$app->adminuser->identity->setting->get('ngrestfilter.admin/'.$apiEndpoint, false);
    if ($userFilter) {
        $settings['filterName'] = $userFilter;
    }
    $modelClass = $this->modelClass;
    // check if taggable exists, if yes return all used tags for the
    if (ObjectHelper::isTraitInstanceOf($this->model, TaggableTrait::class)) {
        $tags = ArrayHelper::toArray($this->model->findTags(), [
            Tag::class => ['id', 'name']
        ]);
    } else {
        $tags = false;
    }
    $notificationMuteState = false;
    $userAuthNotificationModel = UserAuthNotification::find()->where(['user_id' => Yii::$app->adminuser->id, 'auth_id' => $this->authId])->one();
    if ($userAuthNotificationModel) {
        $notificationMuteState = $userAuthNotificationModel->is_muted;
    }
    return [
        'service' => $this->model->getNgRestServices(),
        '_authId' => $this->authId,
        '_tags' => $tags,
        '_hints' => $this->model->attributeHints(),
        '_settings' => $settings,
        '_notifcation_mute_state' => $notificationMuteState,
        '_locked' => [
            'data' => UserOnline::find()
                ->select(['user_id', 'lock_pk', 'last_timestamp', 'firstname', 'lastname', 'admin_user.id'])
                ->where(['lock_table' => $modelClass::tableName()])
                ->joinWith('user')
                ->asArray()
                ->all(),
            'userId' => Yii::$app->adminuser->id,
        ],
    ];
}

            

                public function actionToggleNotification()
{
    $newMuteState = Yii::$app->request->getBodyParam('mute');
    $model = UserAuthNotification::find()->where(['user_id' => Yii::$app->adminuser->id, 'auth_id' => $this->authId])->one();
    if ($model) {
        $model->is_muted = (int) $newMuteState;
        $model->save();
    } else {
        $model = new UserAuthNotification();
        $model->is_muted = (int) $newMuteState;
        $model->auth_id = $this->authId;
        $model->user_id = Yii::$app->adminuser->id;
        $model->model_class = $this->modelClass;
    }
    return $model;
}

            

                public function actionUnlock()
{
    UserOnline::unlock(Yii::$app->adminuser->id);
}

            

                public function actions()
{
    $actions = [
        'index' => [ // for casual api request behavior
            'class' => 'luya\admin\ngrest\base\actions\IndexAction',
            'modelClass' => $this->modelClass,
            'checkAccess' => [$this, 'checkAccess'],
            'prepareActiveDataQuery' => [$this, 'prepareIndexQuery'],
            'dataFilter' => $this->getDataFilter(),
        ],
        'list' => [ // for ngrest list
            'class' => 'luya\admin\ngrest\base\actions\IndexAction',
            'modelClass' => $this->modelClass,
            'checkAccess' => [$this, 'checkAccess'],
            'prepareActiveDataQuery' => [$this, 'prepareListQuery'],
            'dataFilter' => $this->getDataFilter(),
        ],
        'view' => [
            'class' => 'luya\admin\ngrest\base\actions\ViewAction',
            'modelClass' => $this->modelClass,
            'checkAccess' => [$this, 'checkAccess'],
        ],
        'create' => [
            'class' => 'luya\admin\ngrest\base\actions\CreateAction',
            'modelClass' => $this->modelClass,
            'checkAccess' => [$this, 'checkAccess'],
            'scenario' => $this->createScenario,
        ],
        'update' => [
            'class' => 'luya\admin\ngrest\base\actions\UpdateAction',
            'modelClass' => $this->modelClass,
            'checkAccess' => [$this, 'checkAccess'],
            'scenario' => $this->updateScenario,
        ],
        'delete' => [
            'class' => 'luya\admin\ngrest\base\actions\DeleteAction',
            'modelClass' => $this->modelClass,
            'checkAccess' => [$this, 'checkAccess'],
        ],
        'options' => [
            'class' => 'luya\admin\ngrest\base\actions\OptionsAction',
        ],
    ];
    if ($this->truncateAction) {
        $actions['truncate'] = [
            'class' => 'luya\admin\ngrest\base\actions\TruncateAction',
            'modelClass' => $this->modelClass,
            'checkAccess' => [$this, 'checkAccess'],
        ];
    }
    if ($this->enableCors) {
        $actions['options']['class'] = 'luya\admin\ngrest\base\actions\OptionsAction';
    }
    return $actions;
}

            

                public function addActionPermission($type, $actions)
{
    foreach ((array) $actions as $actionName) {
        $this->_actionPermissions[$actionName] = $type;
    }
}

            

                public function afterAction($action, $result)
{
    $result = parent::afterAction($action, $result);
    return $this->serializeData($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)) {
        return $this->isActionAllowed($action->id);
    }
    return false;
}

            

                public function behaviors()
{
    return [
        'contentNegotiator' => [
            'class' => ContentNegotiator::className(),
            'formats' => [
                'application/json' => Response::FORMAT_JSON,
                'application/xml' => Response::FORMAT_XML,
            ],
        ],
        'verbFilter' => [
            'class' => VerbFilter::className(),
            'actions' => $this->verbs(),
        ],
        'authenticator' => [
            'class' => CompositeAuth::className(),
        ],
        'rateLimiter' => [
            'class' => RateLimiter::className(),
        ],
    ];
}

            

                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 canApiUserAccess()
{
    if ($this->userAuthClass()->identity->is_api_user && !$this->_module->apiUserAllowActionsWithoutPermissions) {
        throw new ForbiddenHttpException("This controller ({$this->id}) action is forbidden for API users unless apiUserAllowActionsWithoutPermissions is enabled in admin module config.");
    }
}

            

                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 function checkAccess($action, $model = null, $params = [])
{
    // use the check access method to ensure whether a certain item is valid to a certain user or not.
    // the main purpose of validation whether the action can be access or not is done in {{isActionAllowed()}}
    // which runs always in {{beforeAction()}}.
}

            

                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 findModel($id)
{
    $model = $this->findModelClassObject($this->modelClass, $id, 'view');
    if (!$model) {
        throw new NotFoundHttpException("Unable to find the Model for the given ID");
    }
    return $model;
}

            

                public function findModelClassObject($modelClass, $id, $relationContext)
{
    // returns an array with the names of the primary keys
    $keys = $modelClass::primaryKey();
    if ((is_countable($keys) ? count($keys) : 0) > 1) {
        $values = explode(',', $id);
        if ((is_countable($keys) ? count($keys) : 0) === count($values)) {
            return $this->findModelFromCondition($values, $keys, $modelClass, $relationContext);
        }
    } elseif ($id !== null) {
        return $this->findModelFromCondition([$id], $keys, $modelClass, $relationContext);
    }
    return false;
}

            

                protected function findModelFromCondition(array $values, array $keys, $modelClass, $relationContext)
{
    $condition = array_combine($keys, $values);
    // If an api user the internal find methods are used to find items.
    if (!Yii::$app->adminuser->isGuest && Yii::$app->adminuser->identity->is_api_user) {
        // api calls will always use the "original" find method which is based on yii2 guide the best approach to hide given data by default.
        $findModelInstance = $modelClass::find();
    } else {
        // if its an admin user which is browsing the ui the internal ngRestFind method is used.
        $findModelInstance = $modelClass::ngRestFind();
    }
    return $findModelInstance->andWhere($condition)->with($this->getWithRelation($relationContext))->one();
}

            

                public function generateSortAttributes(Config $config)
{
    $sortAttributes = [];
    foreach ($config->getPointerPlugins('list') as $plugin) {
        $sortAttributes = ArrayHelper::merge($plugin->getSortField(), $sortAttributes);
    }
    return $sortAttributes;
}

            

                public function getActionPermissions()
{
    foreach ($this->actionPermissions() as $type => $actionName) {
        $this->addActionPermission($actionName, $type);
    }
    return $this->_actionPermissions;
}

            

                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 getCompositeAuthMethods()
{
    return [
        QueryParamAuth::class,
        HttpBearerAuth::class,
    ];
}

            

                public function getDataFilter()
{
    if ($this->filterSearchModelClass) {
        return [
            'class' => 'yii\data\ActiveDataFilter',
            'searchModel' => $this->filterSearchModelClass,
        ];
    }
    return null;
}

            

                public function getModel()
{
    if ($this->_model === null) {
        $this->_model = Yii::createObject($this->modelClass);
        if (!$this->_model instanceof NgRestModelInterface) {
            throw new InvalidConfigException("The modelClass '$this->modelClass' must be an instance of NgRestModelInterface.");
        }
    }
    return $this->_model;
}

            

                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->_viewPath === null) {
        $this->_viewPath = $this->module->getViewPath() . DIRECTORY_SEPARATOR . $this->id;
    }
    return $this->_viewPath;
}

            

                public function getWithRelation($actionName)
{
    $expand = Yii::$app->request->get('expand', '');
    $relationPrefixes = [];
    foreach (StringHelper::explode($expand, ',', true, true) as $relation) {
        // check for subrelation dot notation.
        $relationPrefixes[] = current(explode(".", $relation));
    }
    // no expand param found, return empty array which means no relations to load
    if (empty($relationPrefixes)) {
        return [];
    }
    $withRelations = $this->withRelations();
    foreach ($withRelations as $relationName) {
        // it seem to be the advance strucutre for given actions.
        if (is_array($relationName) && isset($withRelations[$actionName])) {
            return $this->relationsFromExpand($withRelations[$actionName], $relationPrefixes);
        }
    }
    // simple structure
    return $this->relationsFromExpand($withRelations, $relationPrefixes);
}

            

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

            

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

            

                protected function handleNotifications($modelClass, $authId)
{
    // find the latest primary key value and store into row notifications user auth table
    $pkValue = Json::encode($modelClass::findLatestPrimaryKeyValue());
    $model = UserAuthNotification::find()->where(['user_id' => Yii::$app->adminuser->id, 'auth_id' => $authId])->one();
    if ($model) {
        $model->model_latest_pk_value = $pkValue;
        $model->model_class = $modelClass::className();
        return $model->save();
    }
    $model = new UserAuthNotification();
    $model->auth_id = $authId;
    $model->user_id = Yii::$app->adminuser->id;
    $model->model_latest_pk_value = $pkValue;
    $model->model_class = $modelClass::className();
    return $model->save();
}

            

                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();
    if ($this->modelClass === null) {
        throw new InvalidConfigException("The property `modelClass` must be defined by the Controller.");
    }
    $this->addActionPermission(Auth::CAN_VIEW, [
        'index', 'view', 'services', 'search', 'relation-call', 'filter', 'export', 'list', 'toggle-notification',
    ]);
    $this->addActionPermission(Auth::CAN_CREATE, [
        'create',
    ]);
    $this->addActionPermission(Auth::CAN_UPDATE, [
        'active-window-render', 'active-window-callback', 'active-button', 'update',
    ]);
    $this->addActionPermission(Auth::CAN_DELETE, [
        'delete', 'truncate',
    ]);
}

            

                public function isActionAllowed($action)
{
    if ($this->isActionAuthOptional($action)) {
        return true;
    }
    // a permission action exists, ensure if user has permission for this action or not:
    if (array_key_exists($action, $this->getActionPermissions())) {
        $type = $this->getActionPermissions()[$action];
        if (!in_array($type, [false, Auth::CAN_CREATE, Auth::CAN_DELETE, Auth::CAN_UPDATE, Auth::CAN_VIEW], true)) {
            throw new InvalidConfigException("Invalid type \"$type\" of action permission.");
        }
        $this->authId = Yii::$app->auth->matchApi($this->userAuthClass()->identity, $this->id, $type);
        if (!$this->authId) {
            throw new ForbiddenHttpException("User is unable to access the API \"{$this->id}\" due to insufficient permissions.");
        }
    } else {
        // there is no permission for the given api and action id, ensure api user access.
        $this->canApiUserAccess();
    }
    UserOnline::refreshUser($this->userAuthClass()->identity, $action);
    return true;
}

            

                public function isActionAuthOptional($actionId)
{
    if ($this->enableCors && Yii::$app->request->isOptions) {
        return true;
    }
    return in_array($actionId, $this->authOptional);
}

            

                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 prepareIndexQuery()
{
    /* @var $modelClass \yii\db\BaseActiveRecord */
    $modelClass = $this->modelClass;
    return $modelClass::find()->with($this->getWithRelation('index'));
}

            

                public function prepareListQuery()
{
    /* @var $modelClass \yii\db\BaseActiveRecord */
    $modelClass = $this->modelClass;
    $find = $modelClass::ngRestFind();
    $this->handleNotifications($modelClass, $this->authId);
    // check if a pool id is requested:
    $this->appendPoolWhereCondition($find);
    // add tags condition
    $tagIds = Yii::$app->request->get('tags');
    if ($tagIds) {
        $subQuery = clone $find;
        $inQuery = $subQuery->joinWith(['tags tags'])->andWhere(['tags.id' => array_unique(explode(",", $tagIds))])->select(['pk_id']);
        $find->andWhere(['in', $modelClass::primaryKey(), $inQuery]);
    }
    return $find->with($this->getWithRelation('list'));
}

            

                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 render($view, $params = [])
{
    $content = $this->getView()->render($view, $params, $this);
    return $this->renderContent($content);
}

            

                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 renderPartial($view, $params = [])
{
    return $this->getView()->render($view, $params, $this);
}

            

                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 sendArrayError(array $errors)
{
    return RestHelper::sendArrayError($errors);
}

            

                public function sendModelError(Model $model)
{
    return RestHelper::sendModelError($model);
}

            

                protected function serializeData($data)
{
    return Yii::createObject($this->serializer)->serialize($data);
}

            

                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);
}

            

                public function userAuthClass()
{
    return Yii::$app->adminuser;
}

            

                protected function verbs()
{
    return [
        'index' => ['GET', 'HEAD'],
        'view' => ['GET', 'HEAD'],
        'create' => ['POST'],
        'update' => ['PUT', 'PATCH'],
        'delete' => ['DELETE'],
    ];
}

            

                public function withRelations()
{
    return [];
}