PHP Table::hasField方法代码示例

 /**
  * ResetSlugs method.
  *
  * Regenerate all slugs. On large dbs this can take more than 30 seconds - a time
  * limit is set to allow a minimum 100 updates per second as a preventative measure.
  *
  * Note that you should use the Reset behavior if you need additional functionality such
  * as callbacks or timeouts.
  *
  * @param array $params
  * @return bool Success
  */
 public function resetSlugs($params = [])
 {
     if (!$this->_table->hasField($this->_config['field'])) {
         throw new Exception('Table does not have field ' . $this->_config['field']);
     }
     $defaults = ['page' => 1, 'limit' => 100, 'fields' => array_merge([$this->_table->primaryKey()], $this->_config['label']), 'order' => $this->_table->displayField() . ' ASC', 'conditions' => $this->_config['scope'], 'overwrite' => true];
     $params = array_merge($defaults, $params);
     $count = $this->_table->find('all', compact('conditions'))->count();
     $max = ini_get('max_execution_time');
     if ($max) {
         set_time_limit(max($max, $count / 100));
     }
     $this->_table->behaviors()->Slugged->config($params, null, false);
     while ($records = $this->_table->find('all', $params)->toArray()) {
         foreach ($records as $record) {
             $record->isNew(true);
             $options = ['validate' => true, 'fieldList' => array_merge([$this->_table->primaryKey(), $this->_config['field']], $this->_config['label'])];
             if (!$this->_table->save($record, $options)) {
                 throw new Exception(print_r($this->_table->errors(), true));
             }
         }
         $params['page']++;
     }
     return true;
 }

 /**
  * Do some checks on the table which has been passed to make sure that it has what we need
  *
  * @param string $table The table
  * @return void
  */
 protected function checkTable($table)
 {
     try {
         $this->Table = $this->loadModel($table);
     } catch (Exception $e) {
         $this->out(__('<error>' . $e->getMessage() . '</error>'));
         exit;
     }
     if (get_class($this->Table) === 'AppModel') {
         $this->out(__('<error>The table could not be found, instance of AppModel loaded.</error>'));
         exit;
     }
     if (!$this->Table->hasBehavior('Proffer')) {
         $out = __("<error>The table '" . $this->Table->alias() . "' does not have the Proffer behavior attached.</error>");
         $this->out($out);
         exit;
     }
     $config = $this->Table->behaviors()->Proffer->config();
     foreach ($config as $field => $settings) {
         if (!$this->Table->hasField($field)) {
             $out = __("<error>The table '" . $this->Table->alias() . "' does not have the configured upload field in it's schema.</error>");
             $this->out($out);
             exit;
         }
         if (!$this->Table->hasField($settings['dir'])) {
             $out = __("<error>The table '" . $this->Table->alias() . "' does not have the configured dir field in it's schema.</error>");
             $this->out($out);
             exit;
         }
     }
 }

 /**
  * Gets the field(s) from the args and checks if they're present in the table.
  *
  * @param \Cake\ORM\Table $table Table object.
  * @return array Set of of fields explode()'ed from the args
  */
 protected function _getFields(Table $table)
 {
     $fields = explode(',', $this->args[1]);
     foreach ($fields as $field) {
         if (!$table->hasField($field)) {
             $this->abort(sprintf('Table `%s` is missing the field `%s`.', $table->table(), $field));
         }
     }
     return $fields;
 }

 /**
  * Run before a model is saved.
  *
  * @param \Cake\Event\Event $event The event that was triggered
  * @param \Cake\ORM\Entity $entity The entity being saved
  * @param array $options Array of options for the save operation
  * @return bool True if save should proceed, false otherwise
  */
 public function beforeSave(Event $event, $entity, $options = [])
 {
     if ($this->_table->hasField($this->config('createdByField')) || $this->_table->hasField($this->config('modifiedByField'))) {
         $userId = $this->_getUserId();
         if ($userId > 0) {
             $entity->set($this->config('modifiedByField'), $userId);
             if ($entity->isNew()) {
                 $entity->set($this->config('createdByField'), $userId);
             }
         }
     }
     return true;
 }

 /**
  * Prefixes the field with the table alias if possible.
  *
  * @param \Cake\ORM\Table $object Table object.
  * @param array $order Order array.
  * @param bool $validate If field should be validated. Defaults to false.
  * @return array Final order array.
  */
 protected function _prefix(Table $object, $order, $validate = false)
 {
     $tableAlias = $object->alias();
     $tableOrder = [];
     foreach ($order as $key => $value) {
         $field = $key;
         $alias = $tableAlias;
         if (is_numeric($key)) {
             $tableOrder[] = $value;
         } else {
             if (strpos($key, '.') !== false) {
                 list($alias, $field) = explode('.', $key);
             }
             $correctAlias = $tableAlias === $alias;
             if ($correctAlias && (!$validate || $object->hasField($field))) {
                 $tableOrder[$tableAlias . '.' . $field] = $value;
             }
         }
     }
     return $tableOrder;
 }

 /**
  * Validate that the desired sorting can be performed on the $object. Only fields or
  * virtualFields can be sorted on. The direction param will also be sanitized. Lastly
  * sort + direction keys will be converted into the model friendly order key.
  *
  * You can use the whitelist parameter to control which columns/fields are available for sorting.
  * This helps prevent users from ordering large result sets on un-indexed values.
  *
  * If you need to sort on associated columns or synthetic properties you will need to use a whitelist.
  *
  * Any columns listed in the sort whitelist will be implicitly trusted. You can use this to sort
  * on synthetic columns, or columns added in custom find operations that may not exist in the schema.
  *
  * @param Table $object The model being paginated.
  * @param array $options The pagination options being used for this request.
  * @return array An array of options with sort + direction removed and replaced with order if possible.
  */
 public function validateSort(Table $object, array $options)
 {
     if (isset($options['sort'])) {
         $direction = null;
         if (isset($options['direction'])) {
             $direction = strtolower($options['direction']);
         }
         if (!in_array($direction, ['asc', 'desc'])) {
             $direction = 'asc';
         }
         $options['order'] = [$options['sort'] => $direction];
     }
     unset($options['sort'], $options['direction']);
     if (empty($options['order'])) {
         $options['order'] = [];
     }
     if (!is_array($options['order'])) {
         return $options;
     }
     if (!empty($options['sortWhitelist'])) {
         $field = key($options['order']);
         $inWhitelist = in_array($field, $options['sortWhitelist'], true);
         if (!$inWhitelist) {
             $options['order'] = [];
         }
         return $options;
     }
     $tableAlias = $object->alias();
     $order = [];
     foreach ($options['order'] as $key => $value) {
         $field = $key;
         $alias = $tableAlias;
         if (is_numeric($key)) {
             $order[] = $value;
         } else {
             if (strpos($key, '.') !== false) {
                 list($alias, $field) = explode('.', $key);
             }
             $correctAlias = $tableAlias === $alias;
             if ($correctAlias && $object->hasField($field)) {
                 $order[$tableAlias . '.' . $field] = $value;
             }
         }
     }
     $options['order'] = $order;
     return $options;
 }

 /**
  * Prefixes the field with the table alias if possible.
  *
  * @param \Cake\ORM\Table $object Table object.
  * @param array $order Order array.
  * @param bool $whitelisted Whether or not the field was whitelisted
  * @return array Final order array.
  */
 protected function _prefix(Table $object, $order, $whitelisted = false)
 {
     $tableAlias = $object->alias();
     $tableOrder = [];
     foreach ($order as $key => $value) {
         if (is_numeric($key)) {
             $tableOrder[] = $value;
             continue;
         }
         $field = $key;
         $alias = $tableAlias;
         if (strpos($key, '.') !== false) {
             list($alias, $field) = explode('.', $key);
         }
         $correctAlias = $tableAlias === $alias;
         if ($correctAlias && $whitelisted) {
             // Disambiguate fields in schema. As id is quite common.
             if ($object->hasField($field)) {
                 $field = $alias . '.' . $field;
             }
             $tableOrder[$field] = $value;
         } elseif ($correctAlias && $object->hasField($field)) {
             $tableOrder[$tableAlias . '.' . $field] = $value;
         } elseif (!$correctAlias && $whitelisted) {
             $tableOrder[$alias . '.' . $field] = $value;
         }
     }
     return $tableOrder;
 }