PHP ClassMetadata::getFieldNames方法代码示例

 /**
  * @param \Faker\Generator $generator
  * @return array
  */
 public function guessColumnFormatters(\Faker\Generator $generator)
 {
     $formatters = array();
     $nameGuesser = new \Faker\Guesser\Name($generator);
     $columnTypeGuesser = new ColumnTypeGuesser($generator);
     foreach ($this->class->getFieldNames() as $fieldName) {
         if ($this->class->isIdentifier($fieldName) || !$this->class->hasField($fieldName)) {
             continue;
         }
         $size = isset($this->class->fieldMappings[$fieldName]['length']) ? $this->class->fieldMappings[$fieldName]['length'] : null;
         if ($formatter = $nameGuesser->guessFormat($fieldName, $size)) {
             $formatters[$fieldName] = $formatter;
             continue;
         }
         if ($formatter = $columnTypeGuesser->guessFormat($fieldName, $this->class)) {
             $formatters[$fieldName] = $formatter;
             continue;
         }
     }
     foreach ($this->class->getAssociationNames() as $assocName) {
         if ($this->class->isCollectionValuedAssociation($assocName)) {
             continue;
         }
         $relatedClass = $this->class->getAssociationTargetClass($assocName);
         $unique = $optional = false;
         $mappings = $this->class->getAssociationMappings();
         foreach ($mappings as $mapping) {
             if ($mapping['targetEntity'] == $relatedClass) {
                 if ($mapping['type'] == ClassMetadata::ONE_TO_ONE) {
                     $unique = true;
                     $optional = isset($mapping['joinColumns'][0]['nullable']) ? $mapping['joinColumns'][0]['nullable'] : false;
                     break;
                 }
             }
         }
         $index = 0;
         $formatters[$assocName] = function ($inserted) use($relatedClass, &$index, $unique, $optional) {
             if (isset($inserted[$relatedClass])) {
                 if ($unique) {
                     $related = null;
                     if (isset($inserted[$relatedClass][$index]) || !$optional) {
                         $related = $inserted[$relatedClass][$index];
                     }
                     $index++;
                     return $related;
                 }
                 return $inserted[$relatedClass][mt_rand(0, count($inserted[$relatedClass]) - 1)];
             }
             return null;
         };
     }
     return $formatters;
 }

 /**
  * @param $entity
  * @return array
  */
 protected function prepareSet($entity)
 {
     $data = [];
     foreach ($this->metaData->getFieldNames() as $fieldName) {
         $columnName = $this->metaData->getColumnName($fieldName);
         $type = $this->metaData->getTypeOfField($fieldName);
         $fieldValue = $entity->{$fieldName};
         $type = \Doctrine\DBAL\Types\Type::getType($type);
         $value = $type->convertToDatabaseValue($fieldValue, $this->em->getConnection()->getDatabasePlatform());
         $data[$columnName] = $value;
     }
     return $data;
 }

 /**
  * @param ClassMetadata $metadata
  * @return JavaScript\Metadata
  */
 private function convertMetadata(ClassMetadata $metadata)
 {
     $meta = new JavaScript\Metadata();
     $meta->originalName = $metadata->getName();
     $meta->namespace = str_replace('\\', '_', $metadata->getReflectionClass()->getNamespaceName());
     $meta->functionName = $metadata->getReflectionClass()->getShortName();
     $parent = $metadata->getReflectionClass()->getParentClass();
     $meta->superFunctionName = $parent ? $parent->getShortName() : 'DBEntity';
     // Convert fields.
     foreach ($metadata->getFieldNames() as $fieldName) {
         $field = new JavaScript\Field();
         $field->name = $fieldName;
         $field->methodName = ucfirst($fieldName);
         $field->type = $this->convertDoctrineType($metadata->getTypeOfField($fieldName));
         $field->isIdentifier = $metadata->isIdentifier($fieldName);
         $meta->fields[] = $field;
     }
     // Convert associations.
     foreach ($metadata->getAssociationNames() as $assocName) {
         $assoc = new JavaScript\Association();
         $assoc->name = $assocName;
         $assoc->methodName = ucfirst($assocName);
         $assoc->isCollection = $metadata->isCollectionValuedAssociation($assocName);
         $assoc->isSingle = $metadata->isSingleValuedAssociation($assocName);
         $assoc->singleName = Inflector::singularize($assoc->methodName);
         $assoc->invertedField = $metadata->getAssociationMappedByTargetField($assocName);
         $targetClass = new \ReflectionClass($metadata->getAssociationTargetClass($assocName));
         $assoc->singleType = $targetClass->getShortName();
         $assoc->type = $assoc->singleType . ($assoc->isCollection ? '[]' : '');
         $meta->associations[] = $assoc;
     }
     return $meta;
 }

 /**
  * @param EntityMetadata $entityMetadata
  * @param ClassMetadata $classMetadata
  */
 protected function addDoctrineFields(EntityMetadata $entityMetadata, ClassMetadata $classMetadata)
 {
     $fields = array_diff($classMetadata->getFieldNames(), $classMetadata->getIdentifierFieldNames(), $this->getDeletedFields($classMetadata->name));
     foreach ($fields as $fieldName) {
         $fieldMetadata = $this->metadataFactory->createFieldMetadata(array('field_name' => $fieldName), $classMetadata->getFieldMapping($fieldName));
         $entityMetadata->addFieldMetadata($fieldMetadata);
     }
 }

 /**
  * @param ClassMetadata $meteData
  * @return string
  */
 public function getNameLabelField(ClassMetadata $meteData)
 {
     $fieldNames = $meteData->getFieldNames();
     if (in_array('label', $fieldNames)) {
         return 'label';
     }
     return 'name';
 }

 private function defaultDefsFromMetadata()
 {
     $defaultEntity = $this->getEntityMetadata()->newInstance();
     $allFields = array_merge($this->metadata->getFieldNames(), $this->metadata->getAssociationNames());
     foreach ($allFields as $fieldName) {
         if (!isset($this->fieldDefs[$fieldName])) {
             $defaultFieldValue = $this->metadata->getFieldValue($defaultEntity, $fieldName);
             if ($defaultFieldValue !== null) {
                 $this->fieldDefs[$fieldName] = function () use($defaultFieldValue) {
                     return $defaultFieldValue;
                 };
             } else {
                 $this->fieldDefs[$fieldName] = function () {
                     return null;
                 };
             }
         }
     }
 }

 /**
  * @param ClassMetadata  $doctrineMetadata
  * @param EntityMetadata $entityMetadata
  *
  * @return string|null
  */
 public function getRepresentationField(ClassMetadata $doctrineMetadata, EntityMetadata $entityMetadata)
 {
     $fieldNames = $doctrineMetadata->getFieldNames();
     if (isset($entityMetadata->defaultValues['dictionary']['representation_field'])) {
         $representationField = $entityMetadata->defaultValues['dictionary']['representation_field'];
         if (in_array($representationField, $fieldNames)) {
             return $representationField;
         }
     }
     return null;
 }

 /**
  * @param EntityMetadata $entityMetadata
  * @param ClassMetadata $classMetadata
  */
 protected function addDoctrineFields(EntityMetadata $entityMetadata, ClassMetadata $classMetadata)
 {
     $identifierFields = $classMetadata->getIdentifierFieldNames();
     foreach ($classMetadata->getFieldNames() as $fieldName) {
         if (in_array($fieldName, $identifierFields)) {
             continue;
         }
         $fieldMetadata = $this->metadataFactory->createFieldMetadata(array('field_name' => $fieldName), $classMetadata->getFieldMapping($fieldName));
         $entityMetadata->addFieldMetadata($fieldMetadata);
     }
 }

 private function process(ClassMetadata $metadata, Builder $builder)
 {
     foreach ($metadata->getFieldNames() as $fname) {
         if ($metadata->isIdentifier($fname)) {
             $builder->none($fname);
         } elseif (!$builder->has($fname)) {
             $mapping = $metadata->fieldMappings[$fname];
             $this->makeField($mapping, $builder);
         }
     }
 }

 /**
  * Задает параметры для "получателя данных для ExtJS"
  *
  * @param ClassMetadata $classMetadata
  * @param ParamFetcherInterface $paramFetcher
  * @param GathererInterface $dataGatherer
  *
  * @throws \LogicException
  */
 public static function transport(ClassMetadata $classMetadata, ParamFetcherInterface $paramFetcher, GathererInterface &$dataGatherer)
 {
     $dataGatherer->setPage((int) $paramFetcher->get('page'));
     $dataGatherer->setStartIndex((int) $paramFetcher->get('start'));
     $dataGatherer->setLimit((int) $paramFetcher->get('limit'));
     $additionalFilters = self::getAdditionalFiltersFromJSONString($paramFetcher->get('additional_filter'));
     foreach ($additionalFilters as $additFilter) {
         if (!in_array($additFilter->getField(), $classMetadata->getFieldNames())) {
             throw new \LogicException("AdditionalFilter пытается фильтровать сущность '{$classMetadata->getName()}' по несуществующему полю '{$additFilter->getField()}'");
         }
     }
     $dataGatherer->addAdditionalFilters($additionalFilters);
     $sorters = self::getSortersFromJSONString($paramFetcher->get('sort'));
     foreach ($sorters as $sorter) {
         if (!in_array($sorter->getProperty(), $classMetadata->getFieldNames())) {
             throw new \LogicException("Sorter пытается сортировать сущность '{$classMetadata->getName()}' по несуществующему полю '{$sorter->getProperty()}'");
         }
     }
     $dataGatherer->addSorters($sorters);
     $dataGatherer->addFilters(self::getFiltersFromJSONString($paramFetcher->get('filter')));
 }

 /**
  * @param string[]|array list of field and association names
  * @param array of pairs [name=>options]. Optional options for non-excluded field/associations
  * @return IBuilder[]
  */
 public function addExcept($excluded, $options = [])
 {
     $names = array_merge($this->metadata->getFieldNames(), $this->metadata->getAssociationNames());
     $names = array_diff($names, $excluded);
     $names = array_filter($names, function ($name) {
         return !$this->shouldSkip($name);
     });
     $builders = [];
     foreach ($names as $name) {
         $builders[$name] = $this->add($name, isset($options[$name]) ? $options[$name] : []);
     }
     return $builders;
 }

 public function createFieldsFormatters($columnTypeGuesser, $generator)
 {
     $formatters = array();
     $nameGuesser = new Name($generator);
     foreach ($this->class->getFieldNames() as $fieldName) {
         //echo "pola standardowe: " . $fieldName . "\n";
         if ($this->class->isIdentifier($fieldName) || !$this->class->hasField($fieldName)) {
             //echo "pola standardowe kończę: " . $fieldName . "\n";
             continue;
         }
         //echo "pola standardowe dalej: " . $fieldName . "\n";
         if ($formatter = $nameGuesser->guessFormat($fieldName)) {
             $formatters[$fieldName] = $formatter;
             continue;
         }
         if ($formatter = $columnTypeGuesser->guessFormat($fieldName, $this->class)) {
             $formatters[$fieldName] = $formatter;
             continue;
         }
     }
     return $formatters;
 }

 /**
  * {@inheritdoc}
  */
 public function writeItem(array $item)
 {
     $this->counter++;
     $entity = null;
     // If the table was not truncated to begin with, find current entities
     // first
     if (false === $this->truncate) {
         if ($this->index) {
             // If the table has a composite key
             if (!empty($this->compositeKey) && is_array($this->compositeKey)) {
                 $composite = '';
                 foreach ($this->compositeKey as $key => $index) {
                     $composite .= $item[$index];
                 }
                 $value = $composite;
             } else {
                 $value = $item[$this->index];
             }
             $entity = $this->entityRepository->findOneBy(array($this->index => $value));
         } else {
             $entity = $this->entityRepository->find(current($item));
         }
     }
     if (!$entity) {
         $entity = $this->getNewInstance();
     }
     $fieldNames = array_merge($this->entityMetadata->getFieldNames(), $this->entityMetadata->getAssociationNames());
     foreach ($fieldNames as $fieldName) {
         $value = null;
         if (isset($item[$fieldName])) {
             $value = $item[$fieldName];
         } elseif (method_exists($item, 'get' . ucfirst($fieldName))) {
             $value = $item->{'get' . ucfirst($fieldName)};
         }
         if (null === $value) {
             continue;
         }
         if (!$value instanceof \DateTime || $value != $this->entityMetadata->getFieldValue($entity, $fieldName)) {
             $setter = 'set' . ucfirst($fieldName);
             $this->setValue($entity, $value, $setter);
         }
     }
     $this->entityManager->persist($entity);
     if ($this->counter % $this->batchSize == 0) {
         $this->entityManager->flush();
         $this->entityManager->clear($this->entityName);
     }
     return $this;
 }

 /**
  * @param array         $definition
  * @param ClassMetadata $metadata
  * @param string        $version
  * @param string[]      $requestType
  * @param array         $extras
  *
  * @return array
  */
 protected function getFields(array $definition, ClassMetadata $metadata, $version, array $requestType, array $extras)
 {
     $fieldNames = $metadata->getFieldNames();
     foreach ($fieldNames as $fieldName) {
         if (array_key_exists($fieldName, $definition)) {
             // already defined
             continue;
         }
         $config = $this->fieldConfigProvider->getFieldConfig($metadata->name, $fieldName, $version, $requestType, $extras);
         if ($this->exclusionProvider->isIgnoredField($metadata, $fieldName)) {
             $config[ConfigUtil::DEFINITION][ConfigUtil::EXCLUDE] = true;
         }
         $definition[$fieldName] = $config;
     }
     return $definition;
 }

 public function getFieldsMetadata($class, $group = 'default')
 {
     $result = array();
     foreach ($this->ormMetadata->getFieldNames() as $name) {
         $mapping = $this->ormMetadata->getFieldMapping($name);
         //  $mapping['isAssociation']=false;
         $values = array('title' => $name, 'source' => true);
         if (isset($mapping['fieldName'])) {
             $values['field'] = $mapping['fieldName'];
             $values['id'] = $mapping['fieldName'];
         }
         if (isset($mapping['id']) && $mapping['id'] == 'id') {
             $values['primary'] = true;
         }
         switch ($mapping['type']) {
             case 'string':
             case 'text':
                 $values['type'] = 'text';
                 break;
             case 'integer':
             case 'smallint':
             case 'bigint':
             case 'float':
             case 'decimal':
                 $values['type'] = 'number';
                 break;
             case 'boolean':
                 $values['type'] = 'boolean';
                 break;
             case 'date':
                 $values['type'] = 'date';
                 break;
             case 'datetime':
                 $values['type'] = 'datetime';
                 break;
             case 'time':
                 $values['type'] = 'time';
                 break;
             case 'array':
             case 'object':
                 $values['type'] = 'array';
                 break;
         }
         $result[$name] = $values;
     }
     return $result;
 }