Once populated, ClassMetadata instances are usually cached in a serialized form.
IMPORTANT NOTE:
The fields of this class are only public for 2 reasons:
1) To allow fast READ access.
2) To drastically reduce the size of a serialized instance (private/protected members
get the whole class name, namespace inclusive, prepended to every property in
the serialized representation).
/** * @param ClassMetadata $classMetadata * @return $this * * @throws MappingException */ private function fromDocument(ClassMetadata $classMetadata) { if ($classMetadata->isSharded()) { throw MappingException::cannotUseShardedCollectionInOutStage($classMetadata->name); } return parent::out($classMetadata->getCollection()); }
/** * @param string $fieldName * @return $this * @throws MappingException */ private function fromReference($fieldName) { if (!$this->class->hasReference($fieldName)) { MappingException::referenceMappingNotFound($this->class->name, $fieldName); } $referenceMapping = $this->class->getFieldMapping($fieldName); $targetMapping = $this->dm->getClassMetadata($referenceMapping['targetDocument']); parent::from($targetMapping->getCollection()); if ($referenceMapping['isOwningSide']) { if ($referenceMapping['storeAs'] !== ClassMetadataInfo::REFERENCE_STORE_AS_ID) { throw MappingException::cannotLookupNonIdReference($this->class->name, $fieldName); } $this->foreignField('_id')->localField($referenceMapping['name']); } else { if (isset($referenceMapping['repositoryMethod'])) { throw MappingException::repositoryMethodLookupNotAllowed($this->class->name, $fieldName); } $mappedByMapping = $targetMapping->getFieldMapping($referenceMapping['mappedBy']); if ($mappedByMapping['storeAs'] !== ClassMetadataInfo::REFERENCE_STORE_AS_ID) { throw MappingException::cannotLookupNonIdReference($this->class->name, $fieldName); } $this->localField('_id')->foreignField($mappedByMapping['name']); } return $this; }
/** * @param string $class * @param DocumentManager $documentManager * @param ClassMetadata $metadata * @param ResourceInterface|null $resource * * @return ObjectRepository */ protected function createResourceRepository($class, DocumentManager $documentManager, ClassMetadata $metadata, ResourceInterface $resource = null) { if ($resource !== null && is_a($class, BaseRepositoryInterface::class, true)) { return new $class($documentManager, $documentManager->getUnitOfWork(), $metadata, $resource); } return parent::createRepository($documentManager, $metadata->getName()); }
/** * {@inheritdoc} */ public function __construct(DocumentManager $dm, UnitOfWork $uow, ClassMetadata $class) { if ($class->getReflectionClass()->isSubclassOf('Gedmo\\Translatable\\Document\\MappedSuperclass\\AbstractPersonalTranslation')) { throw new \Gedmo\Exception\UnexpectedValueException('This repository is useless for personal translations'); } parent::__construct($dm, $uow, $class); }
protected function getQueryArray(ClassMetadata $metadata, $document, $path) { $class = $metadata->name; $field = $this->getFieldNameFromPropertyPath($path); if (!isset($metadata->fieldMappings[$field])) { throw new \LogicException('Mapping for \'' . $path . '\' doesn\'t exist for ' . $class); } $mapping = $metadata->fieldMappings[$field]; if (isset($mapping['reference']) && $mapping['reference']) { throw new \LogicException('Cannot determine uniqueness of referenced document values'); } switch ($mapping['type']) { case 'one': // TODO: implement support for embed one documents // TODO: implement support for embed one documents case 'many': // TODO: implement support for embed many documents throw new \RuntimeException('Not Implemented.'); case 'hash': $value = $metadata->getFieldValue($document, $mapping['fieldName']); return array($path => $this->getFieldValueRecursively($path, $value)); case 'collection': return array($mapping['fieldName'] => array('$in' => $metadata->getFieldValue($document, $mapping['fieldName']))); default: return array($mapping['fieldName'] => $metadata->getFieldValue($document, $mapping['fieldName'])); } }
/** * Checks that the current field includes a reference to the supplied document. */ public function includesReferenceTo($document) { if ($this->currentField) { $this->query[$this->currentField][$this->cmd . 'elemMatch'] = $this->class ? $this->dm->createDBRef($document, $this->class->getFieldMapping($this->currentField)) : $this->dm->createDBRef($document); } else { $this->query[$this->cmd . 'elemMatch'] = $this->dm->createDBRef($document); } return $this; }
/** * Hydrate array of MongoDB document data into the given document object * based on the mapping information provided in the ClassMetadata instance. * * @param ClassMetadata $metadata The ClassMetadata instance for mapping information. * @param string $document The document object to hydrate the data into. * @param array $data The array of document data. * @return array $values The array of hydrated values. */ public function hydrate(ClassMetadata $metadata, $document, $data) { $values = array(); foreach ($metadata->fieldMappings as $mapping) { if (!isset($data[$mapping['fieldName']])) { continue; } if (isset($mapping['embedded'])) { $embeddedMetadata = $this->_dm->getClassMetadata($mapping['targetDocument']); $embeddedDocument = $embeddedMetadata->newInstance(); if ($mapping['type'] === 'many') { $documents = new ArrayCollection(); foreach ($data[$mapping['fieldName']] as $docArray) { $doc = clone $embeddedDocument; $this->hydrate($embeddedMetadata, $doc, $docArray); $documents->add($doc); } $metadata->setFieldValue($document, $mapping['fieldName'], $documents); $value = $documents; } else { $value = clone $embeddedDocument; $this->hydrate($embeddedMetadata, $value, $data[$mapping['fieldName']]); $metadata->setFieldValue($document, $mapping['fieldName'], $value); } } elseif (isset($mapping['reference'])) { $targetMetadata = $this->_dm->getClassMetadata($mapping['targetDocument']); $targetDocument = $targetMetadata->newInstance(); $value = isset($data[$mapping['fieldName']]) ? $data[$mapping['fieldName']] : null; if ($mapping['type'] === 'one' && isset($value['$id'])) { $id = (string) $value['$id']; $proxy = $this->_dm->getReference($mapping['targetDocument'], $id); $metadata->setFieldValue($document, $mapping['fieldName'], $proxy); } elseif ($mapping['type'] === 'many' && (is_array($value) || $value instanceof Collection)) { $documents = new PersistentCollection($this->_dm, $targetMetadata, new ArrayCollection()); $documents->setInitialized(false); foreach ($value as $v) { $id = (string) $v['$id']; $proxy = $this->_dm->getReference($mapping['targetDocument'], $id); $documents->add($proxy); } $metadata->setFieldValue($document, $mapping['fieldName'], $documents); } } else { $value = $data[$mapping['fieldName']]; $value = Type::getType($mapping['type'])->convertToPHPValue($value); $metadata->setFieldValue($document, $mapping['fieldName'], $value); } if (isset($value)) { $values[$mapping['fieldName']] = $value; } } if (isset($data['_id'])) { $metadata->setIdentifierValue($document, (string) $data['_id']); } return $values; }
/** * @param ClassMetadata $metadata */ private function setCustomRepositoryClass(ClassMetadata $metadata) { try { $resourceMetadata = $this->resourceRegistry->getByClass($metadata->getName()); } catch (\InvalidArgumentException $exception) { return; } if ($resourceMetadata->hasClass('repository')) { $metadata->setCustomRepositoryClass($resourceMetadata->getClass('repository')); } }
/** {@inheritdoc} */ public function getId($object) { if (!is_a($object, $this->getClass())) { throw new MetadataException("Object isn't subclass of '{$this->getClass()}', given '" . (is_object($object) ? get_class($object) : gettype($object)) . "'."); } if ($this->classMetadata->isEmbeddedDocument) { throw new MetadataException("Embedded document '{$this->getClass()}' hasn't ID."); } $identifier = $this->classMetadata->getIdentifierValue($object); return empty($identifier) ? NULL : $identifier; }
public function testCreateQueryBuilderForCollection() { $this->classMetadata->expects($this->once())->method('getFieldNames')->will($this->returnValue([])); $this->classMetadata->expects($this->once())->method('getAssociationTargetClass')->with($this->identicalTo('translations'))->will($this->returnValue($translationClass = TranslationTest::class)); $translationClassMetadata = $this->createClassMetadataMock(); $translationClassMetadata->expects($this->once())->method('getFieldNames')->will($this->returnValue(['locale'])); $this->documentManager->expects($this->once())->method('getClassMetadata')->with($this->identicalTo($translationClass))->will($this->returnValue($translationClassMetadata)); $this->documentManager->expects($this->once())->method('createQueryBuilder')->will($this->returnValue($queryBuilder = $this->createQueryBuilderMock())); $queryBuilder->expects($this->once())->method('field')->with($this->identicalTo('translations.locale'))->will($this->returnSelf()); $this->localeContext->expects($this->once())->method('getLocales')->will($this->returnValue($locales = ['fr'])); $this->localeContext->expects($this->once())->method('getFallbackLocale')->will($this->returnValue($fallbackLocale = 'en')); $queryBuilder->expects($this->once())->method('in')->with($this->identicalTo(array_merge($locales, [$fallbackLocale])))->will($this->returnSelf()); $this->assertSame($queryBuilder, $this->translatableRepository->createQueryBuilderForCollection()); }
/** * Prepares a query value and converts the php value to the database value if it is an identifier. * It also handles converting $fieldName to the database name if they are different. * * @param string $fieldName * @param string $value * @return mixed $value */ private function prepareQueryValue(&$fieldName, $value) { // Process "association.fieldName" if (strpos($fieldName, '.') !== false) { $e = explode('.', $fieldName); $mapping = $this->class->getFieldMapping($e[0]); if ($this->class->hasField($e[0])) { $name = $this->class->fieldMappings[$e[0]]['name']; if ($name !== $e[0]) { $e[0] = $name; } } if (isset($mapping['targetDocument'])) { $targetClass = $this->dm->getClassMetadata($mapping['targetDocument']); if ($targetClass->hasField($e[1])) { if ($targetClass->identifier === $e[1] || $e[1] === '$id') { $fieldName = $e[0] . '.$id'; $value = $targetClass->getDatabaseIdentifierValue($value); } } } // Process all non identifier fields } elseif ($this->class->hasField($fieldName) && !$this->class->isIdentifier($fieldName)) { $name = $this->class->fieldMappings[$fieldName]['name']; $mapping = $this->class->fieldMappings[$fieldName]; if ($name !== $fieldName) { $fieldName = $name; } // Process identifier } elseif ($fieldName === $this->class->identifier || $fieldName === '_id') { $fieldName = '_id'; $value = $this->class->getDatabaseIdentifierValue($value); } return $value; }
public function getFieldsMetadata($class) { $result = array(); foreach ($this->odmMetadata->getReflectionProperties() as $property) { $name = $property->getName(); $mapping = $this->odmMetadata->getFieldMapping($name); $values = array('title' => $name, 'source' => true); if (isset($mapping['fieldName'])) { $values['field'] = $mapping['fieldName']; } if (isset($mapping['id']) && $mapping['id'] == 'id') { $values['primary'] = true; } switch ($mapping['type']) { case 'id': case 'int': case 'string': case 'float': case 'many': $values['type'] = 'text'; break; case 'boolean': $values['type'] = 'boolean'; break; case 'date': $values['type'] = 'date'; break; } $result[$name] = $values; } return $result; }
/** * Executes all queued document insertions and returns any generated post-insert * identifiers that were created as a result of the insertions. * * If no inserts are queued, invoking this method is a NOOP. * * @return array An array of any generated post-insert IDs. This will be an empty array * if the document class does not use the IDENTITY generation strategy. */ public function executeInserts() { if (!$this->_queuedInserts) { return; } $postInsertIds = array(); $inserts = array(); foreach ($this->_queuedInserts as $oid => $document) { $data = $this->prepareInsertData($document); if (!$data) { continue; } $inserts[$oid] = $data; } if (empty($inserts)) { return; } $this->_collection->batchInsert($inserts); foreach ($inserts as $oid => $data) { $document = $this->_queuedInserts[$oid]; $postInsertIds[(string) $data['_id']] = $document; if ($this->_class->isFile()) { $this->_dm->getHydrator()->hydrate($this->_class, $document, $data); } } $this->_queuedInserts = array(); return $postInsertIds; }
/** * Gets reference mapping for current field from current class or its descendants. * * @return array * @throws MappingException */ private function getReferenceMapping() { $mapping = null; try { $mapping = $this->class->getFieldMapping($this->currentField); } catch (MappingException $e) { if (empty($this->class->discriminatorMap)) { throw $e; } $foundIn = null; foreach ($this->class->discriminatorMap as $child) { $childClass = $this->dm->getClassMetadata($child); if ($childClass->hasAssociation($this->currentField)) { if ($mapping !== null && $mapping !== $childClass->getFieldMapping($this->currentField)) { throw MappingException::referenceFieldConflict($this->currentField, $foundIn->name, $childClass->name); } $mapping = $childClass->getFieldMapping($this->currentField); $foundIn = $childClass; } } if ($mapping === null) { throw MappingException::mappingNotFoundInClassNorDescendants($this->class->name, $this->currentField); } } return $mapping; }
/** * Prepares a query value and converts the php value to the database value if it is an identifier. * It also handles converting $fieldName to the database name if they are different. * * @param string $fieldName * @param string $value * @return mixed $value */ private function prepareQueryValue(&$fieldName, $value) { // Process "association.fieldName" if (strpos($fieldName, '.') !== false) { $e = explode('.', $fieldName); $mapping = $this->class->getFieldMapping($e[0]); $name = $mapping['name']; if ($name !== $e[0]) { $e[0] = $name; } if (isset($mapping['targetDocument'])) { $targetClass = $this->dm->getClassMetadata($mapping['targetDocument']); if ($targetClass->hasField($e[1])) { if ($targetClass->identifier === $e[1]) { $e[1] = '$id'; if (is_array($value)) { foreach ($value as $k => $v) { $value[$k] = $targetClass->getDatabaseIdentifierValue($v); } } else { $value = $targetClass->getDatabaseIdentifierValue($value); } } else { $targetMapping = $targetClass->getFieldMapping($e[1]); $targetName = $targetMapping['name']; if ($targetName !== $e[1]) { $e[1] = $targetName; } } $fieldName = $e[0] . '.' . $e[1]; } } // Process all non identifier fields // We only change the field names here to the mongodb field name used for persistence } elseif ($this->class->hasField($fieldName) && !$this->class->isIdentifier($fieldName)) { $name = $this->class->fieldMappings[$fieldName]['name']; $mapping = $this->class->fieldMappings[$fieldName]; if ($name !== $fieldName) { $fieldName = $name; } // Process identifier } elseif ($this->class->hasField($fieldName) && $this->class->isIdentifier($fieldName) || $fieldName === '_id') { $fieldName = '_id'; if (is_array($value)) { foreach ($value as $k => $v) { if ($k[0] === '$' && is_array($v)) { foreach ($v as $k2 => $v2) { $value[$k][$k2] = $this->class->getDatabaseIdentifierValue($v2); } } else { $value[$k] = $this->class->getDatabaseIdentifierValue($v); } } } else { $value = $this->class->getDatabaseIdentifierValue($value); } } return $value; }
/** * Get shard key aware query for single document. * * @param object $document * * @return array */ private function getQueryForDocument($document) { $id = $this->uow->getDocumentIdentifier($document); $id = $this->class->getDatabaseIdentifierValue($id); $shardKeyQueryPart = $this->getShardKeyQuery($document); $query = array_merge(array('_id' => $id), $shardKeyQueryPart); return $query; }
/** * Lood document by its identifier. * * @param string $id * @return object|null */ public function loadById($id) { $result = $this->_collection->findOne(array('_id' => $this->_class->getDatabaseIdentifierValue($id))); if ($result !== null) { return $this->_uow->getOrCreateDocument($this->_documentName, $result); } return null; }
public function getFieldsMetadata($class, $group = 'default') { $result = array(); foreach ($this->odmMetadata->getReflectionProperties() as $property) { $name = $property->getName(); $mapping = $this->odmMetadata->getFieldMapping($name); $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 'id': case 'string': case 'bin_custom': case 'bin_func': case 'bin_md5': case 'bin': case 'bin_uuid': case 'file': case 'key': case 'increment': $values['type'] = 'text'; break; case 'int': case 'float': $values['type'] = 'number'; break; /*case 'hash': $values['type'] = 'array';*/ /*case 'hash': $values['type'] = 'array';*/ case 'boolean': $values['type'] = 'boolean'; break; case 'date': case 'timestamp': $values['type'] = 'date'; break; case 'collection': $values['type'] = 'array'; break; case 'one': $values['type'] = 'array'; break; case 'many': $values['type'] = 'array'; break; default: $values['type'] = 'text'; } $result[$name] = $values; } return $result; }
public function testGetMetadataForSingleClass() { // Self-made metadata $cm1 = new ClassMetadata('Doctrine\\ODM\\MongoDB\\Tests\\Mapping\\TestDocument1'); $cm1->setCollection('group'); // Add a mapped field $cm1->mapField(array('fieldName' => 'name', 'type' => 'string')); // Add a mapped field $cm1->mapField(array('fieldName' => 'id', 'id' => true)); // and a mapped association $cm1->mapOneEmbedded(array('fieldName' => 'other', 'targetDocument' => 'Other')); $cm1->mapOneEmbedded(array('fieldName' => 'association', 'targetDocument' => 'Other')); // SUT $cmf = new ClassMetadataFactoryTestSubject(); $cmf->setMetadataFor('Doctrine\\ODM\\MongoDB\\Tests\\Mapping\\TestDocument1', $cm1); // Prechecks $this->assertEquals(array(), $cm1->parentClasses); $this->assertEquals(ClassMetadata::INHERITANCE_TYPE_NONE, $cm1->inheritanceType); $this->assertTrue($cm1->hasField('name')); $this->assertEquals(4, count($cm1->fieldMappings)); // Go $cm1 = $cmf->getMetadataFor('Doctrine\\ODM\\MongoDB\\Tests\\Mapping\\TestDocument1'); $this->assertEquals('group', $cm1->collection); $this->assertEquals(array(), $cm1->parentClasses); $this->assertTrue($cm1->hasField('name')); }
/** * @param array $options * * @return array */ private function getWriteOptions(array $options = array()) { $defaultOptions = $this->dm->getConfiguration()->getDefaultCommitOptions(); $documentOptions = []; if ($this->class->hasWriteConcern()) { $documentOptions['w'] = $this->class->getWriteConcern(); } return array_merge($defaultOptions, $documentOptions, $options); }
/** * Checks that the current field includes a reference to the supplied document. */ public function includesReferenceTo($document) { $dbRef = $this->dm->createDBRef($document); if ($this->currentField) { $keys = array('ref' => true, 'id' => true, 'db' => true); if ($this->class) { $mapping = $this->class->getFieldMapping($this->currentField); if (isset($mapping['targetDocument'])) { unset($keys['ref'], $keys['db']); } } foreach ($keys as $key => $value) { $this->query[$this->currentField][$this->cmd . 'elemMatch'][$this->cmd . $key] = $dbRef[$this->cmd . $key]; } } else { $this->query[$this->cmd . 'elemMatch'] = $dbRef; } return $this; }
/** * Add mapping data to a translation entity. * * @param ClassMetadata $metadata */ private function mapTranslation(ClassMetadata $metadata) { // In the case A -> B -> TranslationInterface, B might not have mapping defined as it // is probably defined in A, so in that case, we just return. if (!isset($this->configs[$metadata->name])) { return; } $metadata->mapManyToOne(array('fieldName' => 'translatable', 'targetEntity' => $this->configs[$metadata->name]['model'], 'inversedBy' => 'translations', 'joinColumns' => array(array('name' => 'translatable_id', 'referencedColumnName' => 'id', 'onDelete' => 'CASCADE', 'nullable' => false)))); if (!$metadata->hasField('locale')) { $metadata->mapField(array('fieldName' => 'locale', 'type' => 'string', 'nullable' => false)); } // Map unique index. $columns = array($metadata->getSingleAssociationJoinColumnName('translatable'), 'locale'); if (!$this->hasUniqueConstraint($metadata, $columns)) { $constraints = isset($metadata->table['uniqueConstraints']) ? $metadata->table['uniqueConstraints'] : array(); $constraints[$metadata->getTableName() . '_uniq_trans'] = array('columns' => $columns); $metadata->setPrimaryTable(array('uniqueConstraints' => $constraints)); } }
/** * Lood document by its identifier. * * @param string $id * @return object|null */ public function loadById($id) { $result = $this->_collection->findOne(array('_id' => $this->_class->getDatabaseIdentifierValue($id))); if ($result !== null) { $document = $this->_uow->getOrCreateDocument($this->_documentName, $result); $this->_uow->registerManaged($document, $this->_class->getPHPIdentifierValue($result['_id']), $result); return $document; } return null; }
/** * @param ClassMetadataInfo $metadata * @param $configuration */ private function setAssociationMappings(ClassMetadataInfo $metadata, $configuration) { foreach (class_parents($metadata->getName()) as $parent) { if (false === in_array($parent, $configuration->getMetadataDriverImpl()->getAllClassNames())) { continue; } $parentMetadata = new ClassMetadata($parent, $configuration->getNamingStrategy()); // Wakeup Reflection $parentMetadata->wakeupReflection($this->getReflectionService()); // Load Metadata $configuration->getMetadataDriverImpl()->loadMetadataForClass($parent, $parentMetadata); if (false === $this->isResource($parentMetadata)) { continue; } if ($parentMetadata->isMappedSuperclass) { foreach ($parentMetadata->associationMappings as $key => $value) { if ($this->hasRelation($value['association'])) { $metadata->associationMappings[$key] = $value; } } } } }
/** * Prepares insert data for document * * @param mixed $document * @return array */ public function prepareInsertData($document) { $oid = spl_object_hash($document); $changeset = $this->uow->getDocumentChangeSet($document); $insertData = array(); foreach ($this->class->fieldMappings as $mapping) { if (isset($mapping['notSaved']) && $mapping['notSaved'] === true) { continue; } $new = isset($changeset[$mapping['fieldName']][1]) ? $changeset[$mapping['fieldName']][1] : null; if ($new === null && $mapping['nullable'] === false) { continue; } if ($this->class->isIdentifier($mapping['fieldName'])) { $insertData['_id'] = $this->prepareValue($mapping, $new); continue; } $value = $this->prepareValue($mapping, $new); if ($value === null && $mapping['nullable'] === false) { continue; } $insertData[$mapping['name']] = $value; if (isset($mapping['reference'])) { $scheduleForUpdate = false; if ($mapping['type'] === 'one') { if (!isset($insertData[$mapping['name']][$this->cmd . 'id'])) { $scheduleForUpdate = true; } } elseif ($mapping['type'] === 'many') { foreach ($insertData[$mapping['name']] as $ref) { if (!isset($ref[$this->cmd . 'id'])) { $scheduleForUpdate = true; break; } } } if ($scheduleForUpdate) { unset($insertData[$mapping['name']]); $id = spl_object_hash($document); $this->documentsToUpdate[$id] = $document; $this->fieldsToUpdate[$id][$mapping['fieldName']] = array($mapping, $new); } } } // add discriminator if the class has one if ($this->class->hasDiscriminator()) { $insertData[$this->class->discriminatorField['name']] = $this->class->discriminatorValue; } return $insertData; }
/** * @param ClassMetadata $classMetadata * @param array $mapping */ private function remapAssociation(ClassMetadata $classMetadata, array $mapping) { $newMapping = $this->resolveTargetDocuments[$mapping['targetDocument']]; $newMapping = array_replace_recursive($mapping, $newMapping); $newMapping['fieldName'] = $mapping['fieldName']; // clear reference case of duplicate exception unset($classMetadata->fieldMappings[$mapping['fieldName']]); unset($classMetadata->associationMappings[$mapping['fieldName']]); switch ($mapping['association']) { case ClassMetadata::REFERENCE_ONE: $classMetadata->mapOneReference($newMapping); break; case ClassMetadata::REFERENCE_MANY: $classMetadata->mapManyReference($newMapping); break; case ClassMetadata::EMBED_ONE: $classMetadata->mapOneEmbedded($newMapping); break; case ClassMetadata::EMBED_MANY: $classMetadata->mapManyEmbedded($newMapping); break; } }
protected function buildMetadata(ClassMetadata $source, ClassMetadata $target, $eventManager) { $sourceReflClass = $source->getReflectionClass(); $targetReflClass = $target->getReflectionClass(); //Document annotations foreach ($this->annotationReader->getClassAnnotations($sourceReflClass) as $annotation) { if (defined(get_class($annotation) . '::event')) { // Raise annotation event if ($eventManager->hasListeners($annotation::event)) { $eventManager->dispatchEvent($annotation::event, new AnnotationEventArgs($target, EventType::document, $annotation, $targetReflClass, $eventManager)); } } } //Field annotations foreach ($sourceReflClass->getProperties() as $reflField) { foreach ($this->annotationReader->getPropertyAnnotations($reflField) as $annotation) { if (defined(get_class($annotation) . '::event')) { // Raise annotation event if ($eventManager->hasListeners($annotation::event)) { $eventManager->dispatchEvent($annotation::event, new AnnotationEventArgs($target, EventType::field, $annotation, $reflField, $eventManager)); } } } } //Method annotations foreach ($sourceReflClass->getMethods() as $reflMethod) { foreach ($this->annotationReader->getMethodAnnotations($reflMethod) as $annotation) { if (defined(get_class($annotation) . '::event')) { // Raise annotation event if ($eventManager->hasListeners($annotation::event)) { $eventManager->dispatchEvent($annotation::event, new AnnotationEventArgs($target, EventType::method, $annotation, $reflMethod, $eventManager)); } } } } }
/** * @param $object * @param $fieldName * @return ArrayCollection|mixed * @throws \NForms\Exceptions\MetadataException */ protected function getCollection($object, $fieldName) { if ($this->isSingleValuedAssociation($fieldName)) { throw new MetadataException("Can't get collection from association toOne."); } $collection = $this->classMetadata->getFieldValue($object, $fieldName); if ($collection === NULL) { $collection = new ArrayCollection(); $this->classMetadata->setFieldValue($object, $fieldName, $collection); } if (!$collection instanceof Collection) { throw new MetadataException('Expected Doctrine\\Common\\Collections\\Collection, given ' . (is_object($collection) ? get_class($collection) : gettype($collection))); } return $collection; }
/** * Prepare where values converting document object field names to the document collection * field name. * * @param string $fieldName * @param string $value * @return string $value */ private function prepareWhereValue(&$fieldName, $value) { if (strpos($fieldName, '.') !== false) { $e = explode('.', $fieldName); $mapping = $this->class->getFieldMapping($e[0]); if ($this->class->hasField($e[0])) { $name = $this->class->fieldMappings[$e[0]]['name']; if ($name !== $e[0]) { $e[0] = $name; } } if (isset($mapping['targetDocument'])) { $targetClass = $this->dm->getClassMetadata($mapping['targetDocument']); if ($targetClass->hasField($e[1]) && $targetClass->identifier === $e[1]) { $fieldName = $e[0] . '.$id'; $value = $targetClass->getDatabaseIdentifierValue($value); } elseif ($e[1] === '$id') { $value = $targetClass->getDatabaseIdentifierValue($value); } } } elseif ($this->class->hasField($fieldName) && ! $this->class->isIdentifier($fieldName)) { $name = $this->class->fieldMappings[$fieldName]['name']; if ($name !== $fieldName) { $fieldName = $name; } } else { if ($fieldName === $this->class->identifier || $fieldName === '_id') { $fieldName = '_id'; if (is_array($value)) { if (isset($value[$this->cmd.'in'])) { foreach ($value[$this->cmd.'in'] as $k => $v) { $value[$this->cmd.'in'][$k] = $this->class->getDatabaseIdentifierValue($v); } } else { foreach ($value as $k => $v) { $value[$k] = $this->class->getDatabaseIdentifierValue($v); } } } else { $value = $this->class->getDatabaseIdentifierValue($value); } } } return $value; }
/** * Determines which fields get serialized. * * @return array The names of all the fields that should be serialized. */ public function __sleep() { $serialized = parent::__sleep(); if (isset($this->accessControl)) { $serialized[] = 'accessControl'; } if (isset($this->crypt)) { $serialized[] = 'crypt'; } if (isset($this->generator)) { $serialized[] = 'generator'; } if (isset($this->freeze)) { $serialized[] = 'freeze'; } if (isset($this->owner)) { $serialized[] = 'owner'; } if (isset($this->permissions)) { $serialized[] = 'permissions'; } if (isset($this->rest)) { $serialized[] = 'rest'; } if (isset($this->roles)) { $serialized[] = 'roles'; } if (isset($this->serializer)) { $serialized[] = 'serializer'; } if (isset($this->softDelete)) { $serialized[] = 'softDelete'; } if (isset($this->stamp)) { $serialized[] = 'stamp'; } if (isset($this->state)) { $serialized[] = 'state'; } if (isset($this->validator)) { $serialized[] = 'validator'; } if (isset($this->zones)) { $serialized[] = 'zones'; } return $serialized; }