Example #1
0
 /**
  *
  * @param array $values
  * @throws AnnotationException on missing parameters
  */
 public function __construct(array $values = array())
 {
     if (array_key_exists('filepath', $values)) {
         $this->filepath_property = $values['filepath'];
     } else {
         throw AnnotationException::requiredError('filepath', '@FileUpload');
     }
     if (array_key_exists('file', $values)) {
         $this->file_property = $values['file'];
     } else {
         throw AnnotationException::requiredError('fileProperty', '@FileUpload');
     }
     if (array_key_exists('tempFilePath', $values)) {
         $this->temp_filepath_property = $values['tempFilePath'];
     } else {
         throw AnnotationException::requiredError('tempFilePath', '@FileUpload', get_class($this), 'expected');
     }
     if (array_key_exists('filenameMethod', $values)) {
         $this->filename_method = $values['filenameMethod'];
     } else {
         throw AnnotationException::requiredError('filenameMethod', '@FileUpload');
     }
     if (array_key_exists('uploadSubDirectory', $values)) {
         $this->upload_sub_directory = $values['uploadSubDirectory'];
     } else {
         throw AnnotationException::requiredError('uploadSubDirectory', '@FileUpload');
     }
 }
Example #2
0
 /**
  * Store options from the Vlabs\Media annotation
  *
  * @param  array                                            $options
  * @throws \Doctrine\Common\Annotations\AnnotationException
  */
 public function __construct($options)
 {
     if (isset($options['identifier'])) {
         $this->identifier = $options['identifier'];
     } else {
         $e = new AnnotationException();
         throw $e->requiredError('identifier', 'Vlabs\\Media', 'entity', 'configuration entity identifier');
     }
     if (isset($options['upload_dir'])) {
         $this->uploadDir = $options['upload_dir'];
     } else {
         $e = new AnnotationException();
         throw $e->requiredError('upload_dir', 'Vlabs\\Media', 'entity', 'configuration media upload directory');
     }
 }
Example #3
0
 /**
  * @param \Doctrine\ORM\Event\LoadClassMetadataEventArgs $eventArgs
  * @throws AnnotationException
  */
 public function loadClassMetadata(LoadClassMetadataEventArgs $eventArgs)
 {
     $reader = new AnnotationReader();
     $meta = $eventArgs->getClassMetadata();
     foreach ($meta->getReflectionClass()->getProperties() as $property) {
         if ($meta->isMappedSuperclass && !$property->isPrivate() || $meta->isInheritedField($property->name) || isset($meta->associationMappings[$property->name]['inherited'])) {
             continue;
         }
         if ($annotation = $reader->getPropertyAnnotation($property, 'Leapt\\CoreBundle\\Doctrine\\Mapping\\File')) {
             $property->setAccessible(true);
             $field = $property->getName();
             if (null === $annotation->mappedBy) {
                 throw AnnotationException::requiredError('mappedBy', 'LeaptCore\\File', $meta->getReflectionClass()->getName(), 'another class property to map onto');
             }
             if (null === $annotation->path && null === $annotation->pathCallback) {
                 throw AnnotationException::syntaxError(sprintf('Annotation @%s declared on %s expects "path" or "pathCallback". One of them should not be null.', 'LeaptCore\\File', $meta->getReflectionClass()->getName()));
             }
             if (!$meta->hasField($annotation->mappedBy)) {
                 throw AnnotationException::syntaxError(sprintf('The entity "%s" has no field named "%s", but it is documented in the annotation @%s', $meta->getReflectionClass()->getName(), $annotation->mappedBy, 'LeaptCore\\File'));
             }
             $this->config[$meta->getName()]['fields'][$field] = array('property' => $property, 'path' => $annotation->path, 'mappedBy' => $annotation->mappedBy, 'filename' => $annotation->filename, 'meta' => $meta, 'nameCallback' => $annotation->nameCallback, 'pathCallback' => $annotation->pathCallback);
         }
     }
 }
