Doctrine\ODM\CouchDB\UnitOfWork::flush()

Complexity

Conditions	41
Paths	14212

Size

Total Lines

147

Duplication

Lines	10
Ratio	6.8 %

Importance

Changes

0

<?php
    public function flush()
    {
        $this->detectChangedDocuments();

        if ($this->evm->hasListeners(Event::onFlush)) {
            $this->evm->dispatchEvent(Event::onFlush, new Event\OnFlushEventArgs($this));
        }

        $config = $this->dm->getConfiguration();

        $bulkUpdater = $this->dm->getCouchDBClient()->createBulkUpdater();
        $bulkUpdater->setAllOrNothing($config->getAllOrNothingFlush());

        foreach ($this->scheduledRemovals AS $oid => $document) {
            if ($document instanceof Proxy && !$document->__isInitialized__) {

Accessing __isInitialized__ on the interface Doctrine\Common\Persistence\Proxy suggest that you code against a concrete implementation. How about adding an instanceof check?

                $response = $this->dm->getCouchDBClient()->findDocument($this->getDocumentIdentifier($document));

                if ($response->status == 404) {
                    $this->removeFromIdentityMap($document);
                    throw new \Doctrine\ODM\CouchDB\DocumentNotFoundException();
                }

                $this->documentRevisions[$oid] = $response->body['_rev'];
            }

            $bulkUpdater->deleteDocument($this->documentIdentifiers[$oid], $this->documentRevisions[$oid]);
            $this->removeFromIdentityMap($document);

            if ($this->evm->hasListeners(Event::postRemove)) {

This code seems to be duplicated across your project.

                $this->evm->dispatchEvent(Event::postRemove, new Event\LifecycleEventArgs($document, $this->dm));
            }
        }

        foreach ($this->scheduledUpdates AS $oid => $document) {
            $class = $this->dm->getClassMetadata(get_class($document));

            if ($this->evm->hasListeners(Event::preUpdate)) {

This code seems to be duplicated across your project.

                $this->evm->dispatchEvent(Event::preUpdate, new Event\LifecycleEventArgs($document, $this->dm));
                $this->computeChangeSet($class, $document); // TODO: prevent association computations in this case?
            }

            $data = $this->metadataResolver->createDefaultDocumentStruct($class);

            // Convert field values to json values.
            foreach ($this->originalData[$oid] AS $fieldName => $fieldValue) {
                if (isset($class->fieldMappings[$fieldName])) {
                    if ($fieldValue !== null && isset($class->fieldMappings[$fieldName]['embedded'])) {
                        // As we store the serialized value in originalEmbeddedData, we can simply copy here.
                        $fieldValue = $this->originalEmbeddedData[$oid][$class->fieldMappings[$fieldName]['jsonName']];

                    } else if ($fieldValue !== null) {
                        $fieldValue = Type::getType($class->fieldMappings[$fieldName]['type'])
                            ->convertToCouchDBValue($fieldValue);
                    }

                    if (isset($class->fieldMappings[$fieldName]['id'])) {
                        $fieldValue = (string)$fieldValue;
                    }

                    $data[$class->fieldMappings[$fieldName]['jsonName']] = $fieldValue;

                } else if (isset($class->associationsMappings[$fieldName])) {
                    if ($class->associationsMappings[$fieldName]['type'] & ClassMetadata::TO_ONE) {
                        if (\is_object($fieldValue)) {
                            $fieldValue = $this->getDocumentIdentifier($fieldValue);
                        } else {
                            $fieldValue = null;
                        }
                        $data = $this->metadataResolver->storeAssociationField($data, $class, $this->dm, $fieldName, $fieldValue);
                    } else if ($class->associationsMappings[$fieldName]['type'] & ClassMetadata::TO_MANY) {
                        if ($class->associationsMappings[$fieldName]['isOwning']) {
                            // TODO: Optimize when not initialized yet! In ManyToMany case we can keep track of ALL ids
                            $ids = array();
                            if (is_array($fieldValue) || $fieldValue instanceof \Doctrine\Common\Collections\Collection) {
                                foreach ($fieldValue AS $key => $relatedObject) {
                                    $ids[$key] = $this->getDocumentIdentifier($relatedObject);
                                }
                            }
                            $data = $this->metadataResolver->storeAssociationField($data, $class, $this->dm, $fieldName, $ids);
                        }
                    }
                } else if ($class->hasAttachments && $fieldName == $class->attachmentField) {
                    if (is_array($fieldValue) && $fieldValue) {

The expression $fieldValue of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

                        $data['_attachments'] = array();
                        foreach ($fieldValue AS $filename => $attachment) {
                            if (!($attachment instanceof \Doctrine\CouchDB\Attachment)) {
                                throw CouchDBException::invalidAttachment($class->name, $this->documentIdentifiers[$oid], $filename);
                            }
                            $data['_attachments'][$filename] = $attachment->toArray();
                        }
                    }
                }
            }

            // respect the non mapped data, otherwise they will be deleted.
            if (isset($this->nonMappedData[$oid]) && $this->nonMappedData[$oid]) {
                $data = array_merge($data, $this->nonMappedData[$oid]);
            }

            $rev = $this->getDocumentRevision($document);
            if ($rev) {
                $data['_rev'] = $rev;
            }
            $data['_id'] = $this->documentIdentifiers[$oid];

            $bulkUpdater->updateDocument($data);
        }
        $response = $bulkUpdater->execute();
        $updateConflictDocuments = array();
        if ($response->status == 201) {
            foreach ($response->body AS $docResponse) {
                if (!isset($this->identityMap[$docResponse['id']])) {
                    // deletions
                    continue;
                }

                $document = $this->identityMap[$docResponse['id']];
                if (isset($docResponse['error'])) {
                    $updateConflictDocuments[] = $document;
                } else {
                    $this->documentRevisions[spl_object_hash($document)] = $docResponse['rev'];
                    $class = $this->dm->getClassMetadata(get_class($document));
                    if ($class->isVersioned) {
                        $class->reflFields[$class->versionField]->setValue($document, $docResponse['rev']);
                    }
                }

                if ($this->evm->hasListeners(Event::postUpdate)) {

This code seems to be duplicated across your project.

                    $this->evm->dispatchEvent(Event::postUpdate, new Event\LifecycleEventArgs($document, $this->dm));
                }
            }
        } else if ($response->status >= 400) {
            throw HTTPException::fromResponse($bulkUpdater->getPath(), $response);
        }

        foreach ($this->visitedCollections AS $col) {
            $col->takeSnapshot();
        }

        $this->scheduledUpdates =
        $this->scheduledRemovals =
        $this->visitedCollections = array();

        if (count($updateConflictDocuments)) {
            throw new UpdateConflictException($updateConflictDocuments);
        }
    }