PHP Entity::has方法代码示例

 /**
  * Get resource attributes.
  *
  * @param \Cake\ORM\Entity $resource Entity resource
  * @return array
  */
 public function getAttributes($resource)
 {
     if ($resource->has($this->idField)) {
         $hidden = array_merge($resource->hiddenProperties(), [$this->idField]);
         $resource->hiddenProperties($hidden);
     }
     return $resource->toArray();
 }

 /**
  * Corrigir os campos de data ou timestamp
  * @param Entity $entity Uma instância
  * @return void
  */
 private function __ajustarDatas(Entity &$entity)
 {
     foreach ($this->campos[$this->_table->alias()] as $campo) {
         if ($entity->has($campo) && $entity->get($campo) !== "") {
             // DATA E HORA
             if ($this->__isDataHora($entity->get($campo))) {
                 $this->__ajustarDataHora($entity, $campo);
             } elseif (preg_match('/\\d{1,2}\\/\\d{1,2}\\/\\d{2,4}/', $entity->get($campo))) {
                 // DATA
                 $this->__ajustarData($entity, $campo);
             }
         }
     }
 }

 /**
  * beforeSave method
  *
  * @param Event $event The event
  * @param Entity $entity The entity
  * @param ArrayObject $options Array of options
  * @param ProfferPathInterface $path Inject an instance of ProfferPath
  * @return true
  * @throws Exception
  */
 public function beforeSave(Event $event, Entity $entity, ArrayObject $options, ProfferPathInterface $path = null)
 {
     foreach ($this->config() as $field => $settings) {
         if ($entity->has($field) && is_array($entity->get($field)) && $entity->get($field)['error'] === UPLOAD_ERR_OK) {
             // Allow path to be injected or set in config
             if (!empty($settings['pathClass'])) {
                 $path = new $settings['pathClass']($this->_table, $entity, $field, $settings);
             } elseif (!isset($path)) {
                 $path = new ProfferPath($this->_table, $entity, $field, $settings);
             }
             $event = new Event('Proffer.afterPath', $entity, ['path' => $path]);
             $this->_table->eventManager()->dispatch($event);
             if (!empty($event->result)) {
                 $path = $event->result;
             }
             $path->createPathFolder();
             if ($this->moveUploadedFile($entity->get($field)['tmp_name'], $path->fullPath())) {
                 $entity->set($field, $path->getFilename());
                 $entity->set($settings['dir'], $path->getSeed());
                 // Only generate thumbnails for image uploads
                 if (getimagesize($path->fullPath()) !== false && isset($settings['thumbnailSizes'])) {
                     // Allow the transformation class to be injected
                     if (!empty($settings['transformClass'])) {
                         $imageTransform = new $settings['transformClass']($this->_table, $path);
                     } else {
                         $imageTransform = new ImageTransform($this->_table, $path);
                     }
                     $imageTransform->processThumbnails($settings);
                 }
             } else {
                 throw new Exception('Cannot upload file');
             }
         }
         unset($path);
     }
     return true;
 }

 /**
  * Tests unsetProperty whith multiple properties
  *
  * @return void
  */
 public function testUnsetMultiple()
 {
     $entity = new Entity(['id' => 1, 'name' => 'bar', 'thing' => 2]);
     $entity->unsetProperty(['id', 'thing']);
     $this->assertFalse($entity->has('id'));
     $this->assertTrue($entity->has('name'));
     $this->assertFalse($entity->has('thing'));
 }

 /**
  * Get old order and scope values.
  *
  * @param \Cake\ORM\Entity $entity Entity.
  *
  * @return array
  */
 protected function _getOldValues(Entity $entity)
 {
     $config = $this->config();
     $fields = array_merge($config['scope'], [$config['order']]);
     $values = [];
     foreach ($fields as $field) {
         if ($entity->dirty($field)) {
             $values[$field] = $entity->getOriginal($field);
         } elseif ($entity->has($field)) {
             $values[$field] = $entity->get($field);
         }
     }
     if (count($fields) != count($values)) {
         $primaryKey = $entity->get($this->_table->primaryKey());
         $values = $this->_table->get($primaryKey, ['fields' => $fields, 'limit' => 1])->toArray();
     }
     $order = $values[$config['order']];
     unset($values[$config['order']]);
     return [$order, $values];
 }

 /**
  * Restore original (unencrypted) values after saving to DB
  * @param Event $event Event object
  * @param Entity $entity Entity object
  * @param ArrayObject $options Save options array
  * @return void
  */
 public function afterSave(Event $event, Entity $entity, ArrayObject $options)
 {
     if ($entity->has('_cyphered') && is_array($entity->_cyphered)) {
         foreach ($entity->_cyphered as $field => $value) {
             $entity->set($field, $value);
             $entity->clean();
         }
         unset($entity->_cyphered);
     }
 }

 /**
  * Get Title
  *
  * @param Cake\ORM\Entity $uri A complete uri entity
  * @return string
  */
 public function getTitle(Entity $uri)
 {
     $title = $this->config('defaults.title');
     $prefix = $this->config('defaults.prefix');
     $suffix = $this->config('defaults.suffix');
     if ($uri->has('seo_title') && $uri->seo_title) {
         $title = $uri->seo_title->title;
     }
     return $prefix . $title . $suffix;
 }

 /**
  * Ensures that content content has the correct publishing status based in content
  * type restrictions.
  *
  * If it's a new content it will set the correct status. However if it's an
  * existing content and user has no publishing permissions this method will not
  * change content's status, so it will remain published if it was already
  * published by an administrator.
  *
  * @param \Cake\ORM\Entity $entity The content
  * @return void
  */
 protected function _ensureStatus(Entity $entity)
 {
     if (!$entity->has('status')) {
         return;
     }
     if (!$entity->has('content_type') && ($entity->has('content_type_id') || $entity->has('content_type_slug'))) {
         if ($entity->has('content_type_id')) {
             $type = $this->ContentTypes->get($entity->get('content_type_id'));
         } else {
             $type = $this->ContentTypes->find()->where(['content_type_slug' => $entity->get('content_type_id')])->limit(1)->first();
         }
     } else {
         $type = $entity->get('content_type');
     }
     if ($type && !$type->userAllowed('publish')) {
         if ($entity->isNew()) {
             $entity->set('status', false);
         } else {
             $entity->unsetProperty('status');
         }
     }
 }

 /**
  * Generate a slug for the given string and entity. The generated slug is
  * unique across the entire table.
  *
  * @param string $string String from where to generate slug
  * @param \Cake\ORM\Entity $entity The entity for which generate the slug
  * @return string Slug for given string
  */
 protected function _slug($string, $entity)
 {
     $string = $this->_mbTrim(mb_strtolower($string));
     $config = $this->config();
     $slug = Inflector::slug($string, $config['separator']);
     $pk = $this->_table->primaryKey();
     if (mb_strlen($slug) > $config['length']) {
         $slug = mb_substr($slug, 0, $config['length']);
     }
     $conditions = ["{$config['slug']} LIKE" => "{$slug}%"];
     if ($entity->has($pk)) {
         $conditions["{$pk} NOT IN"] = [$entity->{$pk}];
     }
     $same = $this->_table->find()->where($conditions)->all()->extract($config['slug'])->toArray();
     if (!empty($same)) {
         $initialSlug = $slug;
         $index = 1;
         while ($index > 0) {
             $nextSlug = "{$initialSlug}{$config['separator']}{$index}";
             if (!in_array($nextSlug, $same)) {
                 $slug = $nextSlug;
                 $index = -1;
             }
             $index++;
         }
     }
     return $slug;
 }

 /**
  * Internal method to recursively generate the menu.
  *
  * @param \Cake\ORM\Query $items Items to render
  * @param int $depth Current iteration depth
  * @return string HTML
  */
 protected function _render($items, $depth = 0)
 {
     $content = '';
     $formatter = $this->config('formatter');
     foreach ($items as $item) {
         $children = '';
         if (is_array($item)) {
             $item = new Entity($item);
         }
         if ($item->has('children') && !empty($item->children) && $item->expanded) {
             $children = $this->formatTemplate('parent', ['attrs' => $this->templater()->formatAttributes(['class' => $this->config('dropdown') ? 'dropdown-menu multi-level' : '', 'role' => 'menu']), 'content' => $this->_render($item->children, $depth + 1)]);
         }
         $this->_index++;
         $info = ['index' => $this->_index, 'total' => $this->_count, 'active' => $this->Link->isActive($item), 'depth' => $depth, 'hasChildren' => !empty($children), 'children' => $children];
         $content .= $formatter($item, $info);
     }
     return $content;
 }

 /**
  * Format Template
  *
  * Return a formated template to use as content for a tag
  * ex :
  * Hello {{name}} -> Hello John
  * {{name}} is the property entity
  *
  * @param string $pattern a pattern to match
  * @param Cake\ORM\Entity $entity The entity
  * @return string
  * @todo Allow {{model.field}} syntax
  */
 protected function _formatTemplate($pattern, $entity)
 {
     $template = preg_replace_callback('/{{([\\w\\.]+)}}/', function ($matches) use($entity) {
         if (preg_match('/^([_\\w]+)\\.(\\w+)$/', $matches[1], $x)) {
             $table = TableRegistry::get(Inflector::tableize($x[1]));
             $matchEntity = $table->get($entity->{$x[1] . '_id'});
             return $matchEntity->{$x[2]};
         }
         if ($entity->has($matches[1])) {
             return $entity->{$matches[1]};
         }
     }, $pattern);
     return trim($template);
 }

 /**
  * Here we set default values for plugin's settings.
  *
  * Triggers the `Plugin.<PluginName>.settingsDefaults` event, event listeners
  * should catch the event and return an array as `key` => `value` with default
  * values.
  *
  * @param \Cake\Event\Event $event The event that was triggered
  * @param \Cake\ORM\Entity $plugin The plugin entity where to put those values
  * @return array
  */
 public function settingsDefaultValues(Event $event, Entity $plugin)
 {
     if ($plugin->has('name')) {
         return (array) $this->trigger("Plugin.{$plugin->name}.settingsDefaults", $plugin)->result;
     }
     return [];
 }