vendor/bestit/commercetools-odm/src/UnitOfWork.php line 573

Open in your IDE?
  1. <?php
  3. namespace BestIt\CommercetoolsODM;
  5. use BestIt\CommercetoolsODM\ActionBuilder\ActionBuilderProcessorInterface;
  6. use BestIt\CommercetoolsODM\ActionBuilder\Product\ResolveAttributeValueTrait;
  7. use BestIt\CommercetoolsODM\Event\LifecycleEventArgs;
  8. use BestIt\CommercetoolsODM\Event\ListenersInvoker;
  9. use BestIt\CommercetoolsODM\Event\OnFlushEventArgs;
  10. use BestIt\CommercetoolsODM\Exception\APIException;
  11. use BestIt\CommercetoolsODM\Exception\ConnectException;
  12. use BestIt\CommercetoolsODM\Helper\DocumentManagerAwareTrait;
  13. use BestIt\CommercetoolsODM\Helper\EventManagerAwareTrait;
  14. use BestIt\CommercetoolsODM\Helper\ListenerInvokerAwareTrait;
  15. use BestIt\CommercetoolsODM\Mapping\ClassMetadataInterface;
  16. use BestIt\CommercetoolsODM\Repository\ObjectRepository;
  17. use BestIt\CommercetoolsODM\UnitOfWork\ChangeManager;
  18. use BestIt\CommercetoolsODM\UnitOfWork\ChangeManagerInterface;
  19. use BestIt\CommercetoolsODM\UnitOfWork\ResponseHandlers\ResponseHandlerComposite;
  20. use BestIt\CommercetoolsODM\UnitOfWork\ResponseHandlers\ResponseHandlerInterface;
  21. use Commercetools\Core\Error\ApiException as CtApiException;
  22. use Commercetools\Core\Model\Cart\CartDraft;
  23. use Commercetools\Core\Model\Common\AbstractJsonDeserializeObject;
  24. use Commercetools\Core\Model\Common\AssetDraft;
  25. use Commercetools\Core\Model\Common\AssetDraftCollection;
  26. use Commercetools\Core\Model\Common\AttributeCollection;
  27. use Commercetools\Core\Model\Common\DateTimeDecorator;
  28. use Commercetools\Core\Model\Common\JsonObject;
  29. use Commercetools\Core\Model\Common\PriceDraft;
  30. use Commercetools\Core\Model\Common\PriceDraftCollection;
  31. use Commercetools\Core\Model\CustomField\CustomFieldObject;
  32. use Commercetools\Core\Model\CustomField\FieldContainer;
  33. use Commercetools\Core\Model\Product\Product;
  34. use Commercetools\Core\Model\Product\ProductDraft;
  35. use Commercetools\Core\Model\Product\ProductVariant;
  36. use Commercetools\Core\Model\Product\ProductVariantDraft;
  37. use Commercetools\Core\Model\Type\TypeReference;
  38. use Commercetools\Core\Request\AbstractDeleteRequest;
  39. use Commercetools\Core\Request\ClientRequestInterface;
  40. use Commercetools\Core\Response\ApiResponseInterface;
  41. use DateTime;
  42. use Doctrine\Common\EventManager;
  43. use Exception;
  44. use InvalidArgumentException;
  45. use Psr\Log\LoggerAwareTrait;
  46. use Psr\Log\LoggerInterface;
  47. use Psr\Log\NullLogger;
  48. use RuntimeException;
  49. use SplObjectStorage;
  50. use Traversable;
  51. use function array_filter;
  52. use function array_keys;
  53. use function array_search;
  54. use function array_walk;
  55. use function count;
  56. use function Funct\Strings\upperCaseFirst;
  57. use function get_class;
  58. use function is_array;
  59. use function is_string;
  60. use function memory_get_usage;
  61. use function method_exists;
  62. use function spl_object_hash;
  63. use function stripos;
  64. use function ucfirst;
  65. use function var_dump;
  67. /**
  68. * The unit of work inspired by the couch db odm structure.
  69. *
  70. * @author blange <lange@bestit-online.de>
  71. * @internal
  72. * @package BestIt\CommercetoolsODM
  73. */
  74. class UnitOfWork implements UnitOfWorkInterface
  75. {
  76. use ActionBuilderProcessorAwareTrait;
  77. use ClientAwareTrait;
  78. use DocumentManagerAwareTrait;
  79. use EventManagerAwareTrait;
  80. use ListenerInvokerAwareTrait;
  81. use LoggerAwareTrait;
  82. use ResolveAttributeValueTrait;
  84. /**
  85. * Handles the change state of given models.
  86. *
  87. * @var ChangeManagerInterface|null
  88. */
  89. private $changeManager;
  91. /**
  92. * Maps containers and keys to ids.
  93. *
  94. * @var array
  95. */
  96. protected $containerKeyMap = [];
  98. /**
  99. * Maps customer ids.
  100. *
  101. * @var array
  102. */
  103. protected $customerIdMap = [];
  105. /**
  106. * Which objects should be detached after flush.
  107. *
  108. * @var SplObjectStorage
  109. */
  110. private $detachQueue = null;
  112. /**
  113. * Matches object ids to commercetools ids.
  114. *
  115. * @var array
  116. */
  117. protected $documentIdentifiers = [];
  119. /**
  120. * The states for given object ids.
  121. *
  122. * @todo Rename var.
  123. * @var array
  124. */
  125. protected $documentState = [];
  127. /**
  128. * The number of the consecutive flushs.
  129. *
  130. * @var int
  131. */
  132. private $flushRuns = 0;
  134. /**
  135. * Maps documents to ids.
  136. *
  137. * @var array
  138. */
  139. protected $identityMap = [];
  141. /**
  142. * Maps keys to ids.
  143. *
  144. * @var array
  145. */
  146. protected $keyMap = [];
  148. /**
  149. * Saving of the callbacks for objects
  150. *
  151. * @var SplObjectStorage
  152. */
  153. private $modifiers;
  155. /**
  156. * Saves the completely new documents.
  157. *
  158. * @var array
  159. */
  160. protected $newDocuments = [];
  162. /**
  163. * Helper to handle responses.
  164. *
  165. * @var ResponseHandlerInterface
  166. */
  167. private $responseHandler;
  169. /**
  170. * How many times should we retry the flush?
  171. *
  172. * @var int
  173. */
  174. private $retryCount = self::RETRY_STATUS_DEFAULT;
  176. /**
  177. * UnitOfWork constructor.
  178. *
  179. * @param ActionBuilderProcessorInterface $actionBuilderProcessor
  180. * @param DocumentManagerInterface $documentManager
  181. * @param EventManager $eventManager
  182. * @param ListenersInvoker $listenersInvoker
  183. */
  184. public function __construct(
  185. ActionBuilderProcessorInterface $actionBuilderProcessor,
  186. DocumentManagerInterface $documentManager,
  187. EventManager $eventManager,
  188. ListenersInvoker $listenersInvoker
  189. ) {
  190. $this
  191. ->setActionBuilderProcessor($actionBuilderProcessor)
  192. ->setClient($documentManager->getClient())
  193. ->setDocumentManager($documentManager)
  194. ->setEventManager($eventManager)
  195. ->setListenerInvoker($listenersInvoker);
  197. $this->detachQueue = new SplObjectStorage();
  198. $this->logger = new NullLogger();
  199. $this->modifiers = new SplObjectStorage();
  200. }
  202. /**
  203. * Adds the inserts to the request batch.
  204. *
  205. * @return $this
  206. */
  207. private function addInsertsToRequestBatch(): self
  208. {
  209. $client = $this->getClient();
  211. $this->logger->debug(
  212. 'Iterates thru the new documents for inserts.',
  213. [
  214. 'newObjectCount' => $this->countNewObjects(),
  215. ]
  216. );
  218. foreach ($this->newDocuments as $id => $object) {
  219. $this->logger->debug(
  220. 'Iterates to an object for an insert.',
  221. ['class' => $object::class]
  222. );
  224. $request = $this->createNewRequest($this->getClassMetadata($object), $object);
  226. // The responses are marked for the given identifier.
  227. $client->addBatchRequest($request->setIdentifier($id));
  228. }
  230. return $this;
  231. }
  233. /**
  234. * Adds a modifier for the given object.
  235. *
  236. * @param callable $change
  237. * @return void
  238. */
  239. private function addModifier(mixed $object, callable $change)
  240. {
  241. if (!$this->modifiers->contains($object)) {
  242. $this->modifiers->attach($object, []);
  243. }
  245. $callbacks = $this->modifiers[$object];
  246. $callbacks[] = $change;
  248. $this->modifiers[$object] = $callbacks;
  249. }
  251. /**
  252. * Adds the removal requests to the request batch.
  253. *
  254. * @todo Check for needed usage of version.
  255. *
  256. * @return UnitOfWork
  257. */
  258. private function addRemovalsToRequestBatch(): self
  259. {
  260. $client = $this->getClient();
  262. $this->logger->debug(
  263. 'Iterates thru the identity map for removals.',
  264. [
  265. 'allIds' => array_keys($this->identityMap),
  266. ]
  267. );
  269. foreach ($this->identityMap as $id => $model) {
  270. $isRemoved = $this->isObjectRemoved($model);
  272. $this->logger->debug(
  273. 'Iterates to an object for a possible remove.',
  274. [
  275. 'class' => $model::class,
  276. 'id' => $id,
  277. 'isRemoved' => $isRemoved,
  278. ]
  279. );
  281. if ($isRemoved) {
  282. $request = $this->createRemovalRequest($model);
  284. // The responses are marked for the given identifier.
  285. $client->addBatchRequest($request->setIdentifier($id));
  286. }
  287. }
  289. return $this;
  290. }
  292. /**
  293. * Iterates through the entities and creates their update / creation actions if needed.
  294. *
  295. * @return void
  296. */
  297. private function addRequestsToBatch()
  298. {
  299. $this
  300. ->addUpdatesToRequestBatch()
  301. ->addInsertsToRequestBatch()
  302. ->addRemovalsToRequestBatch();
  303. }
  305. /**
  306. * Adds the updates to the request batch.
  307. *
  308. * @return $this
  309. */
  310. private function addUpdatesToRequestBatch(): self
  311. {
  312. $client = $this->getClient();
  314. $this->logger->debug(
  315. 'Iterates thru the identity map for updates.',
  316. [
  317. 'allIds' => array_keys($this->identityMap),
  318. ]
  319. );
  321. foreach ($this->identityMap as $id => $object) {
  322. $isManaged = $this->isObjectManaged($object);
  324. $this->logger->debug(
  325. 'Iterates to an object for a possible update.',
  326. [
  327. 'class' => $object::class,
  328. 'id' => $id,
  329. 'isManaged' => $isManaged,
  330. ]
  331. );
  333. if ($isManaged) {
  334. $this->invokeLifecycleEvents($object, Events::PRE_PERSIST);
  336. $isChanged = $this->getChangeManager()->isChanged($object);
  338. if ($isChanged) {
  339. $this->logger->debug(
  340. 'Adds the possible update of the object to the batch or detaches it if required.',
  341. [
  342. 'class' => $object::class,
  343. 'id' => $id,
  344. 'isChanged' => $isChanged,
  345. 'isManaged' => $isManaged,
  346. ]
  347. );
  349. // The responses are marked for the given identifier.
  350. $updateRequest = $this->computeChangedObject($object);
  352. if ($updateRequest instanceof ClientRequestInterface) {
  353. $client->addBatchRequest($updateRequest->setIdentifier($id));
  354. } else {
  355. $this->invokeLifecycleEvents($object, Events::POST_PERSIST);
  356. }
  357. } else {
  358. $this->invokeLifecycleEvents($object, Events::POST_PERSIST);
  360. //We can remove it now, if there are no changed but a deferred detach.
  361. $this->processDeferredDetach($object);
  362. }
  363. }
  364. }
  366. return $this;
  367. }
  369. /**
  370. * Is a flush retry allowed?
  371. *
  372. * @param bool $increase Should the retry count be increased after the check?
  373. *
  374. * @return bool
  375. */
  376. #[\Override]
  377. public function canRetry(bool $increase = false): bool
  378. {
  379. $canRetry = ($this->retryCount < 0) || ($this->retryCount && $this->flushRuns < $this->retryCount);
  381. if ($increase) {
  382. ++$this->flushRuns;
  383. }
  385. return $canRetry;
  386. }
  388. /**
  389. * Cascades a detach operation to associated documents.
  390. *
  391. * @param array $visited
  392. * @return void
  393. */
  394. private function cascadeDetach(mixed $document, array &$visited)
  395. {
  396. }
  398. /**
  399. * Cascades the save into the documents childs.
  400. *
  401. * @param ClassMetadataInterface $class
  402. * @param array $visited
  403. * @return UnitOfWork
  404. */
  405. private function cascadeScheduleInsert(ClassMetadataInterface $class, mixed $document, array &$visited): self
  406. {
  407. // TODO
  409. return $this;
  410. }
  412. /**
  413. * Creates the update action for the given object if there is a change in the data.
  414. *
  415. * @todo Topmost array should be used as a whole.
  416. * @return ClientRequestInterface|null
  417. */
  418. private function computeChangedObject(mixed $object)
  419. {
  420. return $this->createUpdateRequest(
  421. $this->getChangeManager()->getChanges($object),
  422. $this->getChangeManager()->getOriginalStatus($object),
  423. $object
  424. );
  425. }
  427. /**
  428. * Returns true if the unit of work contains the given document.
  429. *
  430. * @param mixed $document
  431. *
  432. * @return bool
  433. */
  434. #[\Override]
  435. public function contains($document): bool
  436. {
  437. $objectKey = $this->getKeyForObject($document);
  439. return isset($this->documentIdentifiers[$objectKey]) || isset($this->newDocuments[$objectKey]);
  440. }
  442. /**
  443. * Returns the count of managed entities.
  444. *
  445. * @return int
  446. */
  447. #[\Override]
  448. public function count(): int
  449. {
  450. return count($this->identityMap) + $this->countNewObjects();
  451. }
  453. /**
  454. * Returns the count of managed objects.
  455. *
  456. * @return int
  457. */
  458. #[\Override]
  459. public function countManagedObjects(): int
  460. {
  461. return count(array_filter($this->identityMap, [$this, 'isObjectManaged']));
  462. }
  464. /**
  465. * Returns the count for new objects.
  466. *
  467. * @return int
  468. */
  469. #[\Override]
  470. public function countNewObjects(): int
  471. {
  472. return count($this->newDocuments);
  473. }
  475. /**
  476. * Returns the count of scheduled removals.
  477. *
  478. * @return int
  479. */
  480. #[\Override]
  481. public function countRemovals(): int
  482. {
  483. return count(array_filter($this->identityMap, [$this, 'isObjectRemoved']));
  484. }
  486. /**
  487. * Creates and executes the request batch after checking every relevant object in the uow.
  488. *
  489. * @throws APIException
  490. * @throws ConnectException
  491. *
  492. * @return void
  493. */
  494. private function createAndExecuteBatch()
  495. {
  496. $this->addRequestsToBatch();
  498. try {
  499. if ($batchResponses = $this->getClient()->executeBatch()) {
  500. $this->processResponsesFromBatch($batchResponses);
  501. }
  502. } catch (CtApiException $exception) {
  503. if (stripos($exception->getMessage(), 'Error completing request') !== false) {
  504. throw new ConnectException($exception->getMessage(), $exception->getCode(), $exception);
  505. }
  506. }
  507. }
  509. /**
  510. * Creates a document and registers it as managed.
  511. *
  512. * @param string $className
  513. * @param mixed $responseObject The mapped Response from commercetools.
  514. * @param array $hints
  515. * @param bool $withRegistration Should we register the object in the unit of work.
  516. *
  517. * @return mixed The document matching to $className.
  518. */
  519. #[\Override]
  520. public function createDocument(
  521. string $className,
  522. $responseObject,
  523. array $hints = [],
  524. bool $withRegistration = true
  525. ) {
  526. unset($hints);
  528. /** @var ClassMetadataInterface $metadata */
  529. $document = null;
  530. $id = null;
  531. $metadata = $this->getClassMetadata($className);
  532. $version = null;
  534. if ($responseObject instanceof $className) {
  535. $targetDocument = clone $responseObject;
  536. $id = $responseObject->getId();
  537. $version = $responseObject->getVersion();
  538. } else {
  539. /** @var CustomFieldObject $customObject */
  540. $targetDocument = $metadata->getNewInstance();
  541. $customObject = $metadata->getCustomTypeFields() ? $responseObject->getCustom() : new CustomFieldObject();
  543. if ($metadata->getIdentifier()) {
  544. $id = $responseObject->getId();
  545. }
  547. if ($metadata->getVersion()) {
  548. $version = $responseObject->getVersion();
  549. }
  551. // TODO Make it more nice.
  552. foreach ($metadata->getFieldNames() as $fieldName) {
  553. if ($metadata->isCustomTypeField($fieldName)) {
  554. $foundValue = $customObject->getFields()->get($fieldName);
  555. } else {
  556. $foundValue = method_exists($responseObject, $getter = 'get' . ucfirst($fieldName))
  557. ? $responseObject->$getter()
  558. : $responseObject->$fieldName;
  559. }
  561. if (!empty($foundValue) || !$metadata->ignoreFieldOnEmpty($fieldName)) {
  562. $parsedValue = $this->parseFoundFieldValue($fieldName, $metadata, $foundValue);
  564. $targetDocument->{'set' . ucfirst($fieldName)}($parsedValue);
  565. }
  566. }
  567. }
  569. // TODO Find in new objects.
  570. $this->invokeLifecycleEvents($targetDocument, Events::POST_LOAD, $metadata);
  572. if (@$id && $withRegistration) {
  573. $this->registerAsManaged($targetDocument, $id, @$version);
  574. }
  576. return $targetDocument;
  577. }
  579. /**
  580. * Creates the draft for a new request.
  581. *
  582. * @todo Move to factory.
  583. *
  584. * @param ClassMetadataInterface $metadata
  585. * @param mixed $object The source object.
  586. * @param array $fields
  587. *
  588. * @return JsonObject
  589. */
  590. private function createDraftObjectForNewRequest(
  591. ClassMetadataInterface $metadata,
  592. mixed $object,
  593. array $fields
  594. ): JsonObject {
  595. $draftClass = $metadata->getDraft();
  597. if ($draftClass === ProductDraft::class) {
  598. $values = $this->parseValuesForProductDraft($object);
  599. } elseif ($draftClass === CartDraft::class) {
  600. $values = $this->parseValuesForCartDraft($metadata, $object, $fields);
  601. } else {
  602. $values = $this->parseValuesForSimpleDraft($metadata, $object, $fields);
  603. }
  605. return new $draftClass($values);
  606. }
  608. /**
  609. * Returns the create query for the given document.
  610. *
  611. * @param ClassMetadataInterface $metadata
  612. *
  613. * @return ClientRequestInterface
  614. */
  615. private function createNewRequest(ClassMetadataInterface $metadata, mixed $object): ClientRequestInterface
  616. {
  617. $fields = array_filter($metadata->getFieldNames(), fn(string $field) => !$metadata->isVersion($field) && !$metadata->isIdentifier($field) &&
  618. !$metadata->isFieldReadOnly($field));
  620. if ($metadata->isCTStandardModel()) {
  621. unset(
  622. $fields[array_search('createdAt', $fields)],
  623. $fields[array_search('id', $fields)],
  624. $fields[array_search('lastModifiedAt', $fields)],
  625. $fields[array_search('version', $fields)]
  626. );
  627. }
  629. $draftObject = $this->createDraftObjectForNewRequest($metadata, $object, $fields);
  631. return $this->getDocumentManager()->createRequest(
  632. $metadata->getName(),
  633. DocumentManager::REQUEST_TYPE_CREATE,
  634. $draftObject
  635. );
  636. }
  638. /**
  639. * Creates the removal request for the given model.
  640. *
  641. *
  642. * @return AbstractDeleteRequest
  643. */
  644. private function createRemovalRequest(mixed $model): AbstractDeleteRequest
  645. {
  646. return $this->getDocumentManager()->createRequest(
  647. $this->getClassMetadata($model)->getName(),
  648. DocumentManager::REQUEST_TYPE_DELETE_BY_ID,
  649. $model->getId(),
  650. $model->getVersion()
  651. );
  652. }
  654. /**
  655. * Creates the update request for the given changed data.
  656. *
  657. * @param array $changedData
  658. * @param array $oldData
  659. * @param ClassMetadataInterface|null $metadata
  660. * @return ClientRequestInterface|null
  661. */
  662. private function createUpdateRequest(
  663. array $changedData,
  664. array $oldData,
  665. mixed $document,
  666. ClassMetadataInterface $metadata = null
  667. ) {
  668. $documentClass = $document::class;
  670. if (!$metadata) {
  671. /** @var ClassMetadataInterface $metadata */
  672. $metadata = $this->getClassMetadata($document);
  673. }
  675. $actions = $this->getActionBuilderProcessor()->createUpdateActions(
  676. $metadata,
  677. $changedData,
  678. $oldData,
  679. $document
  680. );
  682. // There are possible differences between the raw view on changes and the real usable changes. If there are no
  683. // real usable changes then skip the request creation!
  684. if (!$actions) {
  685. $this->logger->debug(
  686. 'Skips the creation of the update request because there are no actions.',
  687. [
  688. 'actions' => $actions,
  689. 'class' => $document::class,
  690. 'memory' => memory_get_usage(true) / 1024 / 1024,
  691. 'objectId' => $document->getId(),
  692. 'objectKey' => $this->getKeyForObject($document),
  693. 'objectVersion' => $document->getVersion(),
  694. ]
  695. );
  697. return null;
  698. }
  700. $requestClass = $this->getDocumentManager()->getRequestClass(
  701. $documentClass,
  702. DocumentManager::REQUEST_TYPE_UPDATE_BY_ID
  703. );
  705. if (method_exists($requestClass, 'ofObject')) {
  706. $request = $requestClass::ofObject($document);
  707. } else {
  708. $request = $this->getDocumentManager()->createRequest(
  709. $documentClass,
  710. DocumentManager::REQUEST_TYPE_UPDATE_BY_ID,
  711. $document->getId(),
  712. $document->getVersion()
  713. );
  715. /** @var ObjectRepository $repository */
  716. $repository = $this->getDocumentManager()->getRepository($documentClass);
  718. // TODO Try to refactor to an explicit api, even if the doctrine base api does not support it.
  719. if (($repository instanceof ObjectRepository) && ($expands = $repository->getExpands())) {
  720. array_walk($expands, [$request, 'expand']);
  721. }
  723. $this->logger->debug(
  724. 'Created the update request.',
  725. [
  726. 'actions' => $actions,
  727. 'class' => $document::class,
  728. 'memory' => memory_get_usage(true) / 1024 / 1024,
  729. 'objectId' => $document->getId(),
  730. 'objectKey' => $this->getKeyForObject($document),
  731. 'objectVersion' => $document->getVersion(),
  732. 'request' => $request::class,
  733. ]
  734. );
  736. $request->setActions($actions);
  737. }
  739. return $request;
  740. }
  742. /**
  743. * Detaches a document from the persistence management.
  744. * It's persistence will no longer be managed by Doctrine.
  745. *
  746. * @param mixed $object The document to detach.
  747. *
  748. * @return void
  749. */
  750. #[\Override]
  751. public function detach($object)
  752. {
  753. $visited = [];
  754. $this->doDetach($object, $visited);
  755. }
  757. /**
  758. * Detaches the given object after flush.
  759. *
  760. * @param mixed $object
  761. *
  762. * @return void
  763. */
  764. #[\Override]
  765. public function detachDeferred($object)
  766. {
  767. $this->detachQueue->attach($object);
  768. }
  770. /**
  771. * Executes a detach operation on the given entity.
  772. *
  773. * @param array $visited
  774. * @return void
  775. */
  776. private function doDetach(mixed $model, array &$visited)
  777. {
  778. $oid = $this->getKeyForObject($model);
  780. if (!isset($visited[$oid])) {
  781. $this->logger->info(
  782. 'Model was detached from unit of work.',
  783. [
  784. 'class' => $model::class,
  785. 'id' => $model->getId(),
  786. ]
  787. );
  789. $visited[$oid] = $model; // mark visited
  790. $this->detachQueue->detach($model);
  791. $this->modifiers->detach($model); // TODO Check
  793. $this->removeFromIdentityMap($model);
  794. $this->cascadeDetach($model, $visited);
  796. $this->getChangeManager()->detach($model);
  797. unset($this->newDocuments[$oid]);
  799. $this->invokeLifecycleEvents($model, Events::POST_DETACH);
  800. }
  801. }
  803. /**
  804. * Schedules the removal of the given object.
  805. *
  806. * @param array $visited
  807. * @return void
  808. */
  809. private function doScheduleRemove(mixed $object, array &$visited)
  810. {
  811. $oid = $this->getKeyForObject($object);
  813. if (!isset($visited[$oid])) {
  814. $this->registerAsRemoved($object);
  815. $this->invokeLifecycleEvents($object, Events::PRE_REMOVE);
  816. }
  817. }
  819. /**
  820. * Queues the entity for saving or throws an exception if there is something wrong.
  821. *
  822. * @param array $visited
  823. * @return void
  824. */
  825. private function doScheduleSave(mixed $entity, array &$visited)
  826. {
  827. $oid = $this->getKeyForObject($entity);
  829. if (!isset($visited[$oid])) {
  830. $visited[$oid] = true;
  832. $class = $this->getClassMetadata($entity);
  833. $state = $this->getDocumentState($entity);
  835. switch ($state) {
  836. case self::STATE_NEW:
  837. $this->persistNew($entity);
  838. break;
  839. case self::STATE_MANAGED:
  840. // TODO: Change Tracking Deferred Explicit
  841. break;
  842. case self::STATE_REMOVED:
  843. // document becomes managed again
  844. $this->documentState[$oid] = self::STATE_MANAGED;
  845. break;
  846. case self::STATE_DETACHED:
  847. throw new InvalidArgumentException('Detached document passed to persist().');
  848. break;
  849. }
  851. $this->cascadeScheduleInsert($class, $entity, $visited);
  852. }
  853. }
  855. /**
  856. * Commits every change to commercetools.
  857. *
  858. * @todo Add the detach queue for ignored objects
  859. *
  860. * @return void
  861. */
  862. #[\Override]
  863. public function flush()
  864. {
  865. $this->getEventManager()->dispatchEvent(Events::ON_FLUSH, new OnFlushEventArgs($this));
  867. while ($this->needsToFlush() && ($this->canRetry(true))) {
  868. $this->logger->debug(
  869. 'Flushes the batch.',
  870. [
  871. 'memory' => memory_get_usage(true) / 1024 / 1024,
  872. 'retryCount' => $this->retryCount,
  873. 'run' => $this->flushRuns,
  874. ]
  875. );
  877. $this->createAndExecuteBatch();
  879. $this->logger->info(
  880. 'Flushed the batch.',
  881. [
  882. 'memory' => memory_get_usage(true) / 1024 / 1024,
  883. 'retryCount' => $this->retryCount,
  884. 'run' => $this->flushRuns,
  885. ]
  886. );
  887. }
  889. $this->flushRuns = 0;
  890. }
  892. /**
  893. * Returns the change manager.
  894. *
  895. * @return ChangeManagerInterface
  896. */
  897. private function getChangeManager(): ChangeManagerInterface
  898. {
  899. if (!$this->changeManager) {
  900. $this->changeManager = $this->loadChangeManager();
  901. }
  903. return $this->changeManager;
  904. }
  906. /**
  907. * Returns the metadata for the given class.
  908. *
  909. * @param string|object $class
  910. *
  911. * @return ClassMetadataInterface
  912. */
  913. protected function getClassMetadata($class): ClassMetadataInterface
  914. {
  915. return $this->getDocumentManager()->getClassMetadata(is_string($class) ? $class : $class::class);
  916. }
  918. /**
  919. * Get the state of a document.
  920. *
  921. * @todo Split for Key and ID. Catch the exception of the commercetools process?
  922. * @return int
  923. */
  924. protected function getDocumentState(mixed $document): int
  925. {
  926. /** @var ClassMetadataInterface $class */
  927. $class = $this->getClassMetadata($className = $document::class);
  928. $isStandard = $document instanceof JsonObject;
  929. $oid = $this->getKeyForObject($document);
  930. $state = $this->documentState[$oid] ?? null;
  931. $id = $isStandard ? $document->getId() : $document->{'get' . ucfirst($class->getIdentifier())}();
  933. // Check with the id.
  934. if (!$state && $id) {
  935. if ($this->tryGetById($id)) {
  936. $state = self::STATE_DETACHED;
  937. } else {
  938. $request = $this->getDocumentManager()->createRequest(
  939. $className,
  940. DocumentManager::REQUEST_TYPE_FIND_BY_ID,
  941. $id
  942. );
  944. $response = $this->getDocumentManager()->getClient()->execute($request);
  945. $state = $response->getStatusCode() === 404 ? self::STATE_NEW : self::STATE_DETACHED;
  946. }
  947. }
  949. // Check with the key.
  950. if (!$state && ($keyName = $class->getKey()) && ($keyValue = $document->{'get' . ucfirst($keyName)}())) {
  951. $request = $this->getDocumentManager()->createRequest(
  952. $className,
  953. DocumentManager::REQUEST_TYPE_FIND_BY_KEY,
  954. $keyValue
  955. );
  957. $response = $this->getDocumentManager()->getClient()->execute($request);
  958. $state = $response->getStatusCode() === 404 ? self::STATE_NEW : self::STATE_DETACHED;
  959. }
  961. return $state ?? self::STATE_NEW;
  962. }
  964. /**
  965. * Returns a key for the given object.
  966. *
  967. *
  968. * @return string
  969. */
  970. private function getKeyForObject(mixed $object): string
  971. {
  972. return spl_object_hash($object);
  973. }
  975. /**
  976. * Returns the used response handler.
  977. *
  978. * @return ResponseHandlerInterface
  979. */
  980. private function getResponseHandler(): ResponseHandlerInterface
  981. {
  982. if (!$this->responseHandler) {
  983. $this->setResponseHandler($this->loadResponseHandler());
  984. }
  986. return $this->responseHandler;
  987. }
  989. /**
  990. * Are there any modify callbacks for the given object?
  991. *
  992. * @param mixed $object
  993. *
  994. * @return bool
  995. */
  996. #[\Override]
  997. public function hasModifyCallbacks($object): bool
  998. {
  999. return $this->modifiers->contains($object);
  1000. }
  1002. /**
  1003. * Invokes the lifecycle events for the given model.
  1004. *
  1005. * @param mixed $model
  1006. * @param string $eventName
  1007. * @param ClassMetadataInterface|null $metadata
  1008. *
  1009. * @return void
  1010. */
  1011. #[\Override]
  1012. public function invokeLifecycleEvents($model, string $eventName, ClassMetadataInterface $metadata = null)
  1013. {
  1014. $this->getListenerInvoker()->invoke(
  1015. new LifecycleEventArgs($model, $this->getDocumentManager()),
  1016. $eventName,
  1017. $model,
  1018. $metadata ?: $this->getClassMetadata($model)
  1019. );
  1020. }
  1022. /**
  1023. * Returns true if the given object is managed by this class.
  1024. *
  1025. *
  1026. * @return bool
  1027. */
  1028. private function isObjectManaged(mixed $object): bool
  1029. {
  1030. return $this->getDocumentState($object) === self::STATE_MANAGED;
  1031. }
  1033. /**
  1034. * Returns true if the given object is managed by this class but marked as removed.
  1035. *
  1036. *
  1037. * @return bool
  1038. */
  1039. private function isObjectRemoved(mixed $object): bool
  1040. {
  1041. return $this->getDocumentState($object) === self::STATE_REMOVED;
  1042. }
  1044. /**
  1045. * Loads a fresh change manager.
  1046. *
  1047. * @todo Refactor.
  1048. *
  1049. * @return ChangeManagerInterface
  1050. */
  1051. private function loadChangeManager(): ChangeManagerInterface
  1052. {
  1053. $changeManager = new ChangeManager($this->getDocumentManager());
  1055. $changeManager->setLogger($this->logger);
  1057. return $changeManager;
  1058. }
  1060. /**
  1061. * Returns a fresh response handler instance.
  1062. *
  1063. * @return ResponseHandlerInterface
  1064. */
  1065. protected function loadResponseHandler(): ResponseHandlerInterface
  1066. {
  1067. $handler = new ResponseHandlerComposite($this->getDocumentManager());
  1069. $handler->setLogger($this->logger);
  1071. return $handler;
  1072. }
  1074. /**
  1075. * This method uses a callback to modify the given object to get conflict resolution in case of a 409 error.
  1076. *
  1077. * @param mixed $object
  1078. * @param callable $change The callback is called with the given object.
  1079. *
  1080. * @return mixed Returns the changed object.
  1081. */
  1082. #[\Override]
  1083. public function modify($object, callable $change)
  1084. {
  1085. $change($object);
  1087. $this->addModifier($object, $change);
  1089. return $object;
  1090. }
  1092. /**
  1093. * Are there any objects which need to be flushed to the database.
  1094. *
  1095. * @todo CheckCleanQueue
  1096. *
  1097. * @return bool
  1098. */
  1099. private function needsToFlush()
  1100. {
  1101. if ($this->newDocuments || count($this->detachQueue)) {
  1102. return true;
  1103. }
  1105. foreach ($this->identityMap as $id => $object) {
  1106. if ($this->isObjectManaged($object) && $this->changeManager->isChanged($object)) {
  1107. return true;
  1108. }
  1110. if ($this->isObjectRemoved($object)) {
  1111. return true;
  1112. }
  1113. }
  1115. return false;
  1116. }
  1118. /**
  1119. * Parses the found value with the data from the field declaration.
  1120. *
  1121. * @param string $field
  1122. * @param ClassMetadataInterface $metadata
  1123. *
  1124. * @return bool|DateTime|int|string
  1125. */
  1126. private function parseFoundFieldValue(string $field, ClassMetadataInterface $metadata, mixed $value)
  1127. {
  1128. switch ($metadata->getTypeOfField($field)) {
  1129. case 'array':
  1130. case 'set':
  1131. // Force parse to array.
  1132. if (!$value) {
  1133. $value = [];
  1134. }
  1136. if (!is_array($returnValue = $value)) {
  1137. $returnValue = $value instanceof Traversable ? iterator_to_array($value) : (array) $value;
  1138. }
  1140. // clean up.
  1141. array_walk($returnValue, function ($value) {
  1142. if ($value instanceof AbstractJsonDeserializeObject) {
  1143. $value->parentSet(null)->rootSet(null);
  1144. }
  1145. });
  1147. break;
  1149. case 'boolean':
  1150. $returnValue = (bool) $value;
  1151. break;
  1153. case 'dateTime':
  1154. $returnValue = (new DateTimeDecorator($value))->getDateTime();
  1155. break;
  1157. case 'int':
  1158. $returnValue = (int) $value;
  1159. break;
  1161. case 'string':
  1162. $returnValue = (string) $value;
  1163. break;
  1165. default:
  1166. $returnValue = $value;
  1167. }
  1169. return $returnValue;
  1170. }
  1172. /**
  1173. * Parses the data of the given object to create a cart draft
  1174. *
  1175. * @param ClassMetadataInterface $metadata
  1176. * @param mixed $object The source object.
  1177. * @param array $fields
  1178. *
  1179. * @return array
  1180. */
  1181. private function parseValuesForCartDraft(ClassMetadataInterface $metadata, mixed $object, array $fields): array
  1182. {
  1183. $values = $this->parseValuesForSimpleDraft($metadata, $object, $fields);
  1184. $objectArray = $object->toArray();
  1186. $values['currency'] = $objectArray['currency'];
  1188. if (isset($objectArray['shippingInfo']['shippingMethod'])) {
  1189. $values['shippingMethod'] = $objectArray['shippingInfo']['shippingMethod'];
  1190. }
  1192. return $values;
  1193. }
  1195. /**
  1196. * Parses the data of the given object to create a value array for the draft of the object.
  1197. *
  1198. * @todo To hard coupled with the standard object.
  1199. * @todo Not completely tested.
  1200. *
  1201. * @param Product $product The source object.
  1202. *
  1203. * @return array
  1204. */
  1205. private function parseValuesForProductDraft(Product $product): array
  1206. {
  1207. $values = [
  1208. 'key' => (string) $product->getKey(),
  1209. 'productType' => $product->getProductType(),
  1210. 'state' => $product->getState(),
  1211. 'taxCategory' => $product->getTaxCategory(),
  1212. 'variants' => null,
  1213. ];
  1215. if ($productData = $product->getMasterData()) {
  1216. $values += [
  1217. 'publish' => (bool) $productData->getPublished(),
  1218. ];
  1220. $projection = $productData->getStaged();
  1221. $valueNames = [
  1222. 'categoryOrderHints',
  1223. 'categories',
  1224. 'description',
  1225. 'name',
  1226. 'metaKeywords',
  1227. 'metaDescription',
  1228. 'metaTitle',
  1229. 'slug',
  1230. ];
  1232. $searchKeywords = $projection->getSearchKeywords();
  1233. if ($searchKeywords && count($searchKeywords)) {
  1234. $valueNames[] = 'searchKeywords';
  1235. }
  1237. foreach ($valueNames as $name) {
  1238. $values[$name] = @$projection->get($name);
  1239. }
  1241. // getAllVariants() did not work as expected and Collection::toArray() changes to mush.
  1242. $variants = [$projection->getMasterVariant()];
  1243. foreach ($projection->getVariants() ?? [] as $variant) {
  1244. $variants[] = $variant;
  1245. }
  1247. /** @var ProductVariant $variant */
  1248. foreach ($variants as $index => $variant) {
  1249. $attributes = [];
  1251. if ($variant->getAttributes() instanceof AttributeCollection) {
  1252. $attributes = array_map(function (array $attribute) {
  1253. $attribute['value'] = $this->resolveAttributeValue($attribute['value']);
  1255. return $attribute;
  1256. }, $variant->getAttributes()->toArray());
  1257. }
  1259. $variantDraft = ProductVariantDraft::fromArray(
  1260. array_filter(
  1261. [
  1262. 'attributes' => $attributes,
  1263. 'images' => $variant->getImages(),
  1264. 'key' => $variant->getKey(),
  1265. 'sku' => (string) $variant->getSku(),
  1266. ]
  1267. )
  1268. );
  1270. if (($prices = $variant->getPrices()) && (count($prices))) {
  1271. $variantDraft->setPrices(new PriceDraftCollection());
  1273. foreach ($prices as $price) {
  1274. $variantDraft->getPrices()->add(PriceDraft::fromArray($price->toArray()));
  1275. }
  1276. }
  1278. if (($assets = $variant->getAssets()) && (count($assets))) {
  1279. $variantDraft->setAssets(new AssetDraftCollection());
  1281. foreach ($assets as $asset) {
  1282. $variantDraft->getAssets()->add(AssetDraft::fromArray($asset->toArray()));
  1283. }
  1284. }
  1286. if (!$index) {
  1287. $values['masterVariant'] = $variantDraft;
  1288. } else {
  1289. $values['variants'][] = $variantDraft;
  1290. }
  1291. }
  1292. }
  1294. if (!@$values['searchKeywords']) {
  1295. unset($values['searchKeywords']);
  1296. }
  1298. array_walk($values, function (&$value, $key) {
  1299. if ((is_object($value)) && (method_exists($value, 'toArray'))) {
  1300. $value = $value->toArray();
  1301. }
  1302. });
  1304. return array_filter($values);
  1305. }
  1307. /**
  1308. * Parses the data of the given object to create a value array for the draft of the object.
  1309. *
  1310. * @param ClassMetadataInterface $metadata
  1311. * @param mixed $object The source object.
  1312. * @param array $fields
  1313. *
  1314. * @return array
  1315. */
  1316. private function parseValuesForSimpleDraft(ClassMetadataInterface $metadata, mixed $object, array $fields): array
  1317. {
  1318. $customValues = [];
  1319. $values = [];
  1321. foreach ($fields as $field) {
  1322. $usedValue = $object->{'get' . ucfirst((string) $field)}();
  1324. if ($metadata->isCustomTypeField($field)) {
  1325. if (!@$values['custom']) {
  1326. $values['custom'] = (new CustomFieldObject())
  1327. ->setType(TypeReference::ofKey($metadata->getCustomType($field)));
  1328. }
  1330. $customValues[$field] = $usedValue;
  1331. } else {
  1332. $values[$field] = $usedValue;
  1333. }
  1334. }
  1336. if ($customValues) {
  1337. $values['custom']->setFields(FieldContainer::fromArray($customValues));
  1338. }
  1340. return $values;
  1341. }
  1343. /**
  1344. * Persist new document, marking it managed and generating the id.
  1345. *
  1346. * This method is either called through `DocumentManager#persist()` or during `DocumentManager#flush()`,
  1347. * when persistence by reachability is applied.
  1348. *
  1349. *
  1350. * @return UnitOfWork
  1351. */
  1352. protected function persistNew(mixed $document): UnitOfWork
  1353. {
  1354. $this->invokeLifecycleEvents($document, Events::PRE_PERSIST);
  1356. $this->registerAsManaged($document);
  1358. return $this;
  1359. }
  1361. /**
  1362. * Processed the deferred detach for the given object.
  1363. *
  1364. * @param mixed $model
  1365. *
  1366. * @return void
  1367. */
  1368. #[\Override]
  1369. public function processDeferredDetach($model)
  1370. {
  1371. $needsToDetach = $this->detachQueue->contains($model);
  1373. $this->logger->debug(
  1374. 'Processes the detach queue for the given model.',
  1375. [
  1376. 'class' => $model::class,
  1377. 'id' => $model->getId(),
  1378. 'needsDetach' => $needsToDetach,
  1379. ]
  1380. );
  1382. if ($needsToDetach) {
  1383. $this->detach($model);
  1384. }
  1385. }
  1387. /**
  1388. * Processes the responses from the batch.
  1389. *
  1390. * @param ApiResponseInterface[] $batchResponses
  1391. * @throws APIException
  1392. *
  1393. * @return void
  1394. */
  1395. private function processResponsesFromBatch(array $batchResponses)
  1396. {
  1397. $responseHandler = $this->getResponseHandler();
  1399. $this->logger->debug(
  1400. 'Handling batch responses.',
  1401. [
  1402. 'memory' => memory_get_usage(true) / 1024 / 1024,
  1403. 'responseCount' => count($batchResponses),
  1404. ]
  1405. );
  1407. /** @var ApiResponseInterface $response */
  1408. foreach ($batchResponses as $key => $response) {
  1409. $this->logger->debug(
  1410. 'Got a batch response.',
  1411. [
  1412. 'memory' => memory_get_usage(true) / 1024 / 1024,
  1413. 'objectId' => $key,
  1414. 'response' => $response->getResponse(),
  1415. 'request' => $response->getRequest(),
  1416. ]
  1417. );
  1419. try {
  1420. $responseHandler->handleResponse($response);
  1421. } catch (Exception $exception) {
  1422. // Just debug level. You can make it to an error on higher layers.
  1423. $this->logger->debug(
  1424. 'Received an error and throws it as an exception.',
  1425. [
  1426. 'exception' => $exception,
  1427. 'memory' => memory_get_usage(true) / 1024 / 1024,
  1428. ]
  1429. );
  1431. throw $exception;
  1432. }
  1433. }
  1434. }
  1436. /**
  1437. * Refreshes the persistent state of an object from the database,
  1438. * overriding any local changes that have not yet been persisted.
  1439. *
  1440. * @param mixed $object The object to refresh.
  1441. * @param mixed $overwrite Commercetools returns a representation of the object for many update actions, so use
  1442. * this responds directly.
  1443. * @return void
  1444. */
  1445. #[\Override]
  1446. public function refresh($object, $overwrite = null)
  1447. {
  1448. $metadata = $this->getClassMetadata($object);
  1450. if (!$overwrite) {
  1451. throw new RuntimeException('Not yet implemented');
  1452. }
  1454. foreach ($metadata->getFieldNames() as $fieldName) {
  1455. $value = $overwrite->{'get' . upperCaseFirst($fieldName)}();
  1457. if ($value instanceof DateTimeDecorator) {
  1458. $value = $value->getDateTime();
  1459. }
  1461. if ($value !== null) {
  1462. $object->{'set' . upperCaseFirst($fieldName)}($value);
  1463. }
  1464. }
  1465. }
  1467. /**
  1468. * Registers the given document as managed.
  1469. *
  1470. * @param mixed $document
  1471. * @param string|int $identifier
  1472. * @param mixed|null $revision
  1473. *
  1474. * @return UnitOfWorkInterface
  1475. */
  1476. #[\Override]
  1477. public function registerAsManaged($document, string $identifier = '', $revision = null): UnitOfWorkInterface
  1478. {
  1479. $oid = $this->getKeyForObject($document);
  1481. $this->documentState[$oid] = self::STATE_MANAGED;
  1483. if ($identifier) {
  1484. $oldIdentifier = @$this->documentIdentifiers[$oid];
  1486. if ($oldIdentifier !== $identifier) {
  1487. unset($this->identityMap[$oldIdentifier]);
  1488. }
  1490. $this->documentIdentifiers[$oid] = (string) $identifier;
  1491. $this->identityMap[$identifier] = $document;
  1492. $this->getChangeManager()->registerStatus($document);
  1494. unset($this->newDocuments[$oid]);
  1495. } else {
  1496. $this->newDocuments[$oid] = $document;
  1497. }
  1499. $this->invokeLifecycleEvents($document, Events::POST_REGISTER);
  1501. return $this;
  1502. }
  1504. /**
  1505. * Registers the given document as removed.
  1506. *
  1507. * @todo Handle id and version even for custom objects.
  1508. * @return UnitOfWorkInterface
  1509. */
  1510. public function registerAsRemoved(mixed $document): UnitOfWorkInterface
  1511. {
  1512. $identifier = $document->getId();
  1513. $oid = $this->getKeyForObject($document);
  1515. $this->documentState[$oid] = self::STATE_REMOVED;
  1516. $this->documentIdentifiers[$oid] = (string) $identifier;
  1517. $this->identityMap[$identifier] = $document;
  1519. return $this;
  1520. }
  1522. /**
  1523. * INTERNAL:
  1524. * Removes an document from the identity map. This effectively detaches the
  1525. * document from the persistence management of Doctrine.
  1526. *
  1527. * @ignore
  1528. * @todo Add key/container clear.
  1529. * @return void
  1530. */
  1531. private function removeFromIdentityMap(mixed $document)
  1532. {
  1533. $oid = $this->getKeyForObject($document);
  1535. if (isset($this->documentIdentifiers[$oid])) {
  1536. unset($this->identityMap[$this->documentIdentifiers[$oid]]);
  1537. }
  1539. unset(
  1540. $this->documentIdentifiers[$oid],
  1541. $this->documentState[$oid]
  1542. );
  1543. }
  1545. /**
  1546. * Changes the object with the registered modify callbacks.
  1547. *
  1548. * @param mixed $object
  1549. *
  1550. * return mixed the modified object.
  1551. */
  1552. #[\Override]
  1553. public function runModifyCallbacks($object)
  1554. {
  1555. foreach ($this->modifiers[$object] as $callback) {
  1556. $callback($object);
  1557. }
  1559. return $object;
  1560. }
  1562. /**
  1563. * Removes the object from the commercetools database.
  1564. *
  1565. * @param mixed $object
  1566. *
  1567. * @return UnitOfWorkInterface
  1568. */
  1569. #[\Override]
  1570. public function scheduleRemove($object): UnitOfWorkInterface
  1571. {
  1572. $visited = [];
  1574. $this->doScheduleRemove($object, $visited);
  1576. return $this;
  1577. }
  1579. /**
  1580. * Puts the given object in the save queue.
  1581. *
  1582. * @param mixed $entity
  1583. *
  1584. * @return UnitOfWorkInterface
  1585. */
  1586. #[\Override]
  1587. public function scheduleSave($entity): UnitOfWorkInterface
  1588. {
  1589. $visited = [];
  1591. $this->doScheduleSave($entity, $visited);
  1593. return $this;
  1594. }
  1596. /**
  1597. * Sets the change manager.
  1598. *
  1599. * @param ChangeManagerInterface $changeManager
  1600. *
  1601. * @return $this
  1602. */
  1603. public function setChangeManager(ChangeManagerInterface $changeManager): self
  1604. {
  1605. $this->changeManager = $changeManager;
  1607. return $this;
  1608. }
  1610. /**
  1611. * Sets the response handler for this class.
  1612. *
  1613. * @param ResponseHandlerInterface $responseHandler
  1614. *
  1615. * @return $this
  1616. */
  1617. public function setResponseHandler(ResponseHandlerInterface $responseHandler): self
  1618. {
  1619. $this->responseHandler = $responseHandler;
  1621. return $this;
  1622. }
  1624. /**
  1625. * How often should the flush be retried?
  1626. *
  1627. * You can use the constants for disabling or an infinite loop.
  1628. *
  1629. * @param int $retryCount
  1630. *
  1631. * @return $this
  1632. */
  1633. public function setRetryCount(int $retryCount): self
  1634. {
  1635. $this->retryCount = $retryCount;
  1637. return $this;
  1638. }
  1640. /**
  1641. * Tries to find a managed object by its key and container.
  1642. *
  1643. * @param string $container
  1644. * @param string $key
  1645. *
  1646. * @return mixed|void
  1647. */
  1648. #[\Override]
  1649. public function tryGetByContainerAndKey(string $container, string $key)
  1650. {
  1651. $key = $container . '|' . $key;
  1652. $return = null;
  1654. if (array_key_exists($key, $this->containerKeyMap)) {
  1655. $return = $this->tryGetById($this->containerKeyMap[$key]);
  1656. }
  1658. return $return;
  1659. }
  1661. /**
  1662. * Tries to find an document with the given customer identifier in the identity map of this UnitOfWork.
  1663. *
  1664. * @param string $id The document customer id to look for.
  1665. *
  1666. * @return mixed Returns the document with the specified identifier if it exists in
  1667. * this UnitOfWork, void otherwise.
  1668. */
  1669. #[\Override]
  1670. public function tryGetByCustomerId(string $id)
  1671. {
  1672. $return = null;
  1674. if (array_key_exists($id, $this->customerIdMap)) {
  1675. $return = $this->tryGetById($this->customerIdMap[$id]);
  1676. }
  1678. return $return;
  1679. }
  1681. /**
  1682. * Tries to find an document with the given identifier in the identity map of this UnitOfWork.
  1683. *
  1684. * @param mixed $id The document identifier to look for.
  1685. *
  1686. * @return mixed Returns the document with the specified identifier if it exists in
  1687. * this UnitOfWork, void otherwise.
  1688. */
  1689. #[\Override]
  1690. public function tryGetById($id)
  1691. {
  1692. $model = @$this->identityMap[$id];
  1694. if (!$model) {
  1695. $model = @$this->newDocuments[$id];
  1696. }
  1698. return $model;
  1699. }
  1701. /**
  1702. * Tries to find an document with the given identifier in the identity map of this UnitOfWork.
  1703. *
  1704. * @param string $key The document key to look for.
  1705. *
  1706. * @return mixed Returns the document with the specified identifier if it exists in
  1707. * this UnitOfWork, void otherwise.
  1708. */
  1709. #[\Override]
  1710. public function tryGetByKey(string $key)
  1711. {
  1712. $return = null;
  1714. if (array_key_exists($key, $this->keyMap)) {
  1715. $return = $this->tryGetById($this->keyMap[$key]);
  1716. }
  1718. return $return;
  1719. }
  1720. }