Since: 1.0
Author: Jonathan H. Wage (jonwage@gmail.com)
Inheritance: extends Doctrine\Common\Persistence\Mapping\MappingException
コード例 #1
0
ファイル: Out.php プロジェクト: doctrine/mongodb-odm
 /**
  * @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());
 }
 function it_checks_a_non_existent_mapping_relationship($classMetadata, ConfigurationInterface $configuration)
 {
     $configuration->getType()->willReturn(ConfigurationInterface::TYPE_MULTI);
     $configuration->getName()->willReturn('foo');
     $classMetadata->getFieldMapping('foo')->willThrow(MappingException::mappingNotFound('spec\\Pim\\Bundle\\ReferenceDataBundle\\RequirementChecker\\CustomValidProductValue', 'foo'));
     $this->check($configuration)->shouldReturn(false);
     $this->getFailure()->shouldReturn("No mapping found for field 'foo' in class " . "'spec\\Pim\\Bundle\\ReferenceDataBundle\\RequirementChecker\\CustomValidProductValue'.");
 }
コード例 #3
0
ファイル: AnnotationDriver.php プロジェクト: im286er/ent
 /**
  * {@inheritdoc}
  */
 public function loadMetadataForClass($className, ClassMetadata $class)
 {
     /** @var $class ClassMetadataInfo */
     $reflClass = $class->getReflectionClass();
     $classAnnotations = $this->reader->getClassAnnotations($reflClass);
     $documentAnnots = array();
     foreach ($classAnnotations as $annot) {
         $classAnnotations[get_class($annot)] = $annot;
         foreach ($this->entityAnnotationClasses as $annotClass => $i) {
             if ($annot instanceof $annotClass) {
                 $documentAnnots[$i] = $annot;
                 continue 2;
             }
         }
         // non-document class annotations
         if ($annot instanceof ODM\AbstractIndex) {
             $this->addIndex($class, $annot);
         }
         if ($annot instanceof ODM\Indexes) {
             foreach (is_array($annot->value) ? $annot->value : array($annot->value) as $index) {
                 $this->addIndex($class, $index);
             }
         } elseif ($annot instanceof ODM\InheritanceType) {
             $class->setInheritanceType(constant('Doctrine\\ODM\\MongoDB\\Mapping\\ClassMetadata::INHERITANCE_TYPE_' . $annot->value));
         } elseif ($annot instanceof ODM\DiscriminatorField) {
             // $fieldName property is deprecated, but fall back for BC
             if (isset($annot->value)) {
                 $class->setDiscriminatorField($annot->value);
             } elseif (isset($annot->name)) {
                 $class->setDiscriminatorField($annot->name);
             } elseif (isset($annot->fieldName)) {
                 $class->setDiscriminatorField($annot->fieldName);
             }
         } elseif ($annot instanceof ODM\DiscriminatorMap) {
             $class->setDiscriminatorMap($annot->value);
         } elseif ($annot instanceof ODM\DiscriminatorValue) {
             $class->setDiscriminatorValue($annot->value);
         } elseif ($annot instanceof ODM\ChangeTrackingPolicy) {
             $class->setChangeTrackingPolicy(constant('Doctrine\\ODM\\MongoDB\\Mapping\\ClassMetadata::CHANGETRACKING_' . $annot->value));
         }
     }
     if (!$documentAnnots) {
         throw MappingException::classIsNotAValidDocument($className);
     }
     // find the winning document annotation
     ksort($documentAnnots);
     $documentAnnot = reset($documentAnnots);
     if ($documentAnnot instanceof ODM\MappedSuperclass) {
         $class->isMappedSuperclass = true;
     } elseif ($documentAnnot instanceof ODM\EmbeddedDocument) {
         $class->isEmbeddedDocument = true;
     }
     if (isset($documentAnnot->db)) {
         $class->setDatabase($documentAnnot->db);
     }
     if (isset($documentAnnot->collection)) {
         $class->setCollection($documentAnnot->collection);
     }
     if (isset($documentAnnot->repositoryClass)) {
         $class->setCustomRepositoryClass($documentAnnot->repositoryClass);
     }
     if (isset($documentAnnot->indexes)) {
         foreach ($documentAnnot->indexes as $index) {
             $this->addIndex($class, $index);
         }
     }
     if (isset($documentAnnot->requireIndexes)) {
         $class->setRequireIndexes($documentAnnot->requireIndexes);
     }
     if (isset($documentAnnot->slaveOkay)) {
         $class->setSlaveOkay($documentAnnot->slaveOkay);
     }
     foreach ($reflClass->getProperties() as $property) {
         if ($class->isMappedSuperclass && !$property->isPrivate() || $class->isInheritedField($property->name) && $property->getDeclaringClass()->name !== $class->name) {
             continue;
         }
         $indexes = array();
         $mapping = array('fieldName' => $property->getName());
         $fieldAnnot = null;
         foreach ($this->reader->getPropertyAnnotations($property) as $annot) {
             if ($annot instanceof ODM\AbstractField) {
                 $fieldAnnot = $annot;
             }
             if ($annot instanceof ODM\AbstractIndex) {
                 $indexes[] = $annot;
             }
             if ($annot instanceof ODM\Indexes) {
                 foreach (is_array($annot->value) ? $annot->value : array($annot->value) as $index) {
                     $indexes[] = $index;
                 }
             } elseif ($annot instanceof ODM\AlsoLoad) {
                 $mapping['alsoLoadFields'] = (array) $annot->value;
             } elseif ($annot instanceof ODM\Version) {
                 $mapping['version'] = true;
             } elseif ($annot instanceof ODM\Lock) {
                 $mapping['lock'] = true;
             }
         }
         if ($fieldAnnot) {
             $mapping = array_replace($mapping, (array) $fieldAnnot);
             $class->mapField($mapping);
         }
         if ($indexes) {
             foreach ($indexes as $index) {
                 $name = isset($mapping['name']) ? $mapping['name'] : $mapping['fieldName'];
                 $keys = array($name => $index->order ?: 'asc');
                 $this->addIndex($class, $index, $keys);
             }
         }
     }
     /** @var $method \ReflectionMethod */
     foreach ($reflClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) {
         /* Filter for the declaring class only. Callbacks from parent
          * classes will already be registered.
          */
         if ($method->getDeclaringClass()->name !== $reflClass->name) {
             continue;
         }
         foreach ($this->reader->getMethodAnnotations($method) as $annot) {
             if ($annot instanceof ODM\AlsoLoad) {
                 $class->registerAlsoLoadMethod($method->getName(), $annot->value);
             }
             if (!isset($classAnnotations['Doctrine\\ODM\\MongoDB\\Mapping\\Annotations\\HasLifecycleCallbacks'])) {
                 continue;
             }
             if ($annot instanceof ODM\PrePersist) {
                 $class->addLifecycleCallback($method->getName(), Events::prePersist);
             } elseif ($annot instanceof ODM\PostPersist) {
                 $class->addLifecycleCallback($method->getName(), Events::postPersist);
             } elseif ($annot instanceof ODM\PreUpdate) {
                 $class->addLifecycleCallback($method->getName(), Events::preUpdate);
             } elseif ($annot instanceof ODM\PostUpdate) {
                 $class->addLifecycleCallback($method->getName(), Events::postUpdate);
             } elseif ($annot instanceof ODM\PreRemove) {
                 $class->addLifecycleCallback($method->getName(), Events::preRemove);
             } elseif ($annot instanceof ODM\PostRemove) {
                 $class->addLifecycleCallback($method->getName(), Events::postRemove);
             } elseif ($annot instanceof ODM\PreLoad) {
                 $class->addLifecycleCallback($method->getName(), Events::preLoad);
             } elseif ($annot instanceof ODM\PostLoad) {
                 $class->addLifecycleCallback($method->getName(), Events::postLoad);
             } elseif ($annot instanceof ODM\PreFlush) {
                 $class->addLifecycleCallback($method->getName(), Events::preFlush);
             }
         }
     }
 }
