src/Core/Framework/DataAbstractionLayer/VersionManager.php line 101

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Framework\DataAbstractionLayer;
  5. use Shopware\Core\Defaults;
  6. use Shopware\Core\Framework\Api\Context\AdminApiSource;
  7. use Shopware\Core\Framework\Api\Sync\SyncOperation;
  8. use Shopware\Core\Framework\Context;
  9. use Shopware\Core\Framework\DataAbstractionLayer\Event\EntityWrittenContainerEvent;
  10. use Shopware\Core\Framework\DataAbstractionLayer\Exception\VersionMergeAlreadyLockedException;
  11. use Shopware\Core\Framework\DataAbstractionLayer\Field\AssociationField;
  12. use Shopware\Core\Framework\DataAbstractionLayer\Field\ChildrenAssociationField;
  13. use Shopware\Core\Framework\DataAbstractionLayer\Field\DateTimeField;
  14. use Shopware\Core\Framework\DataAbstractionLayer\Field\Field;
  15. use Shopware\Core\Framework\DataAbstractionLayer\Field\FkField;
  16. use Shopware\Core\Framework\DataAbstractionLayer\Field\Flag\CascadeDelete;
  17. use Shopware\Core\Framework\DataAbstractionLayer\Field\Flag\Extension;
  18. use Shopware\Core\Framework\DataAbstractionLayer\Field\Flag\Required;
  19. use Shopware\Core\Framework\DataAbstractionLayer\Field\Flag\WriteProtected;
  20. use Shopware\Core\Framework\DataAbstractionLayer\Field\ManyToManyAssociationField;
  21. use Shopware\Core\Framework\DataAbstractionLayer\Field\ManyToOneAssociationField;
  22. use Shopware\Core\Framework\DataAbstractionLayer\Field\OneToManyAssociationField;
  23. use Shopware\Core\Framework\DataAbstractionLayer\Field\OneToOneAssociationField;
  24. use Shopware\Core\Framework\DataAbstractionLayer\Field\ParentFkField;
  25. use Shopware\Core\Framework\DataAbstractionLayer\Field\ReferenceVersionField;
  26. use Shopware\Core\Framework\DataAbstractionLayer\Field\StorageAware;
  27. use Shopware\Core\Framework\DataAbstractionLayer\Field\TranslationsAssociationField;
  28. use Shopware\Core\Framework\DataAbstractionLayer\Field\VersionField;
  29. use Shopware\Core\Framework\DataAbstractionLayer\Read\EntityReaderInterface;
  30. use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
  31. use Shopware\Core\Framework\DataAbstractionLayer\Search\EntitySearcherInterface;
  32. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsFilter;
  33. use Shopware\Core\Framework\DataAbstractionLayer\Search\Sorting\FieldSorting;
  34. use Shopware\Core\Framework\DataAbstractionLayer\Version\Aggregate\VersionCommit\VersionCommitCollection;
  35. use Shopware\Core\Framework\DataAbstractionLayer\Version\Aggregate\VersionCommit\VersionCommitDefinition;
  36. use Shopware\Core\Framework\DataAbstractionLayer\Version\Aggregate\VersionCommit\VersionCommitEntity;
  37. use Shopware\Core\Framework\DataAbstractionLayer\Version\Aggregate\VersionCommitData\VersionCommitDataDefinition;
  38. use Shopware\Core\Framework\DataAbstractionLayer\Version\Aggregate\VersionCommitData\VersionCommitDataEntity;
  39. use Shopware\Core\Framework\DataAbstractionLayer\Version\VersionDefinition;
  40. use Shopware\Core\Framework\DataAbstractionLayer\Write\CloneBehavior;
  41. use Shopware\Core\Framework\DataAbstractionLayer\Write\Command\InsertCommand;
  42. use Shopware\Core\Framework\DataAbstractionLayer\Write\EntityExistence;
  43. use Shopware\Core\Framework\DataAbstractionLayer\Write\EntityWriteGatewayInterface;
  44. use Shopware\Core\Framework\DataAbstractionLayer\Write\EntityWriterInterface;
  45. use Shopware\Core\Framework\DataAbstractionLayer\Write\WriteContext;
  46. use Shopware\Core\Framework\DataAbstractionLayer\Write\WriteResult;
  47. use Shopware\Core\Framework\Log\Package;
  48. use Shopware\Core\Framework\Util\Json;
  49. use Shopware\Core\Framework\Uuid\Uuid;
  50. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  51. use Symfony\Component\Lock\LockFactory;
  52. use Symfony\Component\Serializer\SerializerInterface;
  54. /**
  55.  * @internal
  56.  */
  57. #[Package('core')]
  58. class VersionManager
  59. {
  60.     final public const DISABLE_AUDIT_LOG = 'disable-audit-log';
  61.     final public const MERGE_SCOPE = 'merge-scope';
  63.     public function __construct(private readonly EntityWriterInterface $entityWriter, private readonly EntityReaderInterface $entityReader, private readonly EntitySearcherInterface $entitySearcher, private readonly EntityWriteGatewayInterface $entityWriteGateway, private readonly EventDispatcherInterface $eventDispatcher, private readonly SerializerInterface $serializer, private readonly DefinitionInstanceRegistry $registry, private readonly VersionCommitDefinition $versionCommitDefinition, private readonly VersionCommitDataDefinition $versionCommitDataDefinition, private readonly VersionDefinition $versionDefinition, private readonly LockFactory $lockFactory)
  64.     {
  65.     }
  67.     /**
  68.      * @param array<array<string, mixed|null>> $rawData
  69.      *
  70.      * @return array<string, array<EntityWriteResult>>
  71.      */
  72.     public function upsert(EntityDefinition $definition, array $rawData, WriteContext $writeContext): array
  73.     {
  74.         $result = $this->entityWriter->upsert($definition, $rawData, $writeContext);
  76.         $this->writeAuditLog($result, $writeContext);
  78.         return $result;
  79.     }
  81.     /**
  82.      * @param array<array<string, mixed|null>> $rawData
  83.      *
  84.      * @return array<string, array<EntityWriteResult>>
  85.      */
  86.     public function insert(EntityDefinition $definition, array $rawData, WriteContext $writeContext): array
  87.     {
  88.         /** @var array<string, array<EntityWriteResult>> $result */
  89.         $result = $this->entityWriter->insert($definition, $rawData, $writeContext);
  91.         $this->writeAuditLog($result, $writeContext);
  93.         return $result;
  94.     }
  96.     /**
  97.      * @param array<array<string, mixed|null>> $rawData
  98.      *
  99.      * @return array<string, array<EntityWriteResult>>
  100.      */
  101.     public function update(EntityDefinition $definition, array $rawData, WriteContext $writeContext): array
  102.     {
  103.         /** @var array<string, array<EntityWriteResult>> $result */
  104.         $result = $this->entityWriter->update($definition, $rawData, $writeContext);
  106.         $this->writeAuditLog($result, $writeContext);
  108.         return $result;
  109.     }
  111.     /**
  112.      * @param array<array<string, mixed|null>> $ids
  113.      */
  114.     public function delete(EntityDefinition $definition, array $ids, WriteContext $writeContext): WriteResult
  115.     {
  116.         $result = $this->entityWriter->delete($definition, $ids, $writeContext);
  118.         $this->writeAuditLog($result->getDeleted(), $writeContext);
  120.         return $result;
  121.     }
  123.     public function createVersion(EntityDefinition $definition, string $id, WriteContext $context, ?string $name = null, ?string $versionId = null): string
  124.     {
  125.         $versionId = $versionId ?? Uuid::randomHex();
  126.         $versionData = ['id' => $versionId];
  128.         if ($name) {
  129.             $versionData['name'] = $name;
  130.         }
  132.         $context->scope(Context::SYSTEM_SCOPE, function ($context) use ($versionData): void {
  133.             $this->entityWriter->upsert($this->versionDefinition, [$versionData], $context);
  134.         });
  136.         $affected = $this->cloneEntity($definition, $id, $id, $versionId, $context, new CloneBehavior());
  138.         $versionContext = $context->createWithVersionId($versionId);
  140.         $event = EntityWrittenContainerEvent::createWithWrittenEvents($affected, $versionContext->getContext(), []);
  141.         $this->eventDispatcher->dispatch($event);
  143.         $this->writeAuditLog($affected, $context, $versionId, true);
  145.         return $versionId;
  146.     }
  148.     public function merge(string $versionId, WriteContext $writeContext): void
  149.     {
  150.         // acquire a lock to prevent multiple merges of the same version
  151.         $lock = $this->lockFactory->createLock('sw-merge-version-' . $versionId);
  153.         if (!$lock->acquire()) {
  154.             throw new VersionMergeAlreadyLockedException($versionId);
  155.         }
  157.         // load all commits of the provided version
  158.         $commits = $this->getCommits($versionId, $writeContext);
  160.         // create context for live and version
  161.         $versionContext = $writeContext->createWithVersionId($versionId);
  162.         $liveContext = $writeContext->createWithVersionId(Defaults::LIVE_VERSION);
  164.         $versionContext->addState(self::MERGE_SCOPE);
  165.         $liveContext->addState(self::MERGE_SCOPE);
  167.         // group all payloads by their action (insert, update, delete) and by their entity name
  168.         $writes = $this->buildWrites($commits);
  170.         // execute writes and get access to the write result to dispatch events later on
  171.         $result = $this->executeWrites($writes, $liveContext);
  173.         // remove commits which reference the version and create a "merge commit" for the live version with all payloads
  174.         $this->updateVersionData($commits, $writeContext, $versionId);
  176.         // delete all versioned records
  177.         $this->deleteClones($commits, $versionContext, $versionId);
  179.         // release lock to ensure no other merge is running
  180.         $lock->release();
  182.         // dispatch events to trigger indexer and other subscribts
  183.         $writes = EntityWrittenContainerEvent::createWithWrittenEvents($result->getWritten(), $liveContext->getContext(), []);
  185.         $deletes = EntityWrittenContainerEvent::createWithDeletedEvents($result->getDeleted(), $liveContext->getContext(), []);
  187.         if ($deletes->getEvents() !== null) {
  188.             $writes->addEvent(...$deletes->getEvents()->getElements());
  189.         }
  190.         $this->eventDispatcher->dispatch($writes);
  192.         $versionContext->removeState(self::MERGE_SCOPE);
  193.         $liveContext->addState(self::MERGE_SCOPE);
  194.     }
  196.     /**
  197.      * @return array<string, array<EntityWriteResult>>
  198.      */
  199.     public function clone(
  200.         EntityDefinition $definition,
  201.         string $id,
  202.         string $newId,
  203.         string $versionId,
  204.         WriteContext $context,
  205.         CloneBehavior $behavior
  206.     ): array {
  207.         return $this->cloneEntity($definition, $id, $newId, $versionId, $context, $behavior, true);
  208.     }
  210.     /**
  211.      * @return array<string, array<EntityWriteResult>>
  212.      */
  213.     private function cloneEntity(
  214.         EntityDefinition $definition,
  215.         string $id,
  216.         string $newId,
  217.         string $versionId,
  218.         WriteContext $context,
  219.         CloneBehavior $behavior,
  220.         bool $writeAuditLog = false
  221.     ): array {
  222.         $criteria = new Criteria([$id]);
  223.         $this->addCloneAssociations($definition, $criteria, $behavior->cloneChildren());
  225.         $detail = $this->entityReader->read($definition, $criteria, $context->getContext())->first();
  227.         if ($detail === null) {
  228.             throw new \RuntimeException(sprintf('Cannot create new version. %s by id (%s) not found.', $definition->getEntityName(), $id));
  229.         }
  231.         $data = json_decode($this->serializer->serialize($detail, 'json'), true, 512, \JSON_THROW_ON_ERROR);
  233.         $keepIds = $newId === $id;
  235.         $data = $this->filterPropertiesForClone($definition, $data, $keepIds, $id, $definition, $context->getContext());
  236.         $data['id'] = $newId;
  238.         $createdAtField = $definition->getField('createdAt');
  239.         $updatedAtField = $definition->getField('updatedAt');
  241.         if ($createdAtField instanceof DateTimeField) {
  242.             $data['createdAt'] = new \DateTime();
  243.         }
  245.         if ($updatedAtField instanceof DateTimeField) {
  246.             if ($updatedAtField->getFlag(Required::class)) {
  247.                 $data['updatedAt'] = new \DateTime();
  248.             } else {
  249.                 $data['updatedAt'] = null;
  250.             }
  251.         }
  253.         $data = array_replace_recursive($data, $behavior->getOverwrites());
  255.         $versionContext = $context->createWithVersionId($versionId);
  256.         $result = null;
  257.         $versionContext->scope(Context::SYSTEM_SCOPE, function (WriteContext $context) use ($definition, $data, &$result): void {
  258.             $result = $this->entityWriter->insert($definition, [$data], $context);
  259.         });
  261.         if ($writeAuditLog) {
  262.             $this->writeAuditLog($result, $versionContext);
  263.         }
  265.         return $result;
  266.     }
  268.     /**
  269.      * @param array<string, array<string, mixed|null>|null> $data
  270.      *
  271.      * @return array<string, array<string, mixed|null>|string|null>
  272.      */
  273.     private function filterPropertiesForClone(EntityDefinition $definition, array $data, bool $keepIds, string $cloneId, EntityDefinition $cloneDefinition, Context $context): array
  274.     {
  275.         $extensions = [];
  276.         $payload = [];
  278.         $fields = $definition->getFields();
  280.         foreach ($fields as $field) {
  281.             /** @var WriteProtected|null $writeProtection */
  282.             $writeProtection = $field->getFlag(WriteProtected::class);
  283.             if ($writeProtection && !$writeProtection->isAllowed(Context::SYSTEM_SCOPE)) {
  284.                 continue;
  285.             }
  287.             //set data and payload cursor to root or extensions to simplify following if conditions
  288.             $dataCursor = $data;
  290.             $payloadCursor = &$payload;
  292.             if ($field instanceof VersionField || $field instanceof ReferenceVersionField) {
  293.                 continue;
  294.             }
  296.             if ($field->is(Extension::class)) {
  297.                 $dataCursor = $data['extensions'] ?? [];
  298.                 $payloadCursor = &$extensions;
  299.                 if (isset($dataCursor['foreignKeys'])) {
  300.                     $fields = $definition->getFields();
  301.                     /**
  302.                      * @var string $key
  303.                      * @var string $value
  304.                      */
  305.                     foreach ($dataCursor['foreignKeys'] as $key => $value) {
  306.                         // Clone FK extension and add it to payload
  307.                         if (\is_string($value) && Uuid::isValid($value) && $fields->has($key) && $fields->get($key) instanceof FkField) {
  308.                             $payload[$key] = $value;
  309.                         }
  310.                     }
  311.                 }
  312.             }
  314.             if (!\array_key_exists($field->getPropertyName(), $dataCursor)) {
  315.                 continue;
  316.             }
  318.             if (!$keepIds && $field instanceof ParentFkField) {
  319.                 continue;
  320.             }
  322.             $value = $dataCursor[$field->getPropertyName()];
  324.             // remove reference of cloned entity in all sub entity routes. Appears in a parent-child nested data tree
  325.             if ($field instanceof FkField && !$keepIds && $value === $cloneId && $cloneDefinition === $field->getReferenceDefinition()) {
  326.                 continue;
  327.             }
  329.             if ($value === null) {
  330.                 continue;
  331.             }
  333.             //scalar value? assign directly
  334.             if (!$field instanceof AssociationField) {
  335.                 $payloadCursor[$field->getPropertyName()] = $value;
  337.                 continue;
  338.             }
  340.             //many to one should be skipped because it is no part of the root entity
  341.             if ($field instanceof ManyToOneAssociationField) {
  342.                 continue;
  343.             }
  345.             /** @var CascadeDelete|null $flag */
  346.             $flag = $field->getFlag(CascadeDelete::class);
  347.             if (!$flag || !$flag->isCloneRelevant()) {
  348.                 continue;
  349.             }
  351.             if ($field instanceof OneToManyAssociationField) {
  352.                 $reference = $field->getReferenceDefinition();
  354.                 $nested = [];
  355.                 foreach ($value as $item) {
  356.                     $nestedItem = $this->filterPropertiesForClone($reference, $item, $keepIds, $cloneId, $cloneDefinition, $context);
  358.                     if (!$keepIds) {
  359.                         $nestedItem = $this->removePrimaryKey($field, $nestedItem);
  360.                     }
  362.                     $nested[] = $nestedItem;
  363.                 }
  365.                 $nested = array_filter($nested);
  366.                 if (empty($nested)) {
  367.                     continue;
  368.                 }
  370.                 $payloadCursor[$field->getPropertyName()] = $nested;
  372.                 continue;
  373.             }
  375.             if ($field instanceof ManyToManyAssociationField) {
  376.                 $nested = [];
  378.                 foreach ($value as $item) {
  379.                     $nested[] = ['id' => $item['id']];
  380.                 }
  382.                 if (empty($nested)) {
  383.                     continue;
  384.                 }
  386.                 $payloadCursor[$field->getPropertyName()] = $nested;
  388.                 continue;
  389.             }
  391.             if ($field instanceof OneToOneAssociationField && $value) {
  392.                 $reference = $field->getReferenceDefinition();
  394.                 $nestedItem = $this->filterPropertiesForClone($reference, $value, $keepIds, $cloneId, $cloneDefinition, $context);
  396.                 if (!$keepIds) {
  397.                     $nestedItem = $this->removePrimaryKey($field, $nestedItem);
  398.                 }
  400.                 $payloadCursor[$field->getPropertyName()] = $nestedItem;
  401.             }
  402.         }
  404.         if (!empty($extensions)) {
  405.             $payload['extensions'] = $extensions;
  406.         }
  408.         return $payload;
  409.     }
  411.     /**
  412.      * @param array<string, array<EntityWriteResult>> $writtenEvents
  413.      */
  414.     private function writeAuditLog(array $writtenEvents, WriteContext $writeContext, ?string $versionId = null, bool $isClone = false): void
  415.     {
  416.         if ($writeContext->getContext()->hasState(self::DISABLE_AUDIT_LOG)) {
  417.             return;
  418.         }
  420.         $versionId ??= $writeContext->getContext()->getVersionId();
  421.         if ($versionId === Defaults::LIVE_VERSION) {
  422.             return;
  423.         }
  425.         $commitId = Uuid::randomBytes();
  427.         $date = (new \DateTime())->format(Defaults::STORAGE_DATE_TIME_FORMAT);
  429.         $source = $writeContext->getContext()->getSource();
  430.         $userId = $source instanceof AdminApiSource && $source->getUserId()
  431.             ? Uuid::fromHexToBytes($source->getUserId())
  432.             : null;
  434.         $insert = new InsertCommand(
  435.             $this->versionCommitDefinition,
  436.             [
  437.                 'id' => $commitId,
  438.                 'user_id' => $userId,
  439.                 'version_id' => Uuid::fromHexToBytes($versionId),
  440.                 'created_at' => $date,
  441.             ],
  442.             ['id' => $commitId],
  443.             new EntityExistence(
  444.                 $this->versionCommitDefinition->getEntityName(),
  445.                 ['id' => Uuid::fromBytesToHex($commitId)],
  446.                 false,
  447.                 false,
  448.                 false,
  449.                 []
  450.             ),
  451.             ''
  452.         );
  454.         $commands = [$insert];
  456.         foreach ($writtenEvents as $items) {
  457.             if (\count($items) === 0) {
  458.                 continue;
  459.             }
  461.             $definition = $this->registry->getByEntityName($items[0]->getEntityName());
  462.             $entityName = $definition->getEntityName();
  464.             if (!$definition->isVersionAware()) {
  465.                 continue;
  466.             }
  468.             if (mb_strpos('version', $entityName) === 0) {
  469.                 continue;
  470.             }
  472.             /** @var EntityWriteResult $item */
  473.             foreach ($items as $item) {
  474.                 $payload = $item->getPayload();
  476.                 $primary = $item->getPrimaryKey();
  477.                 if (!\is_array($primary)) {
  478.                     $primary = ['id' => $primary];
  479.                 }
  480.                 $primary['versionId'] = $versionId;
  482.                 $id = Uuid::randomBytes();
  484.                 $commands[] = new InsertCommand(
  485.                     $this->versionCommitDataDefinition,
  486.                     [
  487.                         'id' => $id,
  488.                         'version_commit_id' => $commitId,
  489.                         'entity_name' => $entityName,
  490.                         'entity_id' => Json::encode($primary),
  491.                         'payload' => Json::encode($payload),
  492.                         'user_id' => $userId,
  493.                         'action' => $isClone ? 'clone' : $item->getOperation(),
  494.                         'created_at' => $date,
  495.                     ],
  496.                     ['id' => $id],
  497.                     new EntityExistence(
  498.                         $this->versionCommitDataDefinition->getEntityName(),
  499.                         ['id' => Uuid::fromBytesToHex($id)],
  500.                         false,
  501.                         false,
  502.                         false,
  503.                         []
  504.                     ),
  505.                     ''
  506.                 );
  507.             }
  508.         }
  510.         if (\count($commands) <= 1) {
  511.             return;
  512.         }
  514.         $writeContext->scope(Context::SYSTEM_SCOPE, function () use ($commands, $writeContext): void {
  515.             $this->entityWriteGateway->execute($commands, $writeContext);
  516.         });
  517.     }
  519.     /**
  520.      * @param array<string, array<string, mixed>|string|null> $payload
  521.      *
  522.      * @return array<string, array<string, mixed>|string|null>
  523.      */
  524.     private function addVersionToPayload(array $payload, EntityDefinition $definition, string $versionId): array
  525.     {
  526.         $fields = $definition->getFields()->filter(fn (Field $field) => $field instanceof VersionField || $field instanceof ReferenceVersionField);
  528.         foreach ($fields as $field) {
  529.             $payload[$field->getPropertyName()] = $versionId;
  530.         }
  532.         return $payload;
  533.     }
  535.     /**
  536.      * @param array<string, array<string, mixed>|string|null> $nestedItem
  537.      *
  538.      * @return array<string, array<string, mixed>|string|null>
  539.      */
  540.     private function removePrimaryKey(AssociationField $field, array $nestedItem): array
  541.     {
  542.         $pkFields = $field->getReferenceDefinition()->getPrimaryKeys();
  544.         foreach ($pkFields as $pkField) {
  545.             /*
  546.              * `EntityTranslationDefinition`s dont have an `id`, they use a composite primary key consisting of the
  547.              * entity id and the `languageId`. When cloning the entity we want to copy the `languageId`. The entity id
  548.              * has to be unset, so that its set by the parent, resulting in a valid primary key.
  549.              */
  550.             /** @var StorageAware $pkField */
  551.             if ($field instanceof TranslationsAssociationField && $pkField->getStorageName() === $field->getLanguageField()) {
  552.                 continue;
  553.             }
  554.             /** @var Field $pkField */
  555.             if (\array_key_exists($pkField->getPropertyName(), $nestedItem)) {
  556.                 unset($nestedItem[$pkField->getPropertyName()]);
  557.             }
  558.         }
  560.         return $nestedItem;
  561.     }
  563.     private function addCloneAssociations(
  564.         EntityDefinition $definition,
  565.         Criteria $criteria,
  566.         bool $cloneChildren,
  567.         int $childCounter = 1
  568.     ): void {
  569.         //add all cascade delete associations
  570.         $cascades = $definition->getFields()->filter(function (Field $field) {
  571.             /** @var CascadeDelete|null $flag */
  572.             $flag = $field->getFlag(CascadeDelete::class);
  574.             return $flag ? $flag->isCloneRelevant() : false;
  575.         });
  577.         /** @var AssociationField $cascade */
  578.         foreach ($cascades as $cascade) {
  579.             $nested = $criteria->getAssociation($cascade->getPropertyName());
  581.             if ($cascade instanceof ManyToManyAssociationField) {
  582.                 continue;
  583.             }
  585.             //many to one shouldn't be cascaded
  586.             if ($cascade instanceof ManyToOneAssociationField) {
  587.                 continue;
  588.             }
  590.             $reference = $cascade->getReferenceDefinition();
  592.             $childrenAware = $reference->isChildrenAware();
  594.             //first level of parent-child tree?
  595.             if ($childrenAware && $reference !== $definition) {
  596.                 //where product.children.parentId IS NULL
  597.                 $nested->addFilter(new EqualsFilter($reference->getEntityName() . '.parentId', null));
  598.             }
  600.             if ($cascade instanceof ChildrenAssociationField) {
  601.                 //break endless loop
  602.                 if ($childCounter >= 30 || !$cloneChildren) {
  603.                     $criteria->removeAssociation($cascade->getPropertyName());
  605.                     continue;
  606.                 }
  608.                 ++$childCounter;
  609.                 $this->addCloneAssociations($reference, $nested, $cloneChildren, $childCounter);
  611.                 continue;
  612.             }
  614.             $this->addCloneAssociations($reference, $nested, $cloneChildren);
  615.         }
  616.     }
  618.     private function translationHasParent(VersionCommitEntity $commit, VersionCommitDataEntity $translationData): bool
  619.     {
  620.         /** @var EntityTranslationDefinition $translationDefinition */
  621.         $translationDefinition = $this->registry->getByEntityName($translationData->getEntityName());
  623.         $parentEntity = $translationDefinition->getParentDefinition()->getEntityName();
  625.         $parentPropertyName = $this->getEntityForeignKeyName($parentEntity);
  627.         /** @var array<string, string> $payload */
  628.         $payload = $translationData->getPayload();
  629.         $parentId = $payload[$parentPropertyName];
  631.         foreach ($commit->getData() as $data) {
  632.             if ($data->getEntityName() !== $parentEntity) {
  633.                 continue;
  634.             }
  636.             $primary = $data->getEntityId();
  638.             if (!isset($primary['id'])) {
  639.                 continue;
  640.             }
  642.             if ($primary['id'] === $parentId) {
  643.                 return true;
  644.             }
  645.         }
  647.         return false;
  648.     }
  650.     /**
  651.      * @param array<string> $entityId
  652.      * @param array<string|int, mixed> $payload
  653.      *
  654.      * @return array<string|int, mixed>
  655.      */
  656.     private function addTranslationToPayload(array $entityId, array $payload, EntityDefinition $definition, VersionCommitEntity $commit): array
  657.     {
  658.         $translationDefinition = $definition->getTranslationDefinition();
  660.         if (!$translationDefinition) {
  661.             return $payload;
  662.         }
  663.         if (!isset($entityId['id'])) {
  664.             return $payload;
  665.         }
  667.         $id = $entityId['id'];
  669.         $translations = [];
  671.         $foreignKeyName = $this->getEntityForeignKeyName($definition->getEntityName());
  673.         foreach ($commit->getData() as $data) {
  674.             if ($data->getEntityName() !== $translationDefinition->getEntityName()) {
  675.                 continue;
  676.             }
  678.             $translation = $data->getPayload();
  679.             if (!isset($translation[$foreignKeyName])) {
  680.                 continue;
  681.             }
  683.             if ($translation[$foreignKeyName] !== $id) {
  684.                 continue;
  685.             }
  687.             $translations[] = $this->addVersionToPayload($translation, $translationDefinition, Defaults::LIVE_VERSION);
  688.         }
  690.         $payload['translations'] = $translations;
  692.         return $payload;
  693.     }
  695.     private function getEntityForeignKeyName(string $parentEntity): string
  696.     {
  697.         $parentPropertyName = explode('_', $parentEntity);
  698.         $parentPropertyName = array_map('ucfirst', $parentPropertyName);
  700.         return lcfirst(implode('', $parentPropertyName)) . 'Id';
  701.     }
  703.     private function getCommits(string $versionId, WriteContext $writeContext): VersionCommitCollection
  704.     {
  705.         $criteria = new Criteria();
  706.         $criteria->addFilter(new EqualsFilter('version_commit.versionId', $versionId));
  707.         $criteria->addSorting(new FieldSorting('version_commit.autoIncrement'));
  708.         $commitIds = $this->entitySearcher->search($this->versionCommitDefinition, $criteria, $writeContext->getContext());
  710.         $readCriteria = new Criteria();
  711.         if ($commitIds->getTotal() > 0) {
  712.             $readCriteria = new Criteria($commitIds->getIds());
  713.         }
  715.         $readCriteria->addAssociation('data');
  717.         $readCriteria
  718.             ->getAssociation('data')
  719.             ->addSorting(new FieldSorting('autoIncrement'));
  721.         /** @var VersionCommitCollection $commits */
  722.         $commits = $this->entityReader->read($this->versionCommitDefinition, $readCriteria, $writeContext->getContext());
  724.         return $commits;
  725.     }
  727.     /**
  728.      * @return array{insert:array<string, array<int, mixed>>, update:array<string, array<int, mixed>>, delete:array<string, array<int, mixed>>}
  729.      */
  730.     private function buildWrites(VersionCommitCollection $commits): array
  731.     {
  732.         $writes = [
  733.             'insert' => [],
  734.             'update' => [],
  735.             'delete' => [],
  736.         ];
  738.         foreach ($commits as $commit) {
  739.             foreach ($commit->getData() as $data) {
  740.                 $definition = $this->registry->getByEntityName($data->getEntityName());
  742.                 switch ($data->getAction()) {
  743.                     case 'insert':
  744.                     case 'update':
  745.                         if ($definition instanceof EntityTranslationDefinition && $this->translationHasParent($commit, $data)) {
  746.                             break;
  747.                         }
  749.                         $payload = $data->getPayload();
  750.                         if (empty($payload)) {
  751.                             break;
  752.                         }
  753.                         $payload = $this->addVersionToPayload($payload, $definition, Defaults::LIVE_VERSION);
  754.                         $payload = $this->addTranslationToPayload($data->getEntityId(), $payload, $definition, $commit);
  755.                         $writes[$data->getAction()][$definition->getEntityName()][] = $payload;
  757.                         break;
  758.                     case 'delete':
  759.                         $id = $data->getEntityId();
  760.                         $id = $this->addVersionToPayload($id, $definition, Defaults::LIVE_VERSION);
  761.                         $writes['delete'][$definition->getEntityName()][] = $id;
  763.                         break;
  764.                 }
  765.             }
  766.             $writes['delete']['version_commit'][] = ['id' => $commit->getId()];
  767.         }
  769.         return $writes;
  770.     }
  772.     /**
  773.      * @param array{insert:array<string, array<int, mixed>>, update:array<string, array<int, mixed>>, delete:array<string, array<int, mixed>>} $writes
  774.      */
  775.     private function executeWrites(array $writes, WriteContext $liveContext): WriteResult
  776.     {
  777.         $operations = [];
  778.         foreach ($writes['insert'] as $entity => $payload) {
  779.             $operations[] = new SyncOperation('insert-' . $entity, $entity, 'upsert', $payload);
  780.         }
  781.         foreach ($writes['update'] as $entity => $payload) {
  782.             $operations[] = new SyncOperation('update-' . $entity, $entity, 'upsert', $payload);
  783.         }
  784.         foreach ($writes['delete'] as $entity => $payload) {
  785.             $operations[] = new SyncOperation('delete-' . $entity, $entity, 'delete', $payload);
  786.         }
  788.         return $this->entityWriter->sync($operations, $liveContext);
  789.     }
  791.     private function updateVersionData(VersionCommitCollection $commits, WriteContext $writeContext, string $versionId): void
  792.     {
  793.         $new = [];
  795.         foreach ($commits as $commit) {
  796.             foreach ($commit->getData() as $data) {
  797.                 // skip clone action, otherwise the payload would contain all data
  798.                 if ($data->getAction() === 'clone' || $data->getPayload() === null) {
  799.                     continue;
  800.                 }
  801.                 $definition = $this->registry->getByEntityName($data->getEntityName());
  803.                 $id = $data->getEntityId();
  804.                 $id = $this->addVersionToPayload($id, $definition, Defaults::LIVE_VERSION);
  806.                 $payload = $this->addVersionToPayload($data->getPayload(), $definition, Defaults::LIVE_VERSION);
  808.                 $new[] = [
  809.                     'entityId' => $id,
  810.                     'payload' => Json::encode($payload),
  811.                     'userId' => $data->getUserId(),
  812.                     'integrationId' => $data->getIntegrationId(),
  813.                     'entityName' => $data->getEntityName(),
  814.                     'action' => $data->getAction(),
  815.                     'createdAt' => (new \DateTime())->format(Defaults::STORAGE_DATE_TIME_FORMAT),
  816.                 ];
  817.             }
  818.         }
  820.         $commit = [
  821.             'versionId' => Defaults::LIVE_VERSION,
  822.             'data' => $new,
  823.             'userId' => $writeContext->getContext()->getSource() instanceof AdminApiSource ? $writeContext->getContext()->getSource()->getUserId() : null,
  824.             'isMerge' => true,
  825.             'message' => 'merge commit ' . (new \DateTime())->format(Defaults::STORAGE_DATE_TIME_FORMAT),
  826.         ];
  828.         // create new version commit for merge commit
  829.         $this->entityWriter->insert($this->versionCommitDefinition, [$commit], $writeContext);
  831.         // delete version
  832.         $this->entityWriter->delete($this->versionDefinition, [['id' => $versionId]], $writeContext);
  833.     }
  835.     private function deleteClones(VersionCommitCollection $commits, WriteContext $versionContext, string $versionId): void
  836.     {
  837.         $handled = [];
  839.         foreach ($commits as $commit) {
  840.             foreach ($commit->getData() as $data) {
  841.                 $definition = $this->registry->getByEntityName($data->getEntityName());
  843.                 $entity = [
  844.                     'definition' => $definition->getEntityName(),
  845.                     'primary' => $data->getEntityId(),
  846.                 ];
  848.                 // deduplicate to prevent deletion errors
  849.                 $entityKey = md5(Json::encode($entity));
  850.                 if (isset($handled[$entityKey])) {
  851.                     continue;
  852.                 }
  853.                 $handled[$entityKey] = $entity;
  855.                 $primary = $this->addVersionToPayload($data->getEntityId(), $definition, $versionId);
  857.                 $this->entityWriter->delete($definition, [$primary], $versionContext);
  858.             }
  859.         }
  860.     }
  861. }