Example #4
0
 /**
  * Annotation     ::= "@" AnnotationName ["(" [Values] ")"]
  * AnnotationName ::= QualifiedName | SimpleName
  * QualifiedName  ::= NameSpacePart "\" {NameSpacePart "\"}* SimpleName
  * NameSpacePart  ::= identifier | null | false | true
  * SimpleName     ::= identifier | null | false | true
  *
  * @throws AnnotationException
  * @return mixed False if it is not a valid annotation.
  */
 private function Annotation()
 {
     $this->match(DocLexer::T_AT);
     // check if we have an annotation
     $name = $this->Identifier();
     // only process names which are not fully qualified, yet
     // fully qualified names must start with a \
     $originalName = $name;
     if ('\\' !== $name[0]) {
         $alias = false === ($pos = strpos($name, '\\')) ? $name : substr($name, 0, $pos);
         $found = false;
         if ($this->namespaces) {
             foreach ($this->namespaces as $namespace) {
                 if ($this->classExists($namespace . '\\' . $name)) {
                     $name = $namespace . '\\' . $name;
                     $found = true;
                     break;
                 }
             }
         } elseif (isset($this->imports[$loweredAlias = strtolower($alias)])) {
             if (false !== $pos) {
                 $name = $this->imports[$loweredAlias] . substr($name, $pos);
             } else {
                 $name = $this->imports[$loweredAlias];
             }
             $found = true;
         } elseif (isset($this->imports['__NAMESPACE__']) && $this->classExists($this->imports['__NAMESPACE__'] . '\\' . $name)) {
             $name = $this->imports['__NAMESPACE__'] . '\\' . $name;
             $found = true;
         } elseif ($this->classExists($name)) {
             $found = true;
         }
         if (!$found) {
             if ($this->ignoreNotImportedAnnotations || isset($this->ignoredAnnotationNames[$name])) {
                 return false;
             }
             throw AnnotationException::semanticalError(sprintf('The annotation "@%s" in %s was never imported. Did you maybe forget to add a "use" statement for this annotation?', $name, $this->context));
         }
     }
     if (!$this->classExists($name)) {
         throw AnnotationException::semanticalError(sprintf('The annotation "@%s" in %s does not exist, or could not be auto-loaded.', $name, $this->context));
     }
     // at this point, $name contains the fully qualified class name of the
     // annotation, and it is also guaranteed that this class exists, and
     // that it is loaded
     // collects the metadata annotation only if there is not yet
     if (!isset(self::$annotationMetadata[$name])) {
         $this->collectAnnotationMetadata($name);
     }
     // verify that the class is really meant to be an annotation and not just any ordinary class
     if (self::$annotationMetadata[$name]['is_annotation'] === false) {
         if (isset($this->ignoredAnnotationNames[$originalName])) {
             return false;
         }
         throw AnnotationException::semanticalError(sprintf('The class "%s" is not annotated with @Annotation. Are you sure this class can be used as annotation? If so, then you need to add @Annotation to the _class_ doc comment of "%s". If it is indeed no annotation, then you need to add @IgnoreAnnotation("%s") to the _class_ doc comment of %s.', $name, $name, $originalName, $this->context));
     }
     //if target is nested annotation
     $target = $this->isNestedAnnotation ? Target::TARGET_ANNOTATION : $this->target;
     // Next will be nested
     $this->isNestedAnnotation = true;
     //if annotation does not support current target
     if (0 === (self::$annotationMetadata[$name]['targets'] & $target) && $target) {
         throw AnnotationException::semanticalError(sprintf('Annotation @%s is not allowed to be declared on %s. You may only use this annotation on these code elements: %s.', $originalName, $this->context, self::$annotationMetadata[$name]['targets_literal']));
     }
     $values = array();
     if ($this->lexer->isNextToken(DocLexer::T_OPEN_PARENTHESIS)) {
         $this->match(DocLexer::T_OPEN_PARENTHESIS);
         if (!$this->lexer->isNextToken(DocLexer::T_CLOSE_PARENTHESIS)) {
             $values = $this->Values();
         }
         $this->match(DocLexer::T_CLOSE_PARENTHESIS);
     }
     // checks all declared attributes
     foreach (self::$annotationMetadata[$name]['attribute_types'] as $property => $type) {
         if ($property === self::$annotationMetadata[$name]['default_property'] && !isset($values[$property]) && isset($values['value'])) {
             $property = 'value';
         }
         // handle a not given attribute or null value
         if (!isset($values[$property])) {
             if ($type['required']) {
                 throw AnnotationException::requiredError($property, $originalName, $this->context, 'a(n) ' . $type['value']);
             }
             continue;
         }
         if ($type['type'] === 'array') {
             // handle the case of a single value
             if (!is_array($values[$property])) {
                 $values[$property] = array($values[$property]);
             }
             // checks if the attribute has array type declaration, such as "array<string>"
             if (isset($type['array_type'])) {
                 foreach ($values[$property] as $item) {
                     if (gettype($item) !== $type['array_type'] && !$item instanceof $type['array_type']) {
                         throw AnnotationException::typeError($property, $originalName, $this->context, 'either a(n) ' . $type['array_type'] . ', or an array of ' . $type['array_type'] . 's', $item);
                     }
                 }
             }
         } elseif (gettype($values[$property]) !== $type['type'] && !$values[$property] instanceof $type['type']) {
             throw AnnotationException::typeError($property, $originalName, $this->context, 'a(n) ' . $type['value'], $values[$property]);
         }
     }
     // check if the annotation expects values via the constructor,
     // or directly injected into public properties
     if (self::$annotationMetadata[$name]['has_constructor'] === true) {
         return new $name($values);
     }
     $instance = new $name();
     foreach ($values as $property => $value) {
         if (!isset(self::$annotationMetadata[$name]['properties'][$property])) {
             if ('value' !== $property) {
                 throw AnnotationException::creationError(sprintf('The annotation @%s declared on %s does not have a property named "%s". Available properties: %s', $originalName, $this->context, $property, implode(', ', self::$annotationMetadata[$name]['properties'])));
             }
             // handle the case if the property has no annotations
             if (!($property = self::$annotationMetadata[$name]['default_property'])) {
                 throw AnnotationException::creationError(sprintf('The annotation @%s declared on %s does not accept any values, but got %s.', $originalName, $this->context, json_encode($values)));
             }
         }
         $instance->{$property} = $value;
     }
     return $instance;
 }
 /**
  * Gets the Lucene index to the related object
  *
  * @param object $object
  *
  * @return ZendSearch\Lucene\SearchIndexInterface
  */
 private function getIndexForObject($object)
 {
     $reflClass = new ReflectionClass($object);
     $annotation = $this->reader->getClassAnnotation($reflClass, '\\Keratine\\Lucene\\Mapping\\Annotation\\Indexable');
     if (!$annotation) {
         // throw new \Exception(sprintf('%s must define annotation @%s', get_class($object), '\Keratine\Lucene\Mapping\Annotation\Indexable'));
         return;
     }
     if (empty($annotation->index)) {
         AnnotationException::requiredError('index', '\\Keratine\\Lucene\\Mapping\\Annotation\\Indexable', $object, 'string');
     }
     if (false === isset($this->indices[$annotation->index])) {
         throw new \Exception(sprintf('Unknown index "%s".', $annotation->index));
     }
     if (false === $this->indices[$annotation->index] instanceof SearchIndexInterface) {
         throw new \Exception(sprintf('Index "%s" must be an instance of "ZendSearch\\Lucene\\SearchIndexInterface". "%s" given.', $annotation->index, is_object($this->indices[$annotation->index]) ? get_class($this->indices[$annotation->index]) : $this->indices[$annotation->index]));
     }
     return $this->indices[$annotation->index];
 }