コード例 #4
0
 /**
  * Gets the mapping of a field.
  *
  * @param string $fieldName  The field name.
  *
  * @return array  The field mapping.
  *
  * @throws MappingException if the $fieldName is not found in the fieldMappings array
  *
  * @throws MappingException
  */
 public function getFieldMapping($fieldName)
 {
     if (!isset($this->fieldMappings[$fieldName])) {
         throw MappingException::mappingNotFound($this->name, $fieldName);
     }
     return $this->fieldMappings[$fieldName];
 }
コード例 #5
0
 /**
  * Validates the identifier mapping.
  *
  * @param ClassMetadata $class
  */
 protected function validateIdentifier($class)
 {
     if (!$class->identifier && !$class->isMappedSuperclass && !$class->isEmbeddedDocument) {
         throw MappingException::identifierRequired($class->name);
     }
 }
コード例 #6
0
 /**
  * Gets the field mapping by its DB name.
  * E.g. it returns identifier's mapping when called with _id.
  *
  * @param string $dbFieldName
  *
  * @return array
  * @throws MappingException
  */
 public function getFieldMappingByDbFieldName($dbFieldName)
 {
     foreach ($this->fieldMappings as $mapping) {
         if ($mapping['name'] == $dbFieldName) {
             return $mapping;
         }
     }
     throw MappingException::mappingNotFoundByDbName($this->name, $dbFieldName);
 }
コード例 #7
0
ファイル: Expr.php プロジェクト: WillSkates/mongodb-odm
 /**
  * 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;
 }
コード例 #8
0
ファイル: Type.php プロジェクト: alcaeus/mongodb-odm
 /**
  * Overrides an already defined type to use a different implementation.
  *
  * @static
  * @param string $name
  * @param string $className
  * @throws MappingException
  */
 public static function overrideType($name, $className)
 {
     if (!isset(self::$typesMap[$name])) {
         throw MappingException::typeNotFound($name);
     }
     self::$typesMap[$name] = $className;
 }
コード例 #9
0
 private function completeIdGeneratorMapping(ClassMetadataInfo $class)
 {
     $idGenOptions = $class->generatorOptions;
     switch ($class->generatorType) {
         case ClassMetadata::GENERATOR_TYPE_AUTO:
             $class->setIdGenerator(new \Doctrine\ODM\MongoDB\Id\AutoGenerator());
             break;
         case ClassMetadata::GENERATOR_TYPE_INCREMENT:
             $incrementGenerator = new \Doctrine\ODM\MongoDB\Id\IncrementGenerator();
             if (isset($idGenOptions['key'])) {
                 $incrementGenerator->setKey($idGenOptions['key']);
             }
             if (isset($idGenOptions['collection'])) {
                 $incrementGenerator->setCollection($idGenOptions['collection']);
             }
             $class->setIdGenerator($incrementGenerator);
             break;
         case ClassMetadata::GENERATOR_TYPE_UUID:
             $uuidGenerator = new \Doctrine\ODM\MongoDB\Id\UuidGenerator();
             isset($idGenOptions['salt']) && $uuidGenerator->setSalt($idGenOptions['salt']);
             $class->setIdGenerator($uuidGenerator);
             break;
         case ClassMetadata::GENERATOR_TYPE_ALNUM:
             $alnumGenerator = new \Doctrine\ODM\MongoDB\Id\AlnumGenerator();
             if (isset($idGenOptions['pad'])) {
                 $alnumGenerator->setPad($idGenOptions['pad']);
             }
             if (isset($idGenOptions['chars'])) {
                 $alnumGenerator->setChars($idGenOptions['chars']);
             } elseif (isset($idGenOptions['awkwardSafe'])) {
                 $alnumGenerator->setAwkwardSafeMode($idGenOptions['awkwardSafe']);
             }
             $class->setIdGenerator($alnumGenerator);
             break;
         case ClassMetadata::GENERATOR_TYPE_CUSTOM:
             if (empty($idGenOptions['class'])) {
                 throw MappingException::missingIdGeneratorClass($class->name);
             }
             $customGenerator = new $idGenOptions['class']();
             unset($idGenOptions['class']);
             if (!$customGenerator instanceof \Doctrine\ODM\MongoDB\Id\AbstractIdGenerator) {
                 throw MappingException::classIsNotAValidGenerator(get_class($customGenerator));
             }
             $methods = get_class_methods($customGenerator);
             foreach ($idGenOptions as $name => $value) {
                 $method = 'set' . ucfirst($name);
                 if (!in_array($method, $methods)) {
                     throw MappingException::missingGeneratorSetter(get_class($customGenerator), $name);
                 }
                 $customGenerator->{$method}($value);
             }
             $class->setIdGenerator($customGenerator);
             break;
         case ClassMetadata::GENERATOR_TYPE_NONE:
             break;
         default:
             throw new MappingException("Unknown generator type: " . $class->generatorType);
     }
 }
コード例 #10
0
 /**
  * Returns a DBRef array for the supplied document.
  *
  * @param mixed $document A document object
  * @param array $referenceMapping Mapping for the field that references the document
  *
  * @throws \InvalidArgumentException
  * @return array A DBRef array
  */
 public function createDBRef($document, array $referenceMapping = null)
 {
     if (!is_object($document)) {
         throw new \InvalidArgumentException('Cannot create a DBRef, the document is not an object');
     }
     $class = $this->getClassMetadata(get_class($document));
     $id = $this->unitOfWork->getDocumentIdentifier($document);
     if (!$id) {
         throw new \RuntimeException(sprintf('Cannot create a DBRef for class %s without an identifier. Have you forgotten to persist/merge the document first?', $class->name));
     }
     if ($referenceMapping['storeAs'] === ClassMetadataInfo::REFERENCE_STORE_AS_ID) {
         if ($class->inheritanceType === ClassMetadataInfo::INHERITANCE_TYPE_SINGLE_COLLECTION) {
             throw MappingException::simpleReferenceMustNotTargetDiscriminatedDocument($referenceMapping['targetDocument']);
         }
         return $class->getDatabaseIdentifierValue($id);
     }
     $dbRef = array('$ref' => $class->getCollection(), '$id' => $class->getDatabaseIdentifierValue($id));
     if ($referenceMapping['storeAs'] === ClassMetadataInfo::REFERENCE_STORE_AS_DB_REF_WITH_DB) {
         $dbRef['$db'] = $this->getDocumentDatabase($class->name)->getName();
     }
     /* If the class has a discriminator (field and value), use it. A child
      * class that is not defined in the discriminator map may only have a
      * discriminator field and no value, so default to the full class name.
      */
     if (isset($class->discriminatorField)) {
         $dbRef[$class->discriminatorField] = isset($class->discriminatorValue) ? $class->discriminatorValue : $class->name;
     }
     /* Add a discriminator value if the referenced document is not mapped
      * explicitly to a targetDocument class.
      */
     if ($referenceMapping !== null && !isset($referenceMapping['targetDocument'])) {
         $discriminatorField = $referenceMapping['discriminatorField'];
         $discriminatorValue = isset($referenceMapping['discriminatorMap']) ? array_search($class->name, $referenceMapping['discriminatorMap']) : $class->name;
         /* If the discriminator value was not found in the map, use the full
          * class name. In the future, it may be preferable to throw an
          * exception here (perhaps based on some strictness option).
          *
          * @see PersistenceBuilder::prepareEmbeddedDocumentValue()
          */
         if ($discriminatorValue === false) {
             $discriminatorValue = $class->name;
         }
         $dbRef[$discriminatorField] = $discriminatorValue;
     }
     return $dbRef;
 }
コード例 #11
0
ファイル: Lookup.php プロジェクト: doctrine/mongodb-odm
 /**
  * @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;
 }
コード例 #12
0
 /**
  * Finds a document by its identifier
  *
  * @throws LockException
  * @param string|object $id The identifier
  * @param int $lockMode
  * @param int $lockVersion
  * @return object The document.
  */
 public function find($id, $lockMode = LockMode::NONE, $lockVersion = null)
 {
     if ($id === null) {
         return;
     }
     if (is_array($id)) {
         list($identifierFieldName) = $this->class->getIdentifierFieldNames();
         if (!isset($id[$identifierFieldName])) {
             throw MappingException::missingIdentifierField($this->documentName, $identifierFieldName);
         }
         $id = $id[$identifierFieldName];
     }
     // Check identity map first
     if ($document = $this->uow->tryGetById($id, $this->class->rootDocumentName)) {
         if ($lockMode != LockMode::NONE) {
             $this->dm->lock($document, $lockMode, $lockVersion);
         }
         return $document;
         // Hit!
     }
     if ($lockMode == LockMode::NONE) {
         return $this->uow->getDocumentPersister($this->documentName)->load($id);
     } else {
         if ($lockMode == LockMode::OPTIMISTIC) {
             if (!$this->class->isVersioned) {
                 throw LockException::notVersioned($this->documentName);
             }
             $document = $this->uow->getDocumentPersister($this->documentName)->load($id);
             $this->uow->lock($document, $lockMode, $lockVersion);
             return $document;
         } else {
             return $this->uow->getDocumentPersister($this->documentName)->load($id, null, array(), $lockMode);
         }
     }
 }