PHP ClassType::getProperty方法代码示例

 /**
  * Get BuilderDefinition from entity property
  *
  * @param string $propertyName
  * @param bool $fillValues
  * @return BuilderDefinition|null
  * @throws InvalidStateException
  */
 private function getPropertyRule($propertyName, $fillValues = TRUE)
 {
     $property = $this->entityReflection->getProperty($propertyName);
     $annotations = $this->annotationReader->getPropertyAnnotations($property);
     $rule = new BuilderDefinition($propertyName);
     foreach ($annotations as $annotation) {
         switch (get_class($annotation)) {
             case 'Doctrine\\ORM\\Mapping\\Column':
                 if ($this->getEntityPrimaryKeyName($this->entity) === $propertyName) {
                     $rule->setComponentType(BuilderDefinition::COMPONENT_TYPE_HIDDEN);
                     $rule->setRequired(FALSE);
                 } else {
                     $type = BuilderDefinition::COMPONENT_TYPE_TEXT;
                     $rule->setRequired(!$annotation->nullable);
                     /** @var Column $annotation */
                     if ($annotation->type === 'boolean') {
                         $type = BuilderDefinition::COMPONENT_TYPE_CHECKBOX;
                     }
                     // is numeric?
                     if ($annotation->type === 'integer' || $annotation->type === 'float' || $annotation->type === 'bigint' || $annotation->type === 'decimal' || $annotation->type === 'smallint') {
                         $rule->addValidationRule(Form::NUMERIC, 'This is required in numeric format', TRUE);
                     }
                     $rule->setComponentType($type);
                 }
                 break;
             case 'Doctrine\\ORM\\Mapping\\ManyToOne':
                 /** @var ManyToOne $annotation */
                 $rule->setComponentType(BuilderDefinition::COMPONENT_TYPE_SELECT);
                 if ($fillValues) {
                     $rule->setValues($this->getPossibleValues($annotation->targetEntity));
                 }
                 $rule->setTargetEntity($annotation->targetEntity);
                 $rule->setRequired(TRUE);
                 break;
             case 'Doctrine\\ORM\\Mapping\\ManyToMany':
                 /** @var OneToMany $annotation */
                 $rule->setComponentType(BuilderDefinition::COMPONENT_TYPE_MULTI_SELECT);
                 if ($fillValues) {
                     $rule->setValues($this->getPossibleValues($annotation->targetEntity));
                 }
                 $rule->setRequired(TRUE);
                 $rule->setTargetEntity($annotation->targetEntity);
                 break;
             case 'Doctrine\\ORM\\Mapping\\JoinColumn':
                 /** @var JoinColumn $annotation */
                 $rule->setRequired(!$annotation->nullable);
                 break;
         }
     }
     return $rule->getComponentType() === NULL ? NULL : $rule;
 }

 private function assign(array $data)
 {
     $errors = array();
     foreach ($data as $propertyName => $value) {
         $pr = new ClassType($this);
         if (trim($value) == '') {
             $value = NULL;
         }
         $propertyName = Strings::underdashToCamel($propertyName);
         if ($pr->hasProperty($propertyName)) {
             $property = $pr->getProperty($propertyName);
             if ($property->getAnnotation('var') == 'DateTime' && $value !== NULL) {
                 $value = new DateTime($value);
             }
             $this->{$propertyName} = $value;
         } else {
             $errors[] = $propertyName;
         }
     }
 }

 /**
  * @param $name
  * @param $arguments
  * @throws LogicException
  * @return mixed|void
  */
 public function __call($name, $arguments)
 {
     $prefix = substr($name, 0, 3);
     if ($prefix === 'get') {
         return $this->{lcfirst(substr($name, 3))};
     } elseif ($prefix === 'set') {
         $reflection = new ClassType($this);
         $propertyName = lcfirst(substr($name, 3));
         if ($reflection->hasProperty($propertyName) && ($range = $reflection->getProperty($propertyName)->getAnnotation('range')) !== NULL) {
             $dataLength = strlen($arguments[0]);
             if ($range instanceof ArrayHash && count($range) == 2 && ($range[0] > $dataLength || $dataLength > $range[1])) {
                 throw new LogicException(sprintf('%s bad range <%d,%d> ... value %d', $propertyName, $range[0], $range[1], $dataLength));
             } else {
                 if (is_integer($range) && $dataLength != $range) {
                     throw new LogicException('bad length ' . $propertyName . ' ' . strlen($name) . ' - ' . $range);
                 }
             }
         }
         $this->{$propertyName} = reset($arguments);
     }
 }

 /**
  * @dataProvider dataStringFields
  */
 public function testSetFieldValue($class, $fields)
 {
     $metadata = $this->getMetadataFor($class);
     foreach ($fields as $field) {
         $className = 'Tests\\NForms\\Models\\' . $class;
         $reflection = new Nette\Reflection\ClassType($className);
         $object = new $className();
         $metadata->setFieldValue($object, $field, "test string");
         if ($reflection->hasProperty($field) && $reflection->getProperty($field)->isPublic()) {
             $value = $object->{$field};
         } else {
             $value = $object->{'get' . ucfirst($field)}();
         }
         Assert::same('test string', $value);
         $metadata->setFieldValue($object, $field, NULL);
         if ($reflection->hasProperty($field) && $reflection->getProperty($field)->isPublic()) {
             $value = $object->{$field};
         } else {
             $value = $object->{'get' . ucfirst($field)}();
         }
         Assert::same(NULL, $value);
     }
 }

 /**
  * Read property information
  * Read relations and base DB types for convert values to correct format
  *
  * @param object $baseEntity
  * @param string $name
  * @return array|NULL
  */
 private function readPropertyDataType($baseEntity, $name)
 {
     $annotationReader = new AnnotationReader();
     // read property information
     $reflectionClass = new ClassType($baseEntity);
     $property = $reflectionClass->getProperty($name);
     // if property exists
     if ($property !== NULL) {
         /** @var Column $column */
         $column = $annotationReader->getPropertyAnnotation($property, Column::class);
         /** @var ManyToOne $manyToOne */
         $manyToOne = $annotationReader->getPropertyAnnotation($property, ManyToOne::class);
         /** @var ManyToMany $manyToMany */
         $manyToMany = $annotationReader->getPropertyAnnotation($property, ManyToMany::class);
         /** @var OneToMany $oneToMany */
         $oneToMany = $annotationReader->getPropertyAnnotation($property, OneToMany::class);
         $type = NULL;
         $collection = FALSE;
         $relation = FALSE;
         if ($column !== NULL) {
             $type = $column->type;
             if (strrpos($type, 'array') !== FALSE) {
                 $type = \DateTime::class;
             } else {
                 if ($type === 'dateinterval') {
                     $type = \DateInterval::class;
                 } else {
                     if (strrpos($type, 'array') !== FALSE) {
                         $type = 'array';
                         $collection = TRUE;
                     }
                 }
             }
         } else {
             if ($manyToOne !== NULL) {
                 $type = $manyToOne->targetEntity;
                 $relation = TRUE;
             } else {
                 if ($manyToMany !== NULL || $oneToMany !== NULL) {
                     $collection = TRUE;
                     $type = $manyToMany === NULL ? $oneToMany->targetEntity : $manyToMany->targetEntity;
                     $relation = TRUE;
                 }
             }
         }
         return ['type' => $type, 'collection' => $collection, 'relation' => $relation];
     }
     return NULL;
 }