PHP ClassMetadata::getFieldValue方法代码示例

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

    /**
     * Updates the already persisted document if it has any new changesets.
     *
     * @param object $document
     * @param array $options Array of options to be used with update()
     */
    public function update($document, array $options = array())
    {
        $id = $this->uow->getDocumentIdentifier($document);
        $update = $this->dp->prepareUpdateData($document);

        if ( ! empty($update)) {

            $id = $this->class->getDatabaseIdentifierValue($id);
            $query = array('_id' => $id);

            // Include versioning updates
            if ($this->class->isVersioned) {
                $versionMapping = $this->class->fieldMappings[$this->class->versionField];
                $currentVersion = $this->class->getFieldValue($document, $this->class->versionField);
                if ($versionMapping['type'] === 'int') {
                    $nextVersion = $currentVersion + 1;
                    $update[$this->cmd . 'inc'][$versionMapping['name']] = 1;
                    $query[$versionMapping['name']] = $currentVersion;
                    $this->class->setFieldValue($document, $this->class->versionField, $nextVersion);
                } elseif ($versionMapping['type'] === 'date') {
                    $nextVersion = new \DateTime();
                    $update[$this->cmd . 'set'][$versionMapping['name']] = new \MongoDate($nextVersion->getTimestamp());
                    $query[$versionMapping['name']] = new \MongoDate($currentVersion->getTimestamp());
                    $this->class->setFieldValue($document, $this->class->versionField, $nextVersion);
                }
                $options['safe'] = true;
            }

            if ($this->class->isLockable) {
                $isLocked = $this->class->getFieldValue($document, $this->class->lockField);
                $lockMapping = $this->class->fieldMappings[$this->class->lockField];
                if ($isLocked) {
                    $update[$this->cmd . 'unset'] = array($lockMapping['name'] => true);
                } else {
                    $query[$lockMapping['name']] = array($this->cmd . 'exists' => false);
                }
            }

            if ($this->dm->getEventManager()->hasListeners(Events::onUpdatePrepared)) {
                $this->dm->getEventManager()->dispatchEvent(
                    Events::onUpdatePrepared, new OnUpdatePreparedArgs($this->dm, $document, $update)
                );
            }

            $result = $this->collection->update($query, $update, $options);

            if (($this->class->isVersioned || $this->class->isLockable) && ! $result['n']) {
                throw LockException::lockFailed($document);
            }
        }
    }

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

 /**
  * If you are priming references inside an embedded document you'll need to parse the dot syntax.
  * This method will traverse through embedded documents to find the reference to prime.
  * However this method will not traverse through multiple layers of references.
  * I.e. you can prime this: myDocument.embeddedDocument.embeddedDocuments.embeddedDocuments.referencedDocument(s)
  * ... but you cannot prime this: myDocument.embeddedDocument.referencedDocuments.referencedDocument(s)
  * This addresses Issue #624.
  *
  * @param string             $fieldName
  * @param ClassMetadata      $class
  * @param array|\Traversable $documents
  * @param array              $mapping
  * @return array
  */
 private function parseDotSyntaxForPrimer($fieldName, $class, $documents, $mapping = null)
 {
     // Recursion passthrough:
     if ($mapping != null) {
         return array('fieldName' => $fieldName, 'class' => $class, 'documents' => $documents, 'mapping' => $mapping);
     }
     // Gather mapping data:
     $e = explode('.', $fieldName);
     if (!isset($class->fieldMappings[$e[0]])) {
         throw new \InvalidArgumentException(sprintf('Field %s cannot be further parsed for priming because it is unmapped.', $fieldName));
     }
     $mapping = $class->fieldMappings[$e[0]];
     $e[0] = $mapping['name'];
     // Case of embedded document(s) to recurse through:
     if (!isset($mapping['reference'])) {
         if (empty($mapping['embedded'])) {
             throw new \InvalidArgumentException(sprintf('Field "%s" of fieldName "%s" is not an embedded document, therefore no children can be primed. Aborting. This feature does not support traversing nested referenced documents at this time.', $e[0], $fieldName));
         }
         if (!isset($mapping['targetDocument'])) {
             throw new \InvalidArgumentException(sprintf('No target document class has been specified for this embedded document. However, targetDocument mapping must be specified in order for prime to work on fieldName "%s" for mapping of field "%s".', $fieldName, $mapping['fieldName']));
         }
         $childDocuments = array();
         foreach ($documents as $document) {
             $fieldValue = $class->getFieldValue($document, $e[0]);
             if ($fieldValue instanceof PersistentCollection) {
                 foreach ($fieldValue as $elemDocument) {
                     array_push($childDocuments, $elemDocument);
                 }
             } else {
                 array_push($childDocuments, $fieldValue);
             }
         }
         array_shift($e);
         $childClass = $this->dm->getClassMetadata($mapping['targetDocument']);
         if (!$childClass->hasField($e[0])) {
             throw new \InvalidArgumentException(sprintf('Field to prime must exist in embedded target document. Reference fieldName "%s" for mapping of target document class "%s".', $fieldName, $mapping['targetDocument']));
         }
         $childFieldName = implode('.', $e);
         return $this->parseDotSyntaxForPrimer($childFieldName, $childClass, $childDocuments);
     }
     // Case of reference(s) to prime:
     if ($mapping['reference']) {
         if (count($e) > 1) {
             throw new \InvalidArgumentException(sprintf('Cannot prime more than one layer deep but field "%s" is a reference and has children in fieldName "%s".', $e[0], $fieldName));
         }
         return array('fieldName' => $fieldName, 'class' => $class, 'documents' => $documents, 'mapping' => $mapping);
     }
 }

 /**
  * Prepares array of values to be stored in mongo to represent embedded object.
  *
  * @param ClassMetadata $class
  * @param Document $doc
  * @return array
  */
 private function _prepareDocEmbeded(ClassMetadata $class, $doc)
 {
     if (!is_object($doc)) {
         return $doc;
     }
     $changeset = array();
     foreach ($class->fieldMappings as $mapping) {
         $rawValue = $class->getFieldValue($doc, $mapping['fieldName']);
         if (!isset($rawValue)) {
             continue;
         }
         if (isset($mapping['embedded']) || isset($mapping['reference'])) {
             $classMetadata = $this->_dm->getClassMetadata($mapping['targetDocument']);
             if (isset($mapping['embedded'])) {
                 if ($mapping['type'] == 'many') {
                     $value = array();
                     foreach ($rawValue as $doc) {
                         $value[] = $this->_prepareDocEmbeded($classMetadata, $doc);
                     }
                 } elseif ($mapping['type'] == 'one') {
                     $value = $this->_prepareDocEmbeded($classMetadata, $rawValue);
                 }
             } elseif (isset($mapping['reference'])) {
                 if ($mapping['type'] == 'many') {
                     $value = array();
                     foreach ($rawValue as $doc) {
                         $value[] = $this->_prepareDocReference($classMetadata, $doc);
                     }
                 } else {
                     $value = $this->_prepareDocReference($classMetadata, $rawValue);
                 }
             }
         } else {
             $value = Type::getType($mapping['type'])->convertToDatabaseValue($rawValue);
         }
         $changeset[$mapping['fieldName']] = $value;
     }
     return $changeset;
 }

 /**
  * Cascades the preLoad event to embedded documents.
  *
  * @param ClassMetadata $class
  * @param object $document
  * @param array $data
  */
 private function cascadePreLoad(ClassMetadata $class, $document, $data)
 {
     foreach ($class->fieldMappings as $mapping) {
         if (isset($mapping['embedded'])) {
             $value = $class->getFieldValue($document, $mapping['fieldName']);
             if ($value === null) {
                 continue;
             }
             if ($mapping['type'] === 'one') {
                 $value = array($value);
             }
             foreach ($value as $entry) {
                 $entryClass = $this->dm->getClassMetadata(get_class($entry));
                 if (isset($entryClass->lifecycleCallbacks[Events::preLoad])) {
                     $args = array(&$data);
                     $entryClass->invokeLifecycleCallbacks(Events::preLoad, $entry, $args);
                 }
                 if ($this->evm->hasListeners(Events::preLoad)) {
                     $this->evm->dispatchEvent(Events::preLoad, new PreLoadEventArgs($entry, $this->dm, $data[$mapping['name']]));
                 }
                 $this->cascadePreLoad($entryClass, $entry, $data[$mapping['name']]);
             }
         }
     }
 }

 /**
  * Prime references within a mapped field of one or more documents.
  *
  * If a $primer callable is provided, it should have the same signature as
  * the default primer defined in the constructor. If $primer is not
  * callable, the default primer will be used.
  *
  * @param ClassMetadata      $class     Class metadata for the document
  * @param array|\Traversable $documents Documents containing references to prime
  * @param string             $fieldName Field name containing references to prime
  * @param array              $hints     UnitOfWork hints for priming queries
  * @param callable           $primer    Optional primer callable
  * @throws \InvalidArgumentException If the mapped field is not the owning
  *                                   side of a reference relationship.
  * @throws \InvalidArgumentException If $primer is not callable
  * @throws \LogicException If the mapped field is a simple reference and is
  *                         missing a target document class.
  */
 public function primeReferences(ClassMetadata $class, $documents, $fieldName, array $hints = array(), $primer = null)
 {
     $mapping = $class->getFieldMapping($fieldName);
     /* Inverse-side references would need to be populated before we can
      * collect references to be primed. This is not supported.
      */
     if (!isset($mapping['reference']) || !$mapping['isOwningSide']) {
         throw new \InvalidArgumentException(sprintf('Field "%s" is not the owning side of a reference relationship in class "%s"', $fieldName, $class->name));
     }
     /* Simple reference require a target document class so we can construct
      * the priming query.
      */
     if (!empty($mapping['simple']) && empty($mapping['targetDocument'])) {
         throw new \LogicException(sprintf('Field "%s" is a simple reference without a target document class in class "%s"', $fieldName, $class->name));
     }
     if ($primer !== null && !is_callable($primer)) {
         throw new \InvalidArgumentException('$primer is not callable');
     }
     $primer = $primer ?: $this->defaultPrimer;
     $groupedIds = array();
     foreach ($documents as $document) {
         $fieldValue = $class->getFieldValue($document, $fieldName);
         /* The field will need to be either a Proxy (reference-one) or
          * PersistentCollection (reference-many) in order to prime anything.
          */
         if (!is_object($fieldValue)) {
             continue;
         }
         if ($mapping['type'] === 'one' && $fieldValue instanceof Proxy && !$fieldValue->__isInitialized()) {
             $refClass = $this->dm->getClassMetadata(get_class($fieldValue));
             $id = $this->uow->getDocumentIdentifier($fieldValue);
             $groupedIds[$refClass->name][serialize($id)] = $id;
         } elseif ($mapping['type'] == 'many' && $fieldValue instanceof PersistentCollection) {
             $this->addManyReferences($fieldValue, $groupedIds);
         }
     }
     foreach ($groupedIds as $className => $ids) {
         $refClass = $this->dm->getClassMetadata($className);
         call_user_func($primer, $this->dm, $refClass, array_values($ids), $hints);
     }
 }