Example #6
0
 /**
  * Load receiver properties and NotBlank constraints from ReflectionClass.
  *
  * @param \ReflectionClass $class
  *
  * @throws AnnotationException
  *
  * @return array
  */
 protected function loadReceiverProperties(\ReflectionClass $class)
 {
     $receiverPropertiesTypes = [];
     $properties = $class->getProperties();
     //Store receiver properties
     foreach ($properties as $property) {
         $annotations = $this->reader->getPropertyAnnotations($property);
         foreach ($annotations as $key => $annotationObj) {
             if ($annotationObj instanceof ReceiverPropertyAnnotation && !in_array($class, $receiverPropertiesTypes)) {
                 if (!$annotations[$key]->getTypes()) {
                     $message = $class->name . ':$' . $property->name . '" field';
                     throw AnnotationException::requiredError('type', 'ReceiverProperty annotation', $message, 'array or string');
                 }
                 foreach ($annotations[$key]->getTypes() as $type) {
                     $receiverProperty = new ReceiverProperty();
                     $receiverProperty->setFieldName($property->name);
                     $receiverPropertiesTypes[$type][] = $receiverProperty;
                 }
             }
         }
     }
     //Set receiver properties as required if necessary
     foreach ($receiverPropertiesTypes as $type => $receiverProperties) {
         /* @var ReceiverProperty[] $receiverProperties */
         foreach ($receiverProperties as $receiverProperty) {
             $receiverPropertyName = $receiverProperty->getFieldName();
             $refProperty = $class->getProperty($receiverPropertyName);
             $annotations = $this->reader->getPropertyAnnotations($refProperty);
             foreach ($annotations as $key => $annotationObj) {
                 if ($annotationObj instanceof Column && $annotationObj->nullable === false) {
                     throw new Exception(sprintf('Property "%s" in class "%s" has a @ReceiverProperty annotation and by consequence must have "nullable=true" for ORM\\Column annotation', $refProperty->name, $refProperty->class));
                 } elseif ($annotationObj instanceof NotBlank) {
                     throw new Exception(sprintf('Property "%s" in class "%s" has a @ReceiverProperty annotation and by consequence can not use NotBlank annotation', $refProperty->name, $refProperty->class));
                 } elseif ($annotationObj instanceof NotNull) {
                     throw new Exception(sprintf('Property "%s" in class "%s" has a @ReceiverProperty annotation and by consequence can not use NotNull annotation', $refProperty->name, $refProperty->class));
                 } elseif ($annotationObj instanceof ReceiverPropertyAnnotation && $annotationObj->isRequired()) {
                     $receiverProperty->setRequired(true);
                 }
             }
         }
     }
     return $receiverPropertiesTypes;
 }
Example #7
0
 private function loadReceiverProperties()
 {
     $receiverProperties = array();
     //Add widgetItems to widgets
     $widgetItems = $this->widgetItemChain->getWidgetItems();
     $widgets = array_merge($this->widgets, $widgetItems);
     foreach ($widgets as $widget) {
         $class = new \ReflectionClass($widget['class']);
         $properties = $class->getProperties();
         foreach ($properties as $property) {
             $annotations = $this->reader->getPropertyAnnotations($property);
             foreach ($annotations as $key => $annotationObj) {
                 if ($annotationObj instanceof ReceiverProperty && !in_array($class, $receiverProperties)) {
                     if (!$annotations[$key]->getTypes()) {
                         $message = $class->name . ':$' . $property->name . '" field';
                         throw AnnotationException::requiredError('type', 'BusinessProperty annotation', $message, 'array or string');
                     }
                     foreach ($annotations[$key]->getTypes() as $type) {
                         $receiverProperties[$widget['name']][$type][$property->name] = $property->name;
                     }
                 }
             }
         }
     }
     return $receiverProperties;
 }