/**
*
* @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');
}
}
/**
* 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');
}
}
/**
* @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);
}
}
}
/**
* 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];
}
/**
* 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;
}
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;
}