PHP __d函数代码示例

 /**
  * Setup the config based on either the Configure::read() values
  * or the PaypalIpnConfig in config/paypal_ipn_config.php
  *
  * Will attempt to read configuration in the following order:
  *   Configure::read('PaypalIpn')
  *   App::import() of config/paypal_ipn_config.php
  *   App::import() of plugin's config/paypal_ipn_config.php
  */
 function __construct()
 {
     $this->config = Configure::read('PaypalIpn');
     if (empty($this->config)) {
         $importConfig = array('type' => 'File', 'name' => 'PaypalIpn.PaypalIpnConfig', 'file' => CONFIGS . 'paypal_ipn_config.php');
         if (!class_exists('PaypalIpnConfig')) {
             App::import($importConfig);
         }
         if (!class_exists('PaypalIpnConfig')) {
             // Import from paypal plugin configuration
             $importConfig['file'] = 'config' . DS . 'paypal_ipn_config.php';
             App::import($importConfig);
         }
         if (!class_exists('PaypalIpnConfig')) {
             trigger_error(__d('paypal_ipn', 'PaypalIpnConfig: The configuration could not be loaded.', true), E_USER_ERROR);
         }
         if (!PHP5) {
             $config =& new PaypalIpnConfig();
         } else {
             $config = new PaypalIpnConfig();
         }
         $vars = get_object_vars($config);
         foreach ($vars as $property => $configuration) {
             if (strpos($property, 'encryption_') === 0) {
                 $name = substr($property, 11);
                 $this->encryption[$name] = $configuration;
             } else {
                 $this->config[$property] = $configuration;
             }
         }
     }
     parent::__construct();
 }

 /**
  * Overide before validate of UploadBehavior plugin processing.
  *
  * @param Model $model Model instance
  * @param array $options Options passed from Model::save().
  * @return bool
  */
 public function beforeValidate(Model $model, $options = array())
 {
     // only run in step validate
     if (!isset($model->data[$model->alias]['upload_flag'])) {
         return parent::beforeValidate($model, $options);
     }
     foreach ($this->settings[$model->alias] as $field => $options) {
         if (!empty($model->data[$model->alias][$field]) && $this->_isUrl($model->data[$model->alias][$field])) {
             $uri = $model->data[$model->alias][$field];
             if (!$this->_grab($model, $field, $uri)) {
                 $model->invalidate($field, __d('upload', 'File was not downloaded.', true));
                 return false;
             }
         }
         // unset if uploaded
         if (empty($model->data[$model->alias][$field]['name']) && !empty($model->data[$model->alias][$field . '_uploaded'])) {
             // if field is empty, don't delete/nullify existing file
             unset($model->data[$model->alias][$field]);
             continue;
         }
         // set data to validate
         $this->runtime[$model->alias][$field] = $model->data[$model->alias][$field];
     }
     return true;
 }

 public function beforeSave($options = array())
 {
     //when password field
     if (isset($this->data[$this->alias]['password']) && isset($this->data[$this->alias]['password2'])) {
         if (empty($this->data[$this->alias]['password']) && empty($this->data[$this->alias]['password2'])) {
             unset($this->data[$this->alias]['password']);
             unset($this->data[$this->alias]['password2']);
         } elseif (!empty($this->data[$this->alias]['password'])) {
             if ($this->data[$this->alias]['password'] != $this->data[$this->alias]['password2']) {
                 $this->invalidate('password', __d('backend', "The passwords do not match"));
                 $this->invalidate('password2', __d('backend', "The passwords do not match"));
                 $this->data[$this->alias]['password2'] = null;
                 return false;
             }
         }
     } elseif (isset($this->data[$this->alias]['password'])) {
         $this->invalidate('password', __d('backend', 'Password verification not submitted'));
         $this->invalidate('password2', __d('backend', 'Password verification not submitted'));
         return false;
     }
     if (isset($this->data[$this->alias]['password']) && !empty($this->data[$this->alias]['password'])) {
         $this->data[$this->alias]['password'] = AuthComponent::password($this->data[$this->alias]['password']);
     }
     return true;
 }

 public function createDatabaseFile($data)
 {
     App::uses('File', 'Utility');
     App::uses('ConnectionManager', 'Model');
     $config = $this->defaultConfig;
     foreach ($data['Install'] as $key => $value) {
         if (isset($data['Install'][$key])) {
             $config[$key] = $value;
         }
     }
     $result = copy(APP . 'Config' . DS . 'database.php.install', APP . 'Config' . DS . 'database.php');
     if (!$result) {
         return __d('croogo', 'Could not copy database.php file.');
     }
     $file = new File(APP . 'Config' . DS . 'database.php', true);
     $content = $file->read();
     foreach ($config as $configKey => $configValue) {
         $content = str_replace('{default_' . $configKey . '}', $configValue, $content);
     }
     if (!$file->write($content)) {
         return __d('croogo', 'Could not write database.php file.');
     }
     try {
         ConnectionManager::create('default', $config);
         $db = ConnectionManager::getDataSource('default');
     } catch (MissingConnectionException $e) {
         return __d('croogo', 'Could not connect to database: ') . $e->getMessage();
     }
     if (!$db->isConnected()) {
         return __d('croogo', 'Could not connect to database.');
     }
     return true;
 }

 /**
  * ConfirmableBehaviorTest::testBasicValidation()
  *
  * @return void
  */
 public function testValidationThatHasBeenModifiedBefore()
 {
     $this->Articles = TableRegistry::get('SluggedArticles');
     /*
     $this->Articles->validator()->add('confirm', 'notBlank', [
     		'rule' => function ($value, $context) {
     			return !empty($value);
     		},
     		'message' => __('Please select checkbox to continue.'),
     		'requirePresence' => true,
     		'allowEmpty' => false,
     		'last' => true,
     	]);
     $this->Articles->validator()->remove('confirm');
     */
     $this->Articles->addBehavior('Tools.Confirmable');
     $animal = $this->Articles->newEntity();
     $data = ['name' => 'FooBar', 'confirm' => '0'];
     $animal = $this->Articles->patchEntity($animal, $data);
     $this->assertNotEmpty($animal->errors());
     $this->assertSame(['confirm' => ['notBlank' => __d('tools', 'Please confirm the checkbox')]], $animal->errors());
     $data = ['name' => 'FooBar', 'confirm' => '1'];
     $animal = $this->Articles->patchEntity($animal, $data);
     $this->assertEmpty($animal->errors());
 }

 /**
  * Initializes git, makes tmp folders writeable, and adds the core submodules (or specified group)
  *
  * @return void
  */
 public function init($working)
 {
     $this->out(__d('baking_plate', "\n<info>Making temp folders writeable...</info>"));
     $tmp = array('tmp' . DS . 'cache', 'tmp' . DS . 'cache' . DS . 'models', 'tmp' . DS . 'cache' . DS . 'persistent', 'tmp' . DS . 'cache' . DS . 'views', 'tmp' . DS . 'logs', 'tmp' . DS . 'sessions', 'tmp' . DS . 'tests', 'webroot' . DS . 'ccss', 'webroot' . DS . 'cjs', 'webroot' . DS . 'uploads');
     foreach ($tmp as $dir) {
         if (!is_dir($working . DS . $dir)) {
             $this->out(__d('baking_plate', "\n<info>Creating Directory %s with permissions 0777</info>", $dir));
             mkdir($working . DS . $dir, 0777);
         } else {
             $this->out(__d('baking_plate', "\n<info>Setting Permissions of %s to 0777</info>", $dir));
             chmod($working . DS . $dir, 0777);
         }
     }
     $this->nl();
     chdir($working);
     $this->out();
     $this->out(passthru('git init'));
     $this->all();
     $this->args = null;
     if (!file_exists($working . 'Config' . DS . 'database.php')) {
         $this->DbConfig->path = $working . 'Config' . DS;
         $this->out();
         $this->out(__d('baking_plate', '<warning>Your database configuration was not found. Take a moment to create one.</warning>'));
         $this->DbConfig->execute();
     }
 }

 /**
  * Getter
  *
  * @param string $name
  * @throws RuntimeException
  * @return void
  */
 public function __get($name)
 {
     if ($name === 'createVersions') {
         throw new \RuntimeException(__d('file_storage', 'createVersions was removed, see the change log'));
     }
     parent::__get($name);
 }

 /**
  * Adds or drops the specified column.
  *
  * @return bool
  */
 public function main()
 {
     $options = (array) $this->params;
     $options['bundle'] = empty($options['bundle']) ? null : $options['bundle'];
     if (empty($options['use'])) {
         $this->err(__d('eav', 'You must indicate a table alias name using the "--use" option. Example: "Articles.Users"'));
         return false;
     }
     try {
         $table = TableRegistry::get($options['use']);
     } catch (\Exception $ex) {
         $table = false;
     }
     if (!$table) {
         $this->err(__d('eav', 'The specified table does not exists.'));
         return false;
     } elseif (!$table->behaviors()->has('Eav')) {
         $this->err(__d('eav', 'The specified table is not using EAV behavior.'));
         return false;
     }
     $columns = $table->listColumns($options['bundle']);
     ksort($columns, SORT_LOCALE_STRING);
     $rows = [[__d('eav', 'Column Name'), __d('eav', 'Data Type'), __d('eav', 'Bundle'), __d('eav', 'Searchable')]];
     foreach ($columns as $name => $info) {
         $rows[] = [$name, $info['type'], !empty($info['bundle']) ? $info['bundle'] : '---', !empty($info['searchable']) ? 'no' : 'yes'];
     }
     $this->out();
     $this->out(__d('eav', 'EAV information for table "{0}":', $options['use']));
     $this->out();
     $this->helper('table')->output($rows);
     return true;
 }

 /**
  * Return an array of events to listen to.
  *
  * @return array
  */
 public function implementedEvents()
 {
     $before = function ($name) {
         return function () use($name) {
             DebugTimer::start($name, __d('debug_kit', $name));
         };
     };
     $after = function ($name) {
         return function () use($name) {
             DebugTimer::stop($name);
         };
     };
     $both = function ($name) use($before, $after) {
         return [['priority' => 0, 'callable' => $before('Event: ' . $name)], ['priority' => 999, 'callable' => $after('Event: ' . $name)]];
     };
     return ['Controller.initialize' => [['priority' => 0, 'callable' => function () {
         DebugMemory::record(__d('debug_kit', 'Controller initialization'));
     }], ['priority' => 0, 'callable' => $before('Event: Controller.initialize')], ['priority' => 999, 'callable' => $after('Event: Controller.initialize')]], 'Controller.startup' => [['priority' => 0, 'callable' => $before('Event: Controller.startup')], ['priority' => 999, 'callable' => $after('Event: Controller.startup')], ['priority' => 999, 'callable' => function () {
         DebugMemory::record(__d('debug_kit', 'Controller action start'));
         DebugTimer::start(__d('debug_kit', 'Controller action'));
     }]], 'Controller.beforeRender' => [['priority' => 0, 'callable' => function () {
         DebugTimer::stop(__d('debug_kit', 'Controller action'));
     }], ['priority' => 0, 'callable' => $before('Event: Controller.beforeRender')], ['priority' => 999, 'callable' => $after('Event: Controller.beforeRender')], ['priority' => 999, 'callable' => function () {
         DebugMemory::record(__d('debug_kit', 'View Render start'));
         DebugTimer::start(__d('debug_kit', 'View Render start'));
     }]], 'View.beforeRender' => $both('View.beforeRender'), 'View.afterRender' => $both('View.afterRender'), 'View.beforeLayout' => $both('View.beforeLayout'), 'View.afterLayout' => $both('View.afterLayout'), 'View.beforeRenderFile' => [['priority' => 0, 'callable' => function ($event, $filename) {
         DebugTimer::start(__d('debug_kit', 'Render {0}', $filename));
     }]], 'View.afterRenderFile' => [['priority' => 0, 'callable' => function ($event, $filename) {
         DebugTimer::stop(__d('debug_kit', 'Render {0}', $filename));
     }]], 'Controller.shutdown' => [['priority' => 0, 'callable' => $before('Event: Controller.shutdown')], ['priority' => 0, 'callable' => function () {
         DebugTimer::stop(__d('debug_kit', 'View Render start'));
         DebugMemory::record(__d('debug_kit', 'Controller shutdown'));
     }], ['priority' => 999, 'callable' => $after('Event: Controller.shutdown')]]];
 }

 /**
  * {@inheritdoc}
  */
 public function beforeValidate(Model $Model, $options = array())
 {
     $ModelValidator = $Model->validator();
     foreach ($Model->data[$Model->alias] as $field => $value) {
         if (!preg_match('/^([a-z0-9_]+)_confirm$/i', $field, $match)) {
             continue;
         }
         if (!array_key_exists($match[1], $Model->data[$Model->alias])) {
             continue;
         }
         if (!($Ruleset = $ModelValidator->getField($match[1]))) {
             $Ruleset = new CakeValidationSet($match[1], array());
         }
         $ruleset = array();
         foreach ($Ruleset->getRules() as $name => $Rule) {
             $ruleset[$name] = (array) $Rule;
             foreach (array_keys($ruleset[$name]) as $key) {
                 if (!preg_match('/^[a-z]/i', $key)) {
                     unset($ruleset[$name][$key]);
                 }
             }
         }
         $ModelValidator->add($field, new CakeValidationSet($field, array()));
         $ModelValidator->getField($field)->setRule('confirmed', array('rule' => 'isConfirmed', 'message' => __d('common', "No match.")));
     }
     return true;
 }

 /**
  * Default validation rules.
  *
  * @param \Cake\Validation\Validator $validator Validator instance.
  * @return \Cake\Validation\Validator
  */
 public function validationDefault(Validator $validator)
 {
     $validator->add('id', 'valid', ['rule' => 'numeric'])->allowEmpty('id', 'create');
     $validator->add('email', 'valid', ['rule' => 'email'])->notEmpty('email');
     $validator->notEmpty('password');
     $validator->allowEmpty('new_password');
     $validator->allowEmpty('confirm_password');
     $validator->add('new_password', 'custom', ['rule' => function ($value, $context) {
         if (!array_key_exists('confirm_password', $context['data'])) {
             return false;
         }
         if ($value !== $context['data']['confirm_password']) {
             return false;
         }
         return true;
     }, 'message' => __d('CakeAdmin', 'Passwords are not equal.')]);
     $validator->add('confirm_password', 'custom', ['rule' => function ($value, $context) {
         if (!array_key_exists('new_password', $context['data'])) {
             return false;
         }
         if ($value !== $context['data']['new_password']) {
             return false;
         }
         return true;
     }, 'message' => __d('CakeAdmin', 'Passwords are not equal.')]);
     return $validator;
 }

 /**
  * @param \Cake\ORM\Table $table
  * @param array $config
  */
 public function __construct(Table $table, array $config = [])
 {
     parent::__construct($table, $config);
     if (!$this->_config['message']) {
         $this->_config['message'] = __d('tools', 'Please confirm the checkbox');
     }
 }

 /**
  * __construct callback
  *
  * @param \Cake\View\View $View : View
  * @param array $config : Config
  * @throws Cake\Error\NotFoundException
  */
 public function __construct(\Cake\View\View $View, array $config = [])
 {
     parent::__construct($View, $config);
     if (!$this->_isSupportedFramework($fw = $this->config('assets.framework'))) {
         throw new NotFoundException(sprintf(__d('bootstrap', 'Configured JavaScript framework "{0}" is not supported. Only "{1}" are valid options.', $fw, implode(', ', $this->_authorizedJsLibs))));
     }
 }

 /**
  * Perform check before field create.
  *
  * @param string $table Table to look in
  * @param string $field Field to look for
  * @throws MigrationException
  * @return bool
  */
 public function checkAddField($table, $field)
 {
     if ($this->tableExists($table) && $this->fieldExists($table, $field)) {
         throw new MigrationException($this->_migration, sprintf(__d('migrations', 'Field "%s" already exists in "%s".'), $field, $table));
     }
     return true;
 }

 public function __call($methodName, $params)
 {
     if (!method_exists($this->_service, $methodName)) {
         throw new BadMethodCallException(sprintf(__d('ninja', 'The method %s is not defined in %s class.', true), $methodName, get_class($this->_service)));
     }
     return $this->_dispatchService(array($this->_service, $methodName), $params);
 }