Class luya\admin\ngrest\plugins\JsonObject

                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($config = [])
{
    if (!empty($config)) {
        Yii::configure($this, $config);
    }
    $this->init();
}

            

                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 addEvent($trigger, $handler)
{
    $this->_events[$trigger] = $handler;
}

            

                protected function appendFieldNgModelContext($field, $context)
{
    return $context . ltrim($field, '.');
}

            

                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 behaviors()
{
    return [];
}

            

                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 createCrudLoaderTag($ngrestModelClass, $ngRestModelSelectMode = null, array $options = [])
{
    if (!method_exists($ngrestModelClass, 'ngRestApiEndpoint')) {
        return null;
    }
    $menu = Yii::$app->adminmenu->getApiDetail($ngrestModelClass::ngRestApiEndpoint(), Yii::$app->request->get('pool'));
    if ($menu) {
        if ($ngRestModelSelectMode) {
            $options['model-setter'] = $ngRestModelSelectMode;
            $options['model-selection'] = 1;
        } else {
            $options['model-selection'] = 0;
        }
        return $this->createTag('crud-loader', null, array_merge(['api' => $menu['route'], 'alias' => $menu['alias']], $options));
    }
    return null;
}

            

                public function createFormTag($name, $id, $ngModel, array $options = [])
{
    $defaultOptions = [
        'fieldid' => $id,
        'model' => $ngModel,
        'label' => $this->alias,
        'fieldname' => $this->name,
        'i18n' => $this->i18n ? 1 : '',
    ];
    // if a condition is available, evalute from given context
    if ($this->condition) {
        $defaultOptions['ng-show'] = $this->getNgShowCondition($ngModel);
    }
    return $this->createTag($name, null, array_merge($options, $defaultOptions));
}

            

                public function createListTag($ngModel, array $options = [])
{
    return $this->createTag('span', null, ArrayHelper::merge(['ng-bind' => $ngModel], $options));
}

            

                public function createSchedulerListTag($ngModel, array $values, $dataRow, array $options = [])
{
    return Angular::schedule($ngModel, $this->alias, 'getRowPrimaryValue('.$dataRow.')', $values, get_class($this->renderContext->getModel()), $this->name, $options)->render();
}

            

                public function createTag($name, $content, array $options = [])
{
    return Html::tag($name, $content, $options);
}

            

                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 events()
{
    return $this->_events;
}

            

                protected function getAttributeValue($event)
{
    $property = $this->name;
    return $event->sender->{$property};
}

            

                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 getNgShowCondition($ngModel)
{
    return Angular::variablizeContext($ngModel, $this->condition, false);
}

            

                public function getServiceName($name)
{
    return 'service.'.$this->name.'.'.$name;
}

            

                public function getSortField()
{
    if ($this->_sortField === false) {
        return [];
    }
    if ($this->_sortField) {
        //
        if (is_array($this->_sortField)) {
            return [$this->name => $this->_sortField];
        }
        return [$this->name => [
            'asc' => [$this->_sortField => SORT_ASC],
            'desc' => [$this->_sortField => SORT_DESC]
        ]];
    }
    return [$this->name];
}

            

                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 i18nDecodedGetActive(array $fieldValues)
{
    trigger_error('deprecated, use I18n::findActive instead. Will be removed in version 5.0', E_USER_DEPRECATED);
    return I18n::findActive($fieldValues);
}

            

                public function i18nFieldDecode($value, $onEmptyValue = '')
{
    trigger_error('deprecated, use I18n::decode instead. Will be removed in version 5.0', E_USER_DEPRECATED);
    return I18n::decode($value, $onEmptyValue);
}

            

                public function i18nFieldEncode($value)
{
    trigger_error('deprecated, use I18n::encode instead. Will be removed in version 5.0', E_USER_DEPRECATED);
    return I18n::encode($value);
}

            

                public function init()
{
    // call parent initializer
    parent::init();
    if ($this->name === null || $this->alias === null || $this->i18n === null) {
        throw new Exception("Plugin attributes name, alias and i18n must be configured.");
    }
    $this->addEvent(NgRestModel::EVENT_BEFORE_VALIDATE, 'onSave');
    $this->addEvent(NgRestModel::EVENT_AFTER_INSERT, 'onAssign');
    $this->addEvent(NgRestModel::EVENT_AFTER_UPDATE, 'onAssign');
    $this->addEvent(NgRestModel::EVENT_AFTER_REFRESH, 'onAssign');
    $this->addEvent(NgRestModel::EVENT_AFTER_FIND, 'onFind');
    $this->addEvent(NgRestModel::EVENT_AFTER_NGREST_FIND, 'onListFind');
    $this->addEvent(NgRestModel::EVENT_AFTER_NGREST_UPDATE_FIND, 'onExpandFind');
    $this->addEvent(NgRestModel::EVENT_SERVICE_NGREST, 'onCollectServiceData');
}

            

                protected function isAttributeWriteable($event)
{
    return ($event->sender->hasAttribute($this->name) || $event->sender->canSetProperty($this->name));
}

            

                public function jsonDecode($value)
{
    return empty($value) ? [] : Json::decode($value);
}

            

                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 onAfterExpandFind($event)
{
    return true;
}

            

                public function onAfterListFind($event)
{
    return true;
}

            

                public function onAssign($event)
{
}

            

                public function onBeforeCollectServiceData($event)
{
    return true;
}

            

                public function onBeforeFind($event)
{
    return true;
}

            

                public function onBeforeListFind($event)
{
    if ($this->beforeListFind) {
        $this->writeAttribute($event, call_user_func_array($this->beforeListFind, [$this->getAttributeValue($event), $event->sender]));
        return false;
    }
    return true;
}

            

                public function onCollectServiceData($event)
{
    if ($this->onBeforeCollectServiceData($event)) {
        $data = $this->serviceData($event);
        if (!empty($data)) {
            $event->sender->addNgRestServiceData($this->name, $data);
        }
    }
}

            

                public function onExpandFind($event)
{
    if ($this->isAttributeWriteable($event) && $this->onBeforeExpandFind($event)) {
        if ($this->i18n) {
            $event->sender->setAttribute(
                $this->name,
                I18n::decode($event->sender->getAttribute($this->name), $this->i18nEmptyValue)
            );
        }
        $this->onAfterExpandFind($event);
    }
}

            

                public function onFind($event)
{
    if ($this->isAttributeWriteable($event) && $this->onBeforeFind($event)) {
        if ($this->i18n) {
            $oldValue = $event->sender->getAttribute($this->name);
            $event->sender->setI18nOldValue($this->name, $oldValue);
            // get the new array value from an i18n json attribute
            $value = I18n::decodeFindActive($oldValue, $this->i18nEmptyValue);
            // set the new attribute value
            $event->sender->setAttribute($this->name, $value);
            // override the old attribute value in order to ensure this attribute is not marked as dirty
            // see: https://github.com/luyadev/luya-module-admin/pull/567
            $event->sender->setOldAttribute($this->name, $value);
        }
        $this->onAfterFind($event);
    }
}

            

                public function onListFind($event)
{
    if ($this->isAttributeWriteable($event) && $this->onBeforeListFind($event)) {
        if ($this->i18n) {
            $event->sender->setAttribute(
                $this->name,
                I18n::decodeFindActive($event->sender->getAttribute($this->name), $this->i18nEmptyValue, Yii::$app->adminLanguage->defaultLanguageShortCode)
            );
        }
        $this->onAfterListFind($event);
    }
}

            

                public function onSave($event)
{
    if ($this->isAttributeWriteable($event) && $this->onBeforeSave($event)) {
        if ($this->i18n) {
            $event->sender->setAttribute($this->name, I18n::encode($event->sender->getAttribute($this->name)));
        }
    }
}

            

                public function removeEvent($trigger)
{
    if (isset($this->_events[$trigger])) {
        unset($this->_events[$trigger]);
    }
}

            

                public function serviceData($event)
{
    return false;
}

            

                public function setSortField($field)
{
    $this->_sortField = $field;
}

            

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

            

                protected function writeAttribute($event, $value)
{
    $property = $this->name;
    $event->sender->{$property} = $value;
}