php yii-base-Behavior类(方法)实例源码

/**
  * @param string|Behavior $behavior
  */
 public function __construct($behavior)
 {
     if ($behavior instanceof Behavior) {
         $this->_behavior = (string) $behavior->className();
     } else {
         if (is_string($behavior)) {
             $this->_behavior = (string) $behavior;
         }
     }
 }

public function init()
 {
     parent::init();
     $mark = $this->multiple ? UploadStrategyFactory::UPLOAD_MULTIPLE : UploadStrategyFactory::UPLOAD_SINGLE;
     $this->uploadStrategy = UploadStrategyFactory::get($mark);
     $this->uploadStrategy->setBehavior($this);
 }

/**
  * @inheritdoc
  */
 public function init()
 {
     parent::init();
     if ($this->mode === self::MODE_EVENT) {
         throw new Exception('TrackableBehavior does not yet support events.');
     }
 }

/**
  * Init
  */
 public function init()
 {
     if ($this->attributes == null) {
         throw new InvalidConfigException('Property "attributes" must be set');
     }
     parent::init();
 }

public function attach($owner)
 {
     parent::attach($owner);
     if (!$this->key) {
         $this->key = constant(get_class($owner) . '::CACHE_KEY');
     }
 }

public function attach($owner)
 {
     parent::attach($owner);
     $owner->on(BaseActiveRecord::EVENT_BEFORE_INSERT, [AdminLogEvent::className(), AdminLogEvent::EVENT_CREATE_ITEM], ['title' => $this->titleAttribute, 'icon' => $this->icon]);
     $owner->on(BaseActiveRecord::EVENT_BEFORE_UPDATE, [AdminLogEvent::className(), AdminLogEvent::EVENT_UPDATE_ITEM], ['title' => $this->titleAttribute, 'icon' => $this->icon]);
     $owner->on(BaseActiveRecord::EVENT_BEFORE_DELETE, [AdminLogEvent::className(), AdminLogEvent::EVENT_DELETE_ITEM], ['title' => $this->titleAttribute, 'icon' => $this->icon]);
 }

/**
  * @inheritdoc
  */
 public function attach($owner)
 {
     parent::attach($owner);
     if (!is_array($this->attributes) || empty($this->attributes)) {
         throw new InvalidParamException('Invalid or empty attributes array.');
     } else {
         foreach ($this->attributes as $attribute => $config) {
             if (!isset($config['path']) || empty($config['path'])) {
                 throw new InvalidParamException('Path must be set for all attributes.');
             }
             if (!isset($config['tempPath']) || empty($config['tempPath'])) {
                 throw new InvalidParamException('Temporary path must be set for all attributes.');
             }
             if (!isset($config['url']) || empty($config['url'])) {
                 $config['url'] = $this->publish($config['path']);
             }
             $this->attributes[$attribute]['path'] = FileHelper::normalizePath(Yii::getAlias($config['path'])) . DIRECTORY_SEPARATOR;
             $this->attributes[$attribute]['tempPath'] = FileHelper::normalizePath(Yii::getAlias($config['tempPath'])) . DIRECTORY_SEPARATOR;
             $this->attributes[$attribute]['url'] = rtrim($config['url'], '/') . '/';
             $validator = Validator::createValidator('string', $this->owner, $attribute);
             $this->owner->validators[] = $validator;
             unset($validator);
         }
     }
 }

/**
  * @inheritdoc
  */
 public function canSetProperty($name, $checkVars = true)
 {
     if (in_array($name, [$this->titleAttribute, $this->keywordsAttribute, $this->descriptionAttribute])) {
         return true;
     }
     return parent::canSetProperty($name, $checkVars);
 }

/**
  * @param \yii\base\Component $owner
  */
 public function attach($owner)
 {
     parent::attach($owner);
     if (!$this->group) {
         $this->group = get_class($this->owner);
     }
 }

/**
  * @inheritdoc
  */
 public function init()
 {
     parent::init();
     if (empty($this->copyTo)) {
         throw new InvalidConfigException('attribute copyTo must be provided');
     }
 }

public function __get($name)
 {
     if ($name == $this->getAttributeName()) {
         return $this->getRelation();
     }
     return parent::__get($name);
 }

/**
  * @inheritdoc
  */
 public function attach($owner)
 {
     parent::attach($owner);
     $validators = $owner->validators;
     foreach ($this->rules as $rule) {
         if ($rule instanceof Validator) {
             $validators->append($rule);
             $this->validators[] = $rule;
             // keep a reference in behavior
         } elseif (is_array($rule) && isset($rule[0], $rule[1])) {
             // attributes, validator type
             $validator = Validator::createValidator($rule[1], $owner, (array) $rule[0], array_slice($rule, 2));
             $validators->append($validator);
             $this->validators[] = $validator;
             // keep a reference in behavior
         } else {
             throw new InvalidConfigException('Invalid validation rule: a rule must specify both attribute names and validator type.');
         }
     }
     $owner->on(ActiveRecord::EVENT_BEFORE_INSERT, function () {
         $this->saveRelatedDir($this->txt, $this->id_field, $this->name_field, $this->classDir);
     });
     $owner->on(ActiveRecord::EVENT_BEFORE_UPDATE, function () {
         $this->saveRelatedDir($this->txt, $this->id_field, $this->name_field, $this->classDir);
     });
 }

/**
  * @inheritdoc
  */
 public function init()
 {
     parent::init();
     if (empty($this->sessionVarName)) {
         throw new InvalidConfigException('The $sessionVarName should be configured for this behavior.');
     }
 }

/**
  * @inheritdoc
  */
 public function init()
 {
     parent::init();
     if (!$this->app_id || !$this->mch_id || !$this->app_key || !$this->app_secret) {
         throw new InvalidConfigException("WxPay::app_id & mch_id & app_key & app_secret are required to be configured.");
     }
 }

/**
  * @inheritdoc
  */
 public function canSetProperty($name, $checkVars = true)
 {
     if (isset($this->attributes[$name]) || $name === $this->flagsAttribute) {
         return true;
     }
     return parent::canSetProperty($name, $checkVars);
 }

public function attach($owner)
 {
     if (!$owner instanceof ShelterInterface) {
         throw new InvalidParamException('$owner must implement ShelterInterface.');
     }
     parent::attach($owner);
 }

/**
  * @inheritdoc
  */
 public function canSetProperty($name, $checkVars = true)
 {
     if ($name === $this->attribute) {
         return true;
     }
     return parent::canSetProperty($name, $checkVars);
 }

/**
  * Indicates whether a property can be read.
  * @param string $name the property name
  * @param boolean $checkVars whether to treat member variables as properties
  */
 public function canGetProperty($name, $checkVars = true)
 {
     if (!in_array($name, $this->attrs)) {
         return parent::canGetProperty($name, $checkVars);
     }
     return true;
 }

public function init()
 {
     parent::init();
     //检查配置
     if ($this->offlinUrl !== null) {
     }
 }

/**
  * @inheritdoc
  */
 public function init()
 {
     parent::init();
     if (empty($this->classes)) {
         throw new InvalidConfigException('"classes" param must be provided');
     }
 }