vendor/ezsystems/ezpublish-kernel/eZ/Publish/Core/Repository/ContentService.php line 393

Open in your IDE?
  1. <?php
  3. /**
  4.  * @copyright Copyright (C) eZ Systems AS. All rights reserved.
  5.  * @license For full copyright and license information view LICENSE file distributed with this source code.
  6.  */
  7. namespace eZ\Publish\Core\Repository;
  9. use eZ\Publish\API\Repository\ContentService as ContentServiceInterface;
  10. use eZ\Publish\API\Repository\Repository as RepositoryInterface;
  11. use eZ\Publish\API\Repository\Values\Content\ContentDraftList;
  12. use eZ\Publish\API\Repository\Values\Content\DraftList\Item\ContentDraftListItem;
  13. use eZ\Publish\API\Repository\Values\Content\DraftList\Item\UnauthorizedContentDraftListItem;
  14. use eZ\Publish\API\Repository\Values\Content\RelationList;
  15. use eZ\Publish\API\Repository\Values\Content\RelationList\Item\RelationListItem;
  16. use eZ\Publish\API\Repository\Values\Content\RelationList\Item\UnauthorizedRelationListItem;
  17. use eZ\Publish\API\Repository\Values\User\UserReference;
  18. use eZ\Publish\Core\Repository\Values\Content\Content;
  19. use eZ\Publish\Core\Repository\Values\Content\Location;
  20. use eZ\Publish\API\Repository\Values\Content\Language;
  21. use eZ\Publish\SPI\Persistence\Handler;
  22. use eZ\Publish\API\Repository\Values\Content\ContentUpdateStruct as APIContentUpdateStruct;
  23. use eZ\Publish\API\Repository\Values\ContentType\ContentType;
  24. use eZ\Publish\API\Repository\Values\Content\ContentCreateStruct as APIContentCreateStruct;
  25. use eZ\Publish\API\Repository\Values\Content\ContentMetadataUpdateStruct;
  26. use eZ\Publish\API\Repository\Values\Content\Content as APIContent;
  27. use eZ\Publish\API\Repository\Values\Content\VersionInfo as APIVersionInfo;
  28. use eZ\Publish\API\Repository\Values\Content\ContentInfo;
  29. use eZ\Publish\API\Repository\Values\User\User;
  30. use eZ\Publish\API\Repository\Values\Content\LocationCreateStruct;
  31. use eZ\Publish\API\Repository\Values\Content\Field;
  32. use eZ\Publish\API\Repository\Values\Content\Relation as APIRelation;
  33. use eZ\Publish\API\Repository\Exceptions\NotFoundException as APINotFoundException;
  34. use eZ\Publish\Core\Base\Exceptions\BadStateException;
  35. use eZ\Publish\Core\Base\Exceptions\NotFoundException;
  36. use eZ\Publish\Core\Base\Exceptions\InvalidArgumentException;
  37. use eZ\Publish\Core\Base\Exceptions\ContentValidationException;
  38. use eZ\Publish\Core\Base\Exceptions\ContentFieldValidationException;
  39. use eZ\Publish\Core\Base\Exceptions\UnauthorizedException;
  40. use eZ\Publish\Core\FieldType\ValidationError;
  41. use eZ\Publish\Core\Repository\Values\Content\VersionInfo;
  42. use eZ\Publish\Core\Repository\Values\Content\ContentCreateStruct;
  43. use eZ\Publish\Core\Repository\Values\Content\ContentUpdateStruct;
  44. use eZ\Publish\SPI\Limitation\Target;
  45. use eZ\Publish\SPI\Persistence\Content\MetadataUpdateStruct as SPIMetadataUpdateStruct;
  46. use eZ\Publish\SPI\Persistence\Content\CreateStruct as SPIContentCreateStruct;
  47. use eZ\Publish\SPI\Persistence\Content\UpdateStruct as SPIContentUpdateStruct;
  48. use eZ\Publish\SPI\Persistence\Content\Field as SPIField;
  49. use eZ\Publish\SPI\Persistence\Content\Relation\CreateStruct as SPIRelationCreateStruct;
  50. use Exception;
  52. /**
  53.  * This class provides service methods for managing content.
  54.  *
  55.  * @example Examples/content.php
  56.  */
  57. class ContentService implements ContentServiceInterface
  58. {
  59.     /** @var \eZ\Publish\Core\Repository\Repository */
  60.     protected $repository;
  62.     /** @var \eZ\Publish\SPI\Persistence\Handler */
  63.     protected $persistenceHandler;
  65.     /** @var array */
  66.     protected $settings;
  68.     /** @var \eZ\Publish\Core\Repository\Helper\DomainMapper */
  69.     protected $domainMapper;
  71.     /** @var \eZ\Publish\Core\Repository\Helper\RelationProcessor */
  72.     protected $relationProcessor;
  74.     /** @var \eZ\Publish\Core\Repository\Helper\NameSchemaService */
  75.     protected $nameSchemaService;
  77.     /** @var \eZ\Publish\Core\Repository\Helper\FieldTypeRegistry */
  78.     protected $fieldTypeRegistry;
  80.     /**
  81.      * Setups service with reference to repository object that created it & corresponding handler.
  82.      *
  83.      * @param \eZ\Publish\API\Repository\Repository $repository
  84.      * @param \eZ\Publish\SPI\Persistence\Handler $handler
  85.      * @param \eZ\Publish\Core\Repository\Helper\DomainMapper $domainMapper
  86.      * @param \eZ\Publish\Core\Repository\Helper\RelationProcessor $relationProcessor
  87.      * @param \eZ\Publish\Core\Repository\Helper\NameSchemaService $nameSchemaService
  88.      * @param \eZ\Publish\Core\Repository\Helper\FieldTypeRegistry $fieldTypeRegistry,
  89.      * @param array $settings
  90.      */
  91.     public function __construct(
  92.         RepositoryInterface $repository,
  93.         Handler $handler,
  94.         Helper\DomainMapper $domainMapper,
  95.         Helper\RelationProcessor $relationProcessor,
  96.         Helper\NameSchemaService $nameSchemaService,
  97.         Helper\FieldTypeRegistry $fieldTypeRegistry,
  98.         array $settings = []
  99.     ) {
  100.         $this->repository = $repository;
  101.         $this->persistenceHandler = $handler;
  102.         $this->domainMapper = $domainMapper;
  103.         $this->relationProcessor = $relationProcessor;
  104.         $this->nameSchemaService = $nameSchemaService;
  105.         $this->fieldTypeRegistry = $fieldTypeRegistry;
  106.         // Union makes sure default settings are ignored if provided in argument
  107.         $this->settings = $settings + [
  108.             // Version archive limit (0-50), only enforced on publish, not on un-publish.
  109.             'default_version_archive_limit' => 5,
  110.         ];
  111.     }
  113.     /**
  114.      * Loads a content info object.
  115.      *
  116.      * To load fields use loadContent
  117.      *
  118.      * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the user is not allowed to read the content
  119.      * @throws \eZ\Publish\API\Repository\Exceptions\NotFoundException - if the content with the given id does not exist
  120.      *
  121.      * @param int $contentId
  122.      *
  123.      * @return \eZ\Publish\API\Repository\Values\Content\ContentInfo
  124.      */
  125.     public function loadContentInfo($contentId)
  126.     {
  127.         $contentInfo = $this->internalLoadContentInfo($contentId);
  128.         if (!$this->repository->canUser('content', 'read', $contentInfo)) {
  129.             throw new UnauthorizedException('content', 'read', ['contentId' => $contentId]);
  130.         }
  132.         return $contentInfo;
  133.     }
  135.     /**
  136.      * {@inheritdoc}
  137.      */
  138.     public function loadContentInfoList(array $contentIds): iterable
  139.     {
  140.         $contentInfoList = [];
  141.         $spiInfoList = $this->persistenceHandler->contentHandler()->loadContentInfoList($contentIds);
  142.         foreach ($spiInfoList as $id => $spiInfo) {
  143.             $contentInfo = $this->domainMapper->buildContentInfoDomainObject($spiInfo);
  144.             if ($this->repository->canUser('content', 'read', $contentInfo)) {
  145.                 $contentInfoList[$id] = $contentInfo;
  146.             }
  147.         }
  149.         return $contentInfoList;
  150.     }
  152.     /**
  153.      * Loads a content info object.
  154.      *
  155.      * To load fields use loadContent
  156.      *
  157.      * @throws \eZ\Publish\API\Repository\Exceptions\NotFoundException - if the content with the given id does not exist
  158.      *
  159.      * @param mixed $id
  160.      * @param bool $isRemoteId
  161.      *
  162.      * @return \eZ\Publish\API\Repository\Values\Content\ContentInfo
  163.      */
  164.     public function internalLoadContentInfo($id, $isRemoteId = false)
  165.     {
  166.         try {
  167.             $method = $isRemoteId ? 'loadContentInfoByRemoteId' : 'loadContentInfo';
  169.             return $this->domainMapper->buildContentInfoDomainObject(
  170.                 $this->persistenceHandler->contentHandler()->$method($id)
  171.             );
  172.         } catch (APINotFoundException $e) {
  173.             throw new NotFoundException(
  174.                 'Content',
  175.                 $id,
  176.                 $e
  177.             );
  178.         }
  179.     }
  181.     /**
  182.      * Loads a content info object for the given remoteId.
  183.      *
  184.      * To load fields use loadContent
  185.      *
  186.      * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the user is not allowed to read the content
  187.      * @throws \eZ\Publish\API\Repository\Exceptions\NotFoundException - if the content with the given remote id does not exist
  188.      *
  189.      * @param string $remoteId
  190.      *
  191.      * @return \eZ\Publish\API\Repository\Values\Content\ContentInfo
  192.      */
  193.     public function loadContentInfoByRemoteId($remoteId)
  194.     {
  195.         $contentInfo = $this->internalLoadContentInfo($remoteId, true);
  197.         if (!$this->repository->canUser('content', 'read', $contentInfo)) {
  198.             throw new UnauthorizedException('content', 'read', ['remoteId' => $remoteId]);
  199.         }
  201.         return $contentInfo;
  202.     }
  204.     /**
  205.      * Loads a version info of the given content object.
  206.      *
  207.      * If no version number is given, the method returns the current version
  208.      *
  209.      * @throws \eZ\Publish\API\Repository\Exceptions\NotFoundException - if the version with the given number does not exist
  210.      * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the user is not allowed to load this version
  211.      *
  212.      * @param \eZ\Publish\API\Repository\Values\Content\ContentInfo $contentInfo
  213.      * @param int $versionNo the version number. If not given the current version is returned.
  214.      *
  215.      * @return \eZ\Publish\API\Repository\Values\Content\VersionInfo
  216.      */
  217.     public function loadVersionInfo(ContentInfo $contentInfo, $versionNo = null)
  218.     {
  219.         return $this->loadVersionInfoById($contentInfo->id, $versionNo);
  220.     }
  222.     /**
  223.      * Loads a version info of the given content object id.
  224.      *
  225.      * If no version number is given, the method returns the current version
  226.      *
  227.      * @throws \eZ\Publish\API\Repository\Exceptions\NotFoundException - if the version with the given number does not exist
  228.      * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the user is not allowed to load this version
  229.      *
  230.      * @param mixed $contentId
  231.      * @param int $versionNo the version number. If not given the current version is returned.
  232.      *
  233.      * @return \eZ\Publish\API\Repository\Values\Content\VersionInfo
  234.      */
  235.     public function loadVersionInfoById($contentId, $versionNo = null)
  236.     {
  237.         try {
  238.             $spiVersionInfo = $this->persistenceHandler->contentHandler()->loadVersionInfo(
  239.                 $contentId,
  240.                 $versionNo
  241.             );
  242.         } catch (APINotFoundException $e) {
  243.             throw new NotFoundException(
  244.                 'VersionInfo',
  245.                 [
  246.                     'contentId' => $contentId,
  247.                     'versionNo' => $versionNo,
  248.                 ],
  249.                 $e
  250.             );
  251.         }
  253.         $versionInfo = $this->domainMapper->buildVersionInfoDomainObject($spiVersionInfo);
  255.         if ($versionInfo->isPublished()) {
  256.             $function = 'read';
  257.         } else {
  258.             $function = 'versionread';
  259.         }
  261.         if (!$this->repository->canUser('content', $function, $versionInfo)) {
  262.             throw new UnauthorizedException('content', $function, ['contentId' => $contentId]);
  263.         }
  265.         return $versionInfo;
  266.     }
  268.     /**
  269.      * {@inheritdoc}
  270.      */
  271.     public function loadContentByContentInfo(ContentInfo $contentInfo, array $languages = null, $versionNo = null, $useAlwaysAvailable = true)
  272.     {
  273.         // Change $useAlwaysAvailable to false to avoid contentInfo lookup if we know alwaysAvailable is disabled
  274.         if ($useAlwaysAvailable && !$contentInfo->alwaysAvailable) {
  275.             $useAlwaysAvailable = false;
  276.         }
  278.         return $this->loadContent(
  279.             $contentInfo->id,
  280.             $languages,
  281.             $versionNo,// On purpose pass as-is and not use $contentInfo, to make sure to return actual current version on null
  282.             $useAlwaysAvailable
  283.         );
  284.     }
  286.     /**
  287.      * {@inheritdoc}
  288.      */
  289.     public function loadContentByVersionInfo(APIVersionInfo $versionInfo, array $languages = null, $useAlwaysAvailable = true)
  290.     {
  291.         // Change $useAlwaysAvailable to false to avoid contentInfo lookup if we know alwaysAvailable is disabled
  292.         if ($useAlwaysAvailable && !$versionInfo->getContentInfo()->alwaysAvailable) {
  293.             $useAlwaysAvailable = false;
  294.         }
  296.         return $this->loadContent(
  297.             $versionInfo->getContentInfo()->id,
  298.             $languages,
  299.             $versionInfo->versionNo,
  300.             $useAlwaysAvailable
  301.         );
  302.     }
  304.     /**
  305.      * {@inheritdoc}
  306.      */
  307.     public function loadContent($contentId, array $languages = null, $versionNo = null, $useAlwaysAvailable = true)
  308.     {
  309.         $content = $this->internalLoadContent($contentId, $languages, $versionNo, false, $useAlwaysAvailable);
  311.         if (!$this->repository->canUser('content', 'read', $content)) {
  312.             throw new UnauthorizedException('content', 'read', ['contentId' => $contentId]);
  313.         }
  314.         if (
  315.             !$content->getVersionInfo()->isPublished()
  316.             && !$this->repository->canUser('content', 'versionread', $content)
  317.         ) {
  318.             throw new UnauthorizedException('content', 'versionread', ['contentId' => $contentId, 'versionNo' => $versionNo]);
  319.         }
  321.         return $content;
  322.     }
  324.     /**
  325.      * Loads content in a version of the given content object.
  326.      *
  327.      * If no version number is given, the method returns the current version
  328.      *
  329.      * @internal
  330.      *
  331.      * @throws \eZ\Publish\API\Repository\Exceptions\NotFoundException if the content or version with the given id and languages does not exist
  332.      *
  333.      * @param mixed $id
  334.      * @param array|null $languages A language priority, filters returned fields and is used as prioritized language code on
  335.      *                         returned value object. If not given all languages are returned.
  336.      * @param int|null $versionNo the version number. If not given the current version is returned
  337.      * @param bool $isRemoteId
  338.      * @param bool $useAlwaysAvailable Add Main language to \$languages if true (default) and if alwaysAvailable is true
  339.      *
  340.      * @return \eZ\Publish\API\Repository\Values\Content\Content
  341.      */
  342.     public function internalLoadContent($id, array $languages = null, $versionNo = null, $isRemoteId = false, $useAlwaysAvailable = true)
  343.     {
  344.         try {
  345.             // Get Content ID if lookup by remote ID
  346.             if ($isRemoteId) {
  347.                 $spiContentInfo = $this->persistenceHandler->contentHandler()->loadContentInfoByRemoteId($id);
  348.                 $id = $spiContentInfo->id;
  349.                 // Set $isRemoteId to false as the next loads will be for content id now that we have it (for exception use now)
  350.                 $isRemoteId = false;
  351.             }
  353.             $loadLanguages = $languages;
  354.             $alwaysAvailableLanguageCode = null;
  355.             // Set main language on $languages filter if not empty (all) and $useAlwaysAvailable being true
  356.             // @todo Move use always available logic to SPI load methods, like done in location handler in 7.x
  357.             if (!empty($loadLanguages) && $useAlwaysAvailable) {
  358.                 if (!isset($spiContentInfo)) {
  359.                     $spiContentInfo = $this->persistenceHandler->contentHandler()->loadContentInfo($id);
  360.                 }
  362.                 if ($spiContentInfo->alwaysAvailable) {
  363.                     $loadLanguages[] = $alwaysAvailableLanguageCode = $spiContentInfo->mainLanguageCode;
  364.                     $loadLanguages = array_unique($loadLanguages);
  365.                 }
  366.             }
  368.             $spiContent = $this->persistenceHandler->contentHandler()->load(
  369.                 $id,
  370.                 $versionNo,
  371.                 $loadLanguages
  372.             );
  373.         } catch (APINotFoundException $e) {
  374.             throw new NotFoundException(
  375.                 'Content',
  376.                 [
  377.                     $isRemoteId ? 'remoteId' : 'id' => $id,
  378.                     'languages' => $languages,
  379.                     'versionNo' => $versionNo,
  380.                 ],
  381.                 $e
  382.             );
  383.         }
  385.         if ($languages === null) {
  386.             $languages = [];
  387.         }
  389.         return $this->domainMapper->buildContentDomainObject(
  390.             $spiContent,
  391.             $this->repository->getContentTypeService()->loadContentType(
  392.                 $spiContent->versionInfo->contentInfo->contentTypeId,
  393.                 $languages
  394.             ),
  395.             $languages,
  396.             $alwaysAvailableLanguageCode
  397.         );
  398.     }
  400.     /**
  401.      * Loads content in a version for the content object reference by the given remote id.
  402.      *
  403.      * If no version is given, the method returns the current version
  404.      *
  405.      * @throws \eZ\Publish\API\Repository\Exceptions\NotFoundException - if the content or version with the given remote id does not exist
  406.      * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException If the user has no access to read content and in case of un-published content: read versions
  407.      *
  408.      * @param string $remoteId
  409.      * @param array $languages A language filter for fields. If not given all languages are returned
  410.      * @param int $versionNo the version number. If not given the current version is returned
  411.      * @param bool $useAlwaysAvailable Add Main language to \$languages if true (default) and if alwaysAvailable is true
  412.      *
  413.      * @return \eZ\Publish\API\Repository\Values\Content\Content
  414.      */
  415.     public function loadContentByRemoteId($remoteId, array $languages = null, $versionNo = null, $useAlwaysAvailable = true)
  416.     {
  417.         $content = $this->internalLoadContent($remoteId, $languages, $versionNo, true, $useAlwaysAvailable);
  419.         if (!$this->repository->canUser('content', 'read', $content)) {
  420.             throw new UnauthorizedException('content', 'read', ['remoteId' => $remoteId]);
  421.         }
  423.         if (
  424.             !$content->getVersionInfo()->isPublished()
  425.             && !$this->repository->canUser('content', 'versionread', $content)
  426.         ) {
  427.             throw new UnauthorizedException('content', 'versionread', ['remoteId' => $remoteId, 'versionNo' => $versionNo]);
  428.         }
  430.         return $content;
  431.     }
  433.     /**
  434.      * Bulk-load Content items by the list of ContentInfo Value Objects.
  435.      *
  436.      * Note: it does not throw exceptions on load, just ignores erroneous Content item.
  437.      * Moreover, since the method works on pre-loaded ContentInfo list, it is assumed that user is
  438.      * allowed to access every Content on the list.
  439.      *
  440.      * @param \eZ\Publish\API\Repository\Values\Content\ContentInfo[] $contentInfoList
  441.      * @param string[] $languages A language priority, filters returned fields and is used as prioritized language code on
  442.      *                            returned value object. If not given all languages are returned.
  443.      * @param bool $useAlwaysAvailable Add Main language to \$languages if true (default) and if alwaysAvailable is true,
  444.      *                                 unless all languages have been asked for.
  445.      *
  446.      * @return \eZ\Publish\API\Repository\Values\Content\Content[] list of Content items with Content Ids as keys
  447.      */
  448.     public function loadContentListByContentInfo(
  449.         array $contentInfoList,
  450.         array $languages = [],
  451.         $useAlwaysAvailable = true
  452.     ) {
  453.         $loadAllLanguages = $languages === Language::ALL;
  454.         $contentIds = [];
  455.         $contentTypeIds = [];
  456.         $translations = $languages;
  457.         foreach ($contentInfoList as $contentInfo) {
  458.             $contentIds[] = $contentInfo->id;
  459.             $contentTypeIds[] = $contentInfo->contentTypeId;
  460.             // Unless we are told to load all languages, we add main language to translations so they are loaded too
  461.             // Might in some case load more languages then intended, but prioritised handling will pick right one
  462.             if (!$loadAllLanguages && $useAlwaysAvailable && $contentInfo->alwaysAvailable) {
  463.                 $translations[] = $contentInfo->mainLanguageCode;
  464.             }
  465.         }
  467.         $contentList = [];
  468.         $translations = array_unique($translations);
  469.         $spiContentList = $this->persistenceHandler->contentHandler()->loadContentList(
  470.             $contentIds,
  471.             $translations
  472.         );
  473.         $contentTypeList = $this->repository->getContentTypeService()->loadContentTypeList(
  474.             array_unique($contentTypeIds),
  475.             $languages
  476.         );
  477.         foreach ($spiContentList as $contentId => $spiContent) {
  478.             $contentInfo = $spiContent->versionInfo->contentInfo;
  479.             $contentList[$contentId] = $this->domainMapper->buildContentDomainObject(
  480.                 $spiContent,
  481.                 $contentTypeList[$contentInfo->contentTypeId],
  482.                 $languages,
  483.                 $contentInfo->alwaysAvailable ? $contentInfo->mainLanguageCode : null
  484.             );
  485.         }
  487.         return $contentList;
  488.     }
  490.     /**
  491.      * Creates a new content draft assigned to the authenticated user.
  492.      *
  493.      * If a different userId is given in $contentCreateStruct it is assigned to the given user
  494.      * but this required special rights for the authenticated user
  495.      * (this is useful for content staging where the transfer process does not
  496.      * have to authenticate with the user which created the content object in the source server).
  497.      * The user has to publish the draft if it should be visible.
  498.      * In 4.x at least one location has to be provided in the location creation array.
  499.      *
  500.      * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the user is not allowed to create the content in the given location
  501.      * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException if the provided remoteId exists in the system, required properties on
  502.      *                                                                        struct are missing or invalid, or if multiple locations are under the
  503.      *                                                                        same parent.
  504.      * @throws \eZ\Publish\API\Repository\Exceptions\ContentFieldValidationException if a field in the $contentCreateStruct is not valid,
  505.      *                                                                               or if a required field is missing / set to an empty value.
  506.      * @throws \eZ\Publish\API\Repository\Exceptions\ContentValidationException If field definition does not exist in the ContentType,
  507.      *                                                                          or value is set for non-translatable field in language
  508.      *                                                                          other than main.
  509.      *
  510.      * @param \eZ\Publish\API\Repository\Values\Content\ContentCreateStruct $contentCreateStruct
  511.      * @param \eZ\Publish\API\Repository\Values\Content\LocationCreateStruct[] $locationCreateStructs For each location parent under which a location should be created for the content
  512.      *
  513.      * @return \eZ\Publish\API\Repository\Values\Content\Content - the newly created content draft
  514.      */
  515.     public function createContent(APIContentCreateStruct $contentCreateStruct, array $locationCreateStructs = [])
  516.     {
  517.         if ($contentCreateStruct->mainLanguageCode === null) {
  518.             throw new InvalidArgumentException('$contentCreateStruct', "'mainLanguageCode' property must be set");
  519.         }
  521.         if ($contentCreateStruct->contentType === null) {
  522.             throw new InvalidArgumentException('$contentCreateStruct', "'contentType' property must be set");
  523.         }
  525.         $contentCreateStruct = clone $contentCreateStruct;
  527.         if ($contentCreateStruct->ownerId === null) {
  528.             $contentCreateStruct->ownerId = $this->repository->getCurrentUserReference()->getUserId();
  529.         }
  531.         if ($contentCreateStruct->alwaysAvailable === null) {
  532.             $contentCreateStruct->alwaysAvailable = $contentCreateStruct->contentType->defaultAlwaysAvailable ?: false;
  533.         }
  535.         $contentCreateStruct->contentType = $this->repository->getContentTypeService()->loadContentType(
  536.             $contentCreateStruct->contentType->id
  537.         );
  539.         if (empty($contentCreateStruct->sectionId)) {
  540.             if (isset($locationCreateStructs[0])) {
  541.                 $location = $this->repository->getLocationService()->loadLocation(
  542.                     $locationCreateStructs[0]->parentLocationId
  543.                 );
  544.                 $contentCreateStruct->sectionId = $location->contentInfo->sectionId;
  545.             } else {
  546.                 $contentCreateStruct->sectionId = 1;
  547.             }
  548.         }
  550.         if (!$this->repository->canUser('content', 'create', $contentCreateStruct, $locationCreateStructs)) {
  551.             throw new UnauthorizedException(
  552.                 'content',
  553.                 'create',
  554.                 [
  555.                     'parentLocationId' => isset($locationCreateStructs[0]) ?
  556.                             $locationCreateStructs[0]->parentLocationId :
  557.                             null,
  558.                     'sectionId' => $contentCreateStruct->sectionId,
  559.                 ]
  560.             );
  561.         }
  563.         if (!empty($contentCreateStruct->remoteId)) {
  564.             try {
  565.                 $this->loadContentByRemoteId($contentCreateStruct->remoteId);
  567.                 throw new InvalidArgumentException(
  568.                     '$contentCreateStruct',
  569.                     "Another content with remoteId '{$contentCreateStruct->remoteId}' exists"
  570.                 );
  571.             } catch (APINotFoundException $e) {
  572.                 // Do nothing
  573.             }
  574.         } else {
  575.             $contentCreateStruct->remoteId = $this->domainMapper->getUniqueHash($contentCreateStruct);
  576.         }
  578.         $spiLocationCreateStructs = $this->buildSPILocationCreateStructs($locationCreateStructs);
  580.         $languageCodes = $this->getLanguageCodesForCreate($contentCreateStruct);
  581.         $fields = $this->mapFieldsForCreate($contentCreateStruct);
  583.         $fieldValues = [];
  584.         $spiFields = [];
  585.         $allFieldErrors = [];
  586.         $inputRelations = [];
  587.         $locationIdToContentIdMapping = [];
  589.         foreach ($contentCreateStruct->contentType->getFieldDefinitions() as $fieldDefinition) {
  590.             /** @var $fieldType \eZ\Publish\Core\FieldType\FieldType */
  591.             $fieldType = $this->fieldTypeRegistry->getFieldType(
  592.                 $fieldDefinition->fieldTypeIdentifier
  593.             );
  595.             foreach ($languageCodes as $languageCode) {
  596.                 $isEmptyValue = false;
  597.                 $valueLanguageCode = $fieldDefinition->isTranslatable ? $languageCode : $contentCreateStruct->mainLanguageCode;
  598.                 $isLanguageMain = $languageCode === $contentCreateStruct->mainLanguageCode;
  599.                 if (isset($fields[$fieldDefinition->identifier][$valueLanguageCode])) {
  600.                     $fieldValue = $fields[$fieldDefinition->identifier][$valueLanguageCode]->value;
  601.                 } else {
  602.                     $fieldValue = $fieldDefinition->defaultValue;
  603.                 }
  605.                 $fieldValue = $fieldType->acceptValue($fieldValue);
  607.                 if ($fieldType->isEmptyValue($fieldValue)) {
  608.                     $isEmptyValue = true;
  609.                     if ($fieldDefinition->isRequired) {
  610.                         $allFieldErrors[$fieldDefinition->id][$languageCode] = new ValidationError(
  611.                             "Value for required field definition '%identifier%' with language '%languageCode%' is empty",
  612.                             null,
  613.                             ['%identifier%' => $fieldDefinition->identifier, '%languageCode%' => $languageCode],
  614.                             'empty'
  615.                         );
  616.                     }
  617.                 } else {
  618.                     $fieldErrors = $fieldType->validate(
  619.                         $fieldDefinition,
  620.                         $fieldValue
  621.                     );
  622.                     if (!empty($fieldErrors)) {
  623.                         $allFieldErrors[$fieldDefinition->id][$languageCode] = $fieldErrors;
  624.                     }
  625.                 }
  627.                 if (!empty($allFieldErrors)) {
  628.                     continue;
  629.                 }
  631.                 $this->relationProcessor->appendFieldRelations(
  632.                     $inputRelations,
  633.                     $locationIdToContentIdMapping,
  634.                     $fieldType,
  635.                     $fieldValue,
  636.                     $fieldDefinition->id
  637.                 );
  638.                 $fieldValues[$fieldDefinition->identifier][$languageCode] = $fieldValue;
  640.                 // Only non-empty value for: translatable field or in main language
  641.                 if (
  642.                     (!$isEmptyValue && $fieldDefinition->isTranslatable) ||
  643.                     (!$isEmptyValue && $isLanguageMain)
  644.                 ) {
  645.                     $spiFields[] = new SPIField(
  646.                         [
  647.                             'id' => null,
  648.                             'fieldDefinitionId' => $fieldDefinition->id,
  649.                             'type' => $fieldDefinition->fieldTypeIdentifier,
  650.                             'value' => $fieldType->toPersistenceValue($fieldValue),
  651.                             'languageCode' => $languageCode,
  652.                             'versionNo' => null,
  653.                         ]
  654.                     );
  655.                 }
  656.             }
  657.         }
  659.         if (!empty($allFieldErrors)) {
  660.             throw new ContentFieldValidationException($allFieldErrors);
  661.         }
  663.         $spiContentCreateStruct = new SPIContentCreateStruct(
  664.             [
  665.                 'name' => $this->nameSchemaService->resolve(
  666.                     $contentCreateStruct->contentType->nameSchema,
  667.                     $contentCreateStruct->contentType,
  668.                     $fieldValues,
  669.                     $languageCodes
  670.                 ),
  671.                 'typeId' => $contentCreateStruct->contentType->id,
  672.                 'sectionId' => $contentCreateStruct->sectionId,
  673.                 'ownerId' => $contentCreateStruct->ownerId,
  674.                 'locations' => $spiLocationCreateStructs,
  675.                 'fields' => $spiFields,
  676.                 'alwaysAvailable' => $contentCreateStruct->alwaysAvailable,
  677.                 'remoteId' => $contentCreateStruct->remoteId,
  678.                 'modified' => isset($contentCreateStruct->modificationDate) ? $contentCreateStruct->modificationDate->getTimestamp() : time(),
  679.                 'initialLanguageId' => $this->persistenceHandler->contentLanguageHandler()->loadByLanguageCode(
  680.                     $contentCreateStruct->mainLanguageCode
  681.                 )->id,
  682.             ]
  683.         );
  685.         $defaultObjectStates = $this->getDefaultObjectStates();
  687.         $this->repository->beginTransaction();
  688.         try {
  689.             $spiContent = $this->persistenceHandler->contentHandler()->create($spiContentCreateStruct);
  690.             $this->relationProcessor->processFieldRelations(
  691.                 $inputRelations,
  692.                 $spiContent->versionInfo->contentInfo->id,
  693.                 $spiContent->versionInfo->versionNo,
  694.                 $contentCreateStruct->contentType
  695.             );
  697.             $objectStateHandler = $this->persistenceHandler->objectStateHandler();
  698.             foreach ($defaultObjectStates as $objectStateGroupId => $objectState) {
  699.                 $objectStateHandler->setContentState(
  700.                     $spiContent->versionInfo->contentInfo->id,
  701.                     $objectStateGroupId,
  702.                     $objectState->id
  703.                 );
  704.             }
  706.             $this->repository->commit();
  707.         } catch (Exception $e) {
  708.             $this->repository->rollback();
  709.             throw $e;
  710.         }
  712.         return $this->domainMapper->buildContentDomainObject(
  713.             $spiContent,
  714.             $contentCreateStruct->contentType
  715.         );
  716.     }
  718.     /**
  719.      * Returns an array of default content states with content state group id as key.
  720.      *
  721.      * @return \eZ\Publish\SPI\Persistence\Content\ObjectState[]
  722.      */
  723.     protected function getDefaultObjectStates()
  724.     {
  725.         $defaultObjectStatesMap = [];
  726.         $objectStateHandler = $this->persistenceHandler->objectStateHandler();
  728.         foreach ($objectStateHandler->loadAllGroups() as $objectStateGroup) {
  729.             foreach ($objectStateHandler->loadObjectStates($objectStateGroup->id) as $objectState) {
  730.                 // Only register the first object state which is the default one.
  731.                 $defaultObjectStatesMap[$objectStateGroup->id] = $objectState;
  732.                 break;
  733.             }
  734.         }
  736.         return $defaultObjectStatesMap;
  737.     }
  739.     /**
  740.      * Returns all language codes used in given $fields.
  741.      *
  742.      * @throws \eZ\Publish\API\Repository\Exceptions\ContentValidationException if no field value is set in main language
  743.      *
  744.      * @param \eZ\Publish\API\Repository\Values\Content\ContentCreateStruct $contentCreateStruct
  745.      *
  746.      * @return string[]
  747.      */
  748.     protected function getLanguageCodesForCreate(APIContentCreateStruct $contentCreateStruct)
  749.     {
  750.         $languageCodes = [];
  752.         foreach ($contentCreateStruct->fields as $field) {
  753.             if ($field->languageCode === null || isset($languageCodes[$field->languageCode])) {
  754.                 continue;
  755.             }
  757.             $this->persistenceHandler->contentLanguageHandler()->loadByLanguageCode(
  758.                 $field->languageCode
  759.             );
  760.             $languageCodes[$field->languageCode] = true;
  761.         }
  763.         if (!isset($languageCodes[$contentCreateStruct->mainLanguageCode])) {
  764.             $this->persistenceHandler->contentLanguageHandler()->loadByLanguageCode(
  765.                 $contentCreateStruct->mainLanguageCode
  766.             );
  767.             $languageCodes[$contentCreateStruct->mainLanguageCode] = true;
  768.         }
  770.         return array_keys($languageCodes);
  771.     }
  773.     /**
  774.      * Returns an array of fields like $fields[$field->fieldDefIdentifier][$field->languageCode].
  775.      *
  776.      * @throws \eZ\Publish\API\Repository\Exceptions\ContentValidationException If field definition does not exist in the ContentType
  777.      *                                                                          or value is set for non-translatable field in language
  778.      *                                                                          other than main
  779.      *
  780.      * @param \eZ\Publish\API\Repository\Values\Content\ContentCreateStruct $contentCreateStruct
  781.      *
  782.      * @return array
  783.      */
  784.     protected function mapFieldsForCreate(APIContentCreateStruct $contentCreateStruct)
  785.     {
  786.         $fields = [];
  788.         foreach ($contentCreateStruct->fields as $field) {
  789.             $fieldDefinition = $contentCreateStruct->contentType->getFieldDefinition($field->fieldDefIdentifier);
  791.             if ($fieldDefinition === null) {
  792.                 throw new ContentValidationException(
  793.                     "Field definition '%identifier%' does not exist in given ContentType",
  794.                     ['%identifier%' => $field->fieldDefIdentifier]
  795.                 );
  796.             }
  798.             if ($field->languageCode === null) {
  799.                 $field = $this->cloneField(
  800.                     $field,
  801.                     ['languageCode' => $contentCreateStruct->mainLanguageCode]
  802.                 );
  803.             }
  805.             if (!$fieldDefinition->isTranslatable && ($field->languageCode != $contentCreateStruct->mainLanguageCode)) {
  806.                 throw new ContentValidationException(
  807.                     "A value is set for non translatable field definition '%identifier%' with language '%languageCode%'",
  808.                     ['%identifier%' => $field->fieldDefIdentifier, '%languageCode%' => $field->languageCode]
  809.                 );
  810.             }
  812.             $fields[$field->fieldDefIdentifier][$field->languageCode] = $field;
  813.         }
  815.         return $fields;
  816.     }
  818.     /**
  819.      * Clones $field with overriding specific properties from given $overrides array.
  820.      *
  821.      * @param Field $field
  822.      * @param array $overrides
  823.      *
  824.      * @return Field
  825.      */
  826.     private function cloneField(Field $field, array $overrides = [])
  827.     {
  828.         $fieldData = array_merge(
  829.             [
  830.                 'id' => $field->id,
  831.                 'value' => $field->value,
  832.                 'languageCode' => $field->languageCode,
  833.                 'fieldDefIdentifier' => $field->fieldDefIdentifier,
  834.                 'fieldTypeIdentifier' => $field->fieldTypeIdentifier,
  835.             ],
  836.             $overrides
  837.         );
  839.         return new Field($fieldData);
  840.     }
  842.     /**
  843.      * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException
  844.      *
  845.      * @param \eZ\Publish\API\Repository\Values\Content\LocationCreateStruct[] $locationCreateStructs
  846.      *
  847.      * @return \eZ\Publish\SPI\Persistence\Content\Location\CreateStruct[]
  848.      */
  849.     protected function buildSPILocationCreateStructs(array $locationCreateStructs)
  850.     {
  851.         $spiLocationCreateStructs = [];
  852.         $parentLocationIdSet = [];
  853.         $mainLocation = true;
  855.         foreach ($locationCreateStructs as $locationCreateStruct) {
  856.             if (isset($parentLocationIdSet[$locationCreateStruct->parentLocationId])) {
  857.                 throw new InvalidArgumentException(
  858.                     '$locationCreateStructs',
  859.                     "Multiple LocationCreateStructs with the same parent Location '{$locationCreateStruct->parentLocationId}' are given"
  860.                 );
  861.             }
  863.             if (!array_key_exists($locationCreateStruct->sortField, Location::SORT_FIELD_MAP)) {
  864.                 $locationCreateStruct->sortField = Location::SORT_FIELD_NAME;
  865.             }
  867.             if (!array_key_exists($locationCreateStruct->sortOrder, Location::SORT_ORDER_MAP)) {
  868.                 $locationCreateStruct->sortOrder = Location::SORT_ORDER_ASC;
  869.             }
  871.             $parentLocationIdSet[$locationCreateStruct->parentLocationId] = true;
  872.             $parentLocation = $this->repository->getLocationService()->loadLocation(
  873.                 $locationCreateStruct->parentLocationId
  874.             );
  876.             $spiLocationCreateStructs[] = $this->domainMapper->buildSPILocationCreateStruct(
  877.                 $locationCreateStruct,
  878.                 $parentLocation,
  879.                 $mainLocation,
  880.                 // For Content draft contentId and contentVersionNo are set in ContentHandler upon draft creation
  881.                 null,
  882.                 null
  883.             );
  885.             // First Location in the list will be created as main Location
  886.             $mainLocation = false;
  887.         }
  889.         return $spiLocationCreateStructs;
  890.     }
  892.     /**
  893.      * Updates the metadata.
  894.      *
  895.      * (see {@link ContentMetadataUpdateStruct}) of a content object - to update fields use updateContent
  896.      *
  897.      * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the user is not allowed to update the content meta data
  898.      * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException if the remoteId in $contentMetadataUpdateStruct is set but already exists
  899.      *
  900.      * @param \eZ\Publish\API\Repository\Values\Content\ContentInfo $contentInfo
  901.      * @param \eZ\Publish\API\Repository\Values\Content\ContentMetadataUpdateStruct $contentMetadataUpdateStruct
  902.      *
  903.      * @return \eZ\Publish\API\Repository\Values\Content\Content the content with the updated attributes
  904.      */
  905.     public function updateContentMetadata(ContentInfo $contentInfo, ContentMetadataUpdateStruct $contentMetadataUpdateStruct)
  906.     {
  907.         $propertyCount = 0;
  908.         foreach ($contentMetadataUpdateStruct as $propertyName => $propertyValue) {
  909.             if (isset($contentMetadataUpdateStruct->$propertyName)) {
  910.                 ++$propertyCount;
  911.             }
  912.         }
  913.         if ($propertyCount === 0) {
  914.             throw new InvalidArgumentException(
  915.                 '$contentMetadataUpdateStruct',
  916.                 'At least one property must be set'
  917.             );
  918.         }
  920.         $loadedContentInfo = $this->loadContentInfo($contentInfo->id);
  922.         if (!$this->repository->canUser('content', 'edit', $loadedContentInfo)) {
  923.             throw new UnauthorizedException('content', 'edit', ['contentId' => $loadedContentInfo->id]);
  924.         }
  926.         if (isset($contentMetadataUpdateStruct->remoteId)) {
  927.             try {
  928.                 $existingContentInfo = $this->loadContentInfoByRemoteId($contentMetadataUpdateStruct->remoteId);
  930.                 if ($existingContentInfo->id !== $loadedContentInfo->id) {
  931.                     throw new InvalidArgumentException(
  932.                         '$contentMetadataUpdateStruct',
  933.                         "Another content with remoteId '{$contentMetadataUpdateStruct->remoteId}' exists"
  934.                     );
  935.                 }
  936.             } catch (APINotFoundException $e) {
  937.                 // Do nothing
  938.             }
  939.         }
  941.         $this->repository->beginTransaction();
  942.         try {
  943.             if ($propertyCount > 1 || !isset($contentMetadataUpdateStruct->mainLocationId)) {
  944.                 $this->persistenceHandler->contentHandler()->updateMetadata(
  945.                     $loadedContentInfo->id,
  946.                     new SPIMetadataUpdateStruct(
  947.                         [
  948.                             'ownerId' => $contentMetadataUpdateStruct->ownerId,
  949.                             'publicationDate' => isset($contentMetadataUpdateStruct->publishedDate) ?
  950.                                 $contentMetadataUpdateStruct->publishedDate->getTimestamp() :
  951.                                 null,
  952.                             'modificationDate' => isset($contentMetadataUpdateStruct->modificationDate) ?
  953.                                 $contentMetadataUpdateStruct->modificationDate->getTimestamp() :
  954.                                 null,
  955.                             'mainLanguageId' => isset($contentMetadataUpdateStruct->mainLanguageCode) ?
  956.                                 $this->repository->getContentLanguageService()->loadLanguage(
  957.                                     $contentMetadataUpdateStruct->mainLanguageCode
  958.                                 )->id :
  959.                                 null,
  960.                             'alwaysAvailable' => $contentMetadataUpdateStruct->alwaysAvailable,
  961.                             'remoteId' => $contentMetadataUpdateStruct->remoteId,
  962.                             'name' => $contentMetadataUpdateStruct->name,
  963.                         ]
  964.                     )
  965.                 );
  966.             }
  968.             // Change main location
  969.             if (isset($contentMetadataUpdateStruct->mainLocationId)
  970.                 && $loadedContentInfo->mainLocationId !== $contentMetadataUpdateStruct->mainLocationId) {
  971.                 $this->persistenceHandler->locationHandler()->changeMainLocation(
  972.                     $loadedContentInfo->id,
  973.                     $contentMetadataUpdateStruct->mainLocationId
  974.                 );
  975.             }
  977.             // Republish URL aliases to update always-available flag
  978.             if (isset($contentMetadataUpdateStruct->alwaysAvailable)
  979.                 && $loadedContentInfo->alwaysAvailable !== $contentMetadataUpdateStruct->alwaysAvailable) {
  980.                 $content = $this->loadContent($loadedContentInfo->id);
  981.                 $this->publishUrlAliasesForContent($content, false);
  982.             }
  984.             $this->repository->commit();
  985.         } catch (Exception $e) {
  986.             $this->repository->rollback();
  987.             throw $e;
  988.         }
  990.         return isset($content) ? $content : $this->loadContent($loadedContentInfo->id);
  991.     }
  993.     /**
  994.      * Publishes URL aliases for all locations of a given content.
  995.      *
  996.      * @param \eZ\Publish\API\Repository\Values\Content\Content $content
  997.      * @param bool $updatePathIdentificationString this parameter is legacy storage specific for updating
  998.      *                      ezcontentobject_tree.path_identification_string, it is ignored by other storage engines
  999.      */
  1000.     protected function publishUrlAliasesForContent(APIContent $content, $updatePathIdentificationString = true)
  1001.     {
  1002.         $urlAliasNames = $this->nameSchemaService->resolveUrlAliasSchema($content);
  1003.         $locations = $this->repository->getLocationService()->loadLocations(
  1004.             $content->getVersionInfo()->getContentInfo()
  1005.         );
  1006.         $urlAliasHandler = $this->persistenceHandler->urlAliasHandler();
  1007.         foreach ($locations as $location) {
  1008.             foreach ($urlAliasNames as $languageCode => $name) {
  1009.                 $urlAliasHandler->publishUrlAliasForLocation(
  1010.                     $location->id,
  1011.                     $location->parentLocationId,
  1012.                     $name,
  1013.                     $languageCode,
  1014.                     $content->contentInfo->alwaysAvailable,
  1015.                     $updatePathIdentificationString ? $languageCode === $content->contentInfo->mainLanguageCode : false
  1016.                 );
  1017.             }
  1018.             // archive URL aliases of Translations that got deleted
  1019.             $urlAliasHandler->archiveUrlAliasesForDeletedTranslations(
  1020.                 $location->id,
  1021.                 $location->parentLocationId,
  1022.                 $content->versionInfo->languageCodes
  1023.             );
  1024.         }
  1025.     }
  1027.     /**
  1028.      * Deletes a content object including all its versions and locations including their subtrees.
  1029.      *
  1030.      * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the user is not allowed to delete the content (in one of the locations of the given content object)
  1031.      *
  1032.      * @param \eZ\Publish\API\Repository\Values\Content\ContentInfo $contentInfo
  1033.      *
  1034.      * @return mixed[] Affected Location Id's
  1035.      */
  1036.     public function deleteContent(ContentInfo $contentInfo)
  1037.     {
  1038.         $contentInfo = $this->internalLoadContentInfo($contentInfo->id);
  1040.         if (!$this->repository->canUser('content', 'remove', $contentInfo)) {
  1041.             throw new UnauthorizedException('content', 'remove', ['contentId' => $contentInfo->id]);
  1042.         }
  1044.         $affectedLocations = [];
  1045.         $this->repository->beginTransaction();
  1046.         try {
  1047.             // Load Locations first as deleting Content also deletes belonging Locations
  1048.             $spiLocations = $this->persistenceHandler->locationHandler()->loadLocationsByContent($contentInfo->id);
  1049.             $this->persistenceHandler->contentHandler()->deleteContent($contentInfo->id);
  1050.             $urlAliasHandler = $this->persistenceHandler->urlAliasHandler();
  1051.             foreach ($spiLocations as $spiLocation) {
  1052.                 $urlAliasHandler->locationDeleted($spiLocation->id);
  1053.                 $affectedLocations[] = $spiLocation->id;
  1054.             }
  1055.             $this->repository->commit();
  1056.         } catch (Exception $e) {
  1057.             $this->repository->rollback();
  1058.             throw $e;
  1059.         }
  1061.         return $affectedLocations;
  1062.     }
  1064.     /**
  1065.      * Creates a draft from a published or archived version.
  1066.      *
  1067.      * If no version is given, the current published version is used.
  1068.      *
  1069.      * @param \eZ\Publish\API\Repository\Values\Content\ContentInfo $contentInfo
  1070.      * @param \eZ\Publish\API\Repository\Values\Content\VersionInfo $versionInfo
  1071.      * @param \eZ\Publish\API\Repository\Values\User\User $creator if set given user is used to create the draft - otherwise the current-user is used
  1072.      * @param \eZ\Publish\API\Repository\Values\Content\Language|null if not set the draft is created with the initialLanguage code of the source version or if not present with the main language.
  1073.      *
  1074.      * @return \eZ\Publish\API\Repository\Values\Content\Content - the newly created content draft
  1075.      *
  1076.      * @throws \eZ\Publish\API\Repository\Exceptions\ForbiddenException
  1077.      * @throws \eZ\Publish\API\Repository\Exceptions\NotFoundException if the current-user is not allowed to create the draft
  1078.      * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the current-user is not allowed to create the draft
  1079.      */
  1080.     public function createContentDraft(
  1081.         ContentInfo $contentInfo,
  1082.         APIVersionInfo $versionInfo = null,
  1083.         User $creator = null,
  1084.         ?Language $language = null
  1085.     ) {
  1086.         $contentInfo = $this->loadContentInfo($contentInfo->id);
  1088.         if ($versionInfo !== null) {
  1089.             // Check that given $contentInfo and $versionInfo belong to the same content
  1090.             if ($versionInfo->getContentInfo()->id != $contentInfo->id) {
  1091.                 throw new InvalidArgumentException(
  1092.                     '$versionInfo',
  1093.                     'VersionInfo does not belong to the same content as given ContentInfo'
  1094.                 );
  1095.             }
  1097.             $versionInfo = $this->loadVersionInfoById($contentInfo->id, $versionInfo->versionNo);
  1099.             switch ($versionInfo->status) {
  1100.                 case VersionInfo::STATUS_PUBLISHED:
  1101.                 case VersionInfo::STATUS_ARCHIVED:
  1102.                     break;
  1104.                 default:
  1105.                     // @todo: throw an exception here, to be defined
  1106.                     throw new BadStateException(
  1107.                         '$versionInfo',
  1108.                         'Draft can not be created from a draft version'
  1109.                     );
  1110.             }
  1112.             $versionNo = $versionInfo->versionNo;
  1113.         } elseif ($contentInfo->published) {
  1114.             $versionNo = $contentInfo->currentVersionNo;
  1115.         } else {
  1116.             // @todo: throw an exception here, to be defined
  1117.             throw new BadStateException(
  1118.                 '$contentInfo',
  1119.                 'Content is not published, draft can be created only from published or archived version'
  1120.             );
  1121.         }
  1123.         if ($creator === null) {
  1124.             $creator = $this->repository->getCurrentUserReference();
  1125.         }
  1127.         $fallbackLanguageCode = $versionInfo->initialLanguageCode ?? $contentInfo->mainLanguageCode;
  1128.         $languageCode = $language->languageCode ?? $fallbackLanguageCode;
  1130.         if (!$this->repository->getPermissionResolver()->canUser(
  1131.             'content',
  1132.             'edit',
  1133.             $contentInfo,
  1134.             [
  1135.                 (new Target\Builder\VersionBuilder())
  1136.                     ->changeStatusTo(APIVersionInfo::STATUS_DRAFT)
  1137.                     ->build(),
  1138.             ]
  1139.         )) {
  1140.             throw new UnauthorizedException(
  1141.                 'content',
  1142.                 'edit',
  1143.                 ['contentId' => $contentInfo->id]
  1144.             );
  1145.         }
  1147.         $this->repository->beginTransaction();
  1148.         try {
  1149.             $spiContent = $this->persistenceHandler->contentHandler()->createDraftFromVersion(
  1150.                 $contentInfo->id,
  1151.                 $versionNo,
  1152.                 $creator->getUserId(),
  1153.                 $languageCode
  1154.             );
  1155.             $this->repository->commit();
  1156.         } catch (Exception $e) {
  1157.             $this->repository->rollback();
  1158.             throw $e;
  1159.         }
  1161.         return $this->domainMapper->buildContentDomainObject(
  1162.             $spiContent,
  1163.             $this->repository->getContentTypeService()->loadContentType(
  1164.                 $spiContent->versionInfo->contentInfo->contentTypeId
  1165.             )
  1166.         );
  1167.     }
  1169.     /**
  1170.      * {@inheritdoc}
  1171.      */
  1172.     public function countContentDrafts(?User $user = null): int
  1173.     {
  1174.         if ($this->repository->hasAccess('content', 'versionread') === false) {
  1175.             return 0;
  1176.         }
  1178.         return $this->persistenceHandler->contentHandler()->countDraftsForUser(
  1179.             $this->resolveUser($user)->getUserId()
  1180.         );
  1181.     }
  1183.     /**
  1184.      * Loads drafts for a user.
  1185.      *
  1186.      * If no user is given the drafts for the authenticated user are returned
  1187.      *
  1188.      * @param \eZ\Publish\API\Repository\Values\User\User|null $user
  1189.      *
  1190.      * @return \eZ\Publish\API\Repository\Values\Content\VersionInfo[] Drafts owned by the given user
  1191.      *
  1192.      * @throws \eZ\Publish\API\Repository\Exceptions\BadStateException
  1193.      * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException
  1194.      * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException
  1195.      */
  1196.     public function loadContentDrafts(User $user = null)
  1197.     {
  1198.         // throw early if user has absolutely no access to versionread
  1199.         if ($this->repository->hasAccess('content', 'versionread') === false) {
  1200.             throw new UnauthorizedException('content', 'versionread');
  1201.         }
  1203.         $spiVersionInfoList = $this->persistenceHandler->contentHandler()->loadDraftsForUser(
  1204.             $this->resolveUser($user)->getUserId()
  1205.         );
  1206.         $versionInfoList = [];
  1207.         foreach ($spiVersionInfoList as $spiVersionInfo) {
  1208.             $versionInfo = $this->domainMapper->buildVersionInfoDomainObject($spiVersionInfo);
  1209.             // @todo: Change this to filter returned drafts by permissions instead of throwing
  1210.             if (!$this->repository->canUser('content', 'versionread', $versionInfo)) {
  1211.                 throw new UnauthorizedException('content', 'versionread', ['contentId' => $versionInfo->contentInfo->id]);
  1212.             }
  1214.             $versionInfoList[] = $versionInfo;
  1215.         }
  1217.         return $versionInfoList;
  1218.     }
  1220.     /**
  1221.      * {@inheritdoc}
  1222.      */
  1223.     public function loadContentDraftList(?User $user = null, int $offset = 0, int $limit = -1): ContentDraftList
  1224.     {
  1225.         $list = new ContentDraftList();
  1226.         if ($this->repository->hasAccess('content', 'versionread') === false) {
  1227.             return $list;
  1228.         }
  1230.         $list->totalCount = $this->persistenceHandler->contentHandler()->countDraftsForUser(
  1231.             $this->resolveUser($user)->getUserId()
  1232.         );
  1233.         if ($list->totalCount > 0) {
  1234.             $spiVersionInfoList = $this->persistenceHandler->contentHandler()->loadDraftListForUser(
  1235.                 $this->resolveUser($user)->getUserId(),
  1236.                 $offset,
  1237.                 $limit
  1238.             );
  1239.             foreach ($spiVersionInfoList as $spiVersionInfo) {
  1240.                 $versionInfo = $this->domainMapper->buildVersionInfoDomainObject($spiVersionInfo);
  1241.                 if ($this->repository->canUser('content', 'versionread', $versionInfo)) {
  1242.                     $list->items[] = new ContentDraftListItem($versionInfo);
  1243.                 } else {
  1244.                     $list->items[] = new UnauthorizedContentDraftListItem(
  1245.                         'content',
  1246.                         'versionread',
  1247.                         ['contentId' => $versionInfo->contentInfo->id]
  1248.                     );
  1249.                 }
  1250.             }
  1251.         }
  1253.         return $list;
  1254.     }
  1256.     /**
  1257.      * Updates the fields of a draft.
  1258.      *
  1259.      * @param \eZ\Publish\API\Repository\Values\Content\VersionInfo $versionInfo
  1260.      * @param \eZ\Publish\API\Repository\Values\Content\ContentUpdateStruct $contentUpdateStruct
  1261.      *
  1262.      * @return \eZ\Publish\API\Repository\Values\Content\Content the content draft with the updated fields
  1263.      *
  1264.      * @throws \eZ\Publish\API\Repository\Exceptions\ContentFieldValidationException if a field in the $contentCreateStruct is not valid,
  1265.      *                                                                               or if a required field is missing / set to an empty value.
  1266.      * @throws \eZ\Publish\API\Repository\Exceptions\ContentValidationException If field definition does not exist in the ContentType,
  1267.      *                                                                          or value is set for non-translatable field in language
  1268.      *                                                                          other than main.
  1269.      * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the user is not allowed to update this version
  1270.      * @throws \eZ\Publish\API\Repository\Exceptions\BadStateException if the version is not a draft
  1271.      * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException if a property on the struct is invalid.
  1272.      * @throws \eZ\Publish\API\Repository\Exceptions\NotFoundException
  1273.      */
  1274.     public function updateContent(APIVersionInfo $versionInfo, APIContentUpdateStruct $contentUpdateStruct)
  1275.     {
  1276.         /** @var $content \eZ\Publish\Core\Repository\Values\Content\Content */
  1277.         $content = $this->loadContent(
  1278.             $versionInfo->getContentInfo()->id,
  1279.             null,
  1280.             $versionInfo->versionNo
  1281.         );
  1283.         if (!$this->repository->getPermissionResolver()->canUser(
  1284.             'content',
  1285.             'edit',
  1286.             $content,
  1287.             [
  1288.                 (new Target\Builder\VersionBuilder())
  1289.                     ->updateFieldsTo(
  1290.                         $contentUpdateStruct->initialLanguageCode,
  1291.                         $contentUpdateStruct->fields
  1292.                     )
  1293.                     ->build(),
  1294.             ]
  1295.         )) {
  1296.             throw new UnauthorizedException('content', 'edit', ['contentId' => $content->id]);
  1297.         }
  1299.         return $this->internalUpdateContent($versionInfo, $contentUpdateStruct);
  1300.     }
  1302.     /**
  1303.      * Updates the fields of a draft without checking the permissions.
  1304.      *
  1305.      * @throws \eZ\Publish\API\Repository\Exceptions\ContentFieldValidationException if a field in the $contentCreateStruct is not valid,
  1306.      *                                                                               or if a required field is missing / set to an empty value.
  1307.      * @throws \eZ\Publish\API\Repository\Exceptions\ContentValidationException If field definition does not exist in the ContentType,
  1308.      *                                                                          or value is set for non-translatable field in language
  1309.      *                                                                          other than main.
  1310.      * @throws \eZ\Publish\API\Repository\Exceptions\BadStateException if the version is not a draft
  1311.      * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException if a property on the struct is invalid.
  1312.      * @throws \eZ\Publish\API\Repository\Exceptions\NotFoundException
  1313.      */
  1314.     protected function internalUpdateContent(APIVersionInfo $versionInfo, APIContentUpdateStruct $contentUpdateStruct): Content
  1315.     {
  1316.         $contentUpdateStruct = clone $contentUpdateStruct;
  1318.         /** @var $content \eZ\Publish\Core\Repository\Values\Content\Content */
  1319.         $content = $this->internalLoadContent(
  1320.             $versionInfo->getContentInfo()->id,
  1321.             null,
  1322.             $versionInfo->versionNo
  1323.         );
  1324.         if (!$content->versionInfo->isDraft()) {
  1325.             throw new BadStateException(
  1326.                 '$versionInfo',
  1327.                 'Version is not a draft and can not be updated'
  1328.             );
  1329.         }
  1331.         $mainLanguageCode = $content->contentInfo->mainLanguageCode;
  1332.         if ($contentUpdateStruct->initialLanguageCode === null) {
  1333.             $contentUpdateStruct->initialLanguageCode = $mainLanguageCode;
  1334.         }
  1336.         $allLanguageCodes = $this->getLanguageCodesForUpdate($contentUpdateStruct, $content);
  1337.         $contentLanguageHandler = $this->persistenceHandler->contentLanguageHandler();
  1338.         foreach ($allLanguageCodes as $languageCode) {
  1339.             $contentLanguageHandler->loadByLanguageCode($languageCode);
  1340.         }
  1342.         $updatedLanguageCodes = $this->getUpdatedLanguageCodes($contentUpdateStruct);
  1343.         $contentType = $this->repository->getContentTypeService()->loadContentType(
  1344.             $content->contentInfo->contentTypeId
  1345.         );
  1346.         $fields = $this->mapFieldsForUpdate(
  1347.             $contentUpdateStruct,
  1348.             $contentType,
  1349.             $mainLanguageCode
  1350.         );
  1352.         $fieldValues = [];
  1353.         $spiFields = [];
  1354.         $allFieldErrors = [];
  1355.         $inputRelations = [];
  1356.         $locationIdToContentIdMapping = [];
  1358.         foreach ($contentType->getFieldDefinitions() as $fieldDefinition) {
  1359.             /** @var $fieldType \eZ\Publish\SPI\FieldType\FieldType */
  1360.             $fieldType = $this->fieldTypeRegistry->getFieldType(
  1361.                 $fieldDefinition->fieldTypeIdentifier
  1362.             );
  1364.             foreach ($allLanguageCodes as $languageCode) {
  1365.                 $isCopied = $isEmpty = $isRetained = false;
  1366.                 $isLanguageNew = !in_array($languageCode, $content->versionInfo->languageCodes);
  1367.                 $isLanguageUpdated = in_array($languageCode, $updatedLanguageCodes);
  1368.                 $valueLanguageCode = $fieldDefinition->isTranslatable ? $languageCode : $mainLanguageCode;
  1369.                 $isFieldUpdated = isset($fields[$fieldDefinition->identifier][$valueLanguageCode]);
  1370.                 $isProcessed = isset($fieldValues[$fieldDefinition->identifier][$valueLanguageCode]);
  1372.                 if (!$isFieldUpdated && !$isLanguageNew) {
  1373.                     $isRetained = true;
  1374.                     $fieldValue = $content->getField($fieldDefinition->identifier, $valueLanguageCode)->value;
  1375.                 } elseif (!$isFieldUpdated && $isLanguageNew && !$fieldDefinition->isTranslatable) {
  1376.                     $isCopied = true;
  1377.                     $fieldValue = $content->getField($fieldDefinition->identifier, $valueLanguageCode)->value;
  1378.                 } elseif ($isFieldUpdated) {
  1379.                     $fieldValue = $fields[$fieldDefinition->identifier][$valueLanguageCode]->value;
  1380.                 } else {
  1381.                     $fieldValue = $fieldDefinition->defaultValue;
  1382.                 }
  1384.                 $fieldValue = $fieldType->acceptValue($fieldValue);
  1386.                 if ($fieldType->isEmptyValue($fieldValue)) {
  1387.                     $isEmpty = true;
  1388.                     if ($isLanguageUpdated && $fieldDefinition->isRequired) {
  1389.                         $allFieldErrors[$fieldDefinition->id][$languageCode] = new ValidationError(
  1390.                             "Value for required field definition '%identifier%' with language '%languageCode%' is empty",
  1391.                             null,
  1392.                             ['%identifier%' => $fieldDefinition->identifier, '%languageCode%' => $languageCode],
  1393.                             'empty'
  1394.                         );
  1395.                     }
  1396.                 } elseif ($isLanguageUpdated) {
  1397.                     $fieldErrors = $fieldType->validate(
  1398.                         $fieldDefinition,
  1399.                         $fieldValue
  1400.                     );
  1401.                     if (!empty($fieldErrors)) {
  1402.                         $allFieldErrors[$fieldDefinition->id][$languageCode] = $fieldErrors;
  1403.                     }
  1404.                 }
  1406.                 if (!empty($allFieldErrors)) {
  1407.                     continue;
  1408.                 }
  1410.                 $this->relationProcessor->appendFieldRelations(
  1411.                     $inputRelations,
  1412.                     $locationIdToContentIdMapping,
  1413.                     $fieldType,
  1414.                     $fieldValue,
  1415.                     $fieldDefinition->id
  1416.                 );
  1417.                 $fieldValues[$fieldDefinition->identifier][$languageCode] = $fieldValue;
  1419.                 if ($isRetained || $isCopied || ($isLanguageNew && $isEmpty) || $isProcessed) {
  1420.                     continue;
  1421.                 }
  1423.                 $spiFields[] = new SPIField(
  1424.                     [
  1425.                         'id' => $isLanguageNew ?
  1426.                             null :
  1427.                             $content->getField($fieldDefinition->identifier, $languageCode)->id,
  1428.                         'fieldDefinitionId' => $fieldDefinition->id,
  1429.                         'type' => $fieldDefinition->fieldTypeIdentifier,
  1430.                         'value' => $fieldType->toPersistenceValue($fieldValue),
  1431.                         'languageCode' => $languageCode,
  1432.                         'versionNo' => $versionInfo->versionNo,
  1433.                     ]
  1434.                 );
  1435.             }
  1436.         }
  1438.         if (!empty($allFieldErrors)) {
  1439.             throw new ContentFieldValidationException($allFieldErrors);
  1440.         }
  1442.         $spiContentUpdateStruct = new SPIContentUpdateStruct(
  1443.             [
  1444.                 'name' => $this->nameSchemaService->resolveNameSchema(
  1445.                     $content,
  1446.                     $fieldValues,
  1447.                     $allLanguageCodes,
  1448.                     $contentType
  1449.                 ),
  1450.                 'creatorId' => $contentUpdateStruct->creatorId ?: $this->repository->getCurrentUserReference()->getUserId(),
  1451.                 'fields' => $spiFields,
  1452.                 'modificationDate' => time(),
  1453.                 'initialLanguageId' => $this->persistenceHandler->contentLanguageHandler()->loadByLanguageCode(
  1454.                     $contentUpdateStruct->initialLanguageCode
  1455.                 )->id,
  1456.             ]
  1457.         );
  1458.         $existingRelations = $this->internalLoadRelations($versionInfo);
  1460.         $this->repository->beginTransaction();
  1461.         try {
  1462.             $spiContent = $this->persistenceHandler->contentHandler()->updateContent(
  1463.                 $versionInfo->getContentInfo()->id,
  1464.                 $versionInfo->versionNo,
  1465.                 $spiContentUpdateStruct
  1466.             );
  1467.             $this->relationProcessor->processFieldRelations(
  1468.                 $inputRelations,
  1469.                 $spiContent->versionInfo->contentInfo->id,
  1470.                 $spiContent->versionInfo->versionNo,
  1471.                 $contentType,
  1472.                 $existingRelations
  1473.             );
  1474.             $this->repository->commit();
  1475.         } catch (Exception $e) {
  1476.             $this->repository->rollback();
  1477.             throw $e;
  1478.         }
  1480.         return $this->domainMapper->buildContentDomainObject(
  1481.             $spiContent,
  1482.             $contentType
  1483.         );
  1484.     }
  1486.     /**
  1487.      * Returns only updated language codes.
  1488.      *
  1489.      * @param \eZ\Publish\API\Repository\Values\Content\ContentUpdateStruct $contentUpdateStruct
  1490.      *
  1491.      * @return array
  1492.      */
  1493.     private function getUpdatedLanguageCodes(APIContentUpdateStruct $contentUpdateStruct)
  1494.     {
  1495.         $languageCodes = [
  1496.             $contentUpdateStruct->initialLanguageCode => true,
  1497.         ];
  1499.         foreach ($contentUpdateStruct->fields as $field) {
  1500.             if ($field->languageCode === null || isset($languageCodes[$field->languageCode])) {
  1501.                 continue;
  1502.             }
  1504.             $languageCodes[$field->languageCode] = true;
  1505.         }
  1507.         return array_keys($languageCodes);
  1508.     }
  1510.     /**
  1511.      * Returns all language codes used in given $fields.
  1512.      *
  1513.      * @throws \eZ\Publish\API\Repository\Exceptions\ContentValidationException if no field value exists in initial language
  1514.      *
  1515.      * @param \eZ\Publish\API\Repository\Values\Content\ContentUpdateStruct $contentUpdateStruct
  1516.      * @param \eZ\Publish\API\Repository\Values\Content\Content $content
  1517.      *
  1518.      * @return array
  1519.      */
  1520.     protected function getLanguageCodesForUpdate(APIContentUpdateStruct $contentUpdateStruct, APIContent $content)
  1521.     {
  1522.         $languageCodes = array_fill_keys($content->versionInfo->languageCodes, true);
  1523.         $languageCodes[$contentUpdateStruct->initialLanguageCode] = true;
  1525.         $updatedLanguageCodes = $this->getUpdatedLanguageCodes($contentUpdateStruct);
  1526.         foreach ($updatedLanguageCodes as $languageCode) {
  1527.             $languageCodes[$languageCode] = true;
  1528.         }
  1530.         return array_keys($languageCodes);
  1531.     }
  1533.     /**
  1534.      * Returns an array of fields like $fields[$field->fieldDefIdentifier][$field->languageCode].
  1535.      *
  1536.      * @throws \eZ\Publish\API\Repository\Exceptions\ContentValidationException If field definition does not exist in the ContentType
  1537.      *                                                                          or value is set for non-translatable field in language
  1538.      *                                                                          other than main
  1539.      *
  1540.      * @param \eZ\Publish\API\Repository\Values\Content\ContentUpdateStruct $contentUpdateStruct
  1541.      * @param \eZ\Publish\API\Repository\Values\ContentType\ContentType $contentType
  1542.      * @param string $mainLanguageCode
  1543.      *
  1544.      * @return array
  1545.      */
  1546.     protected function mapFieldsForUpdate(
  1547.         APIContentUpdateStruct $contentUpdateStruct,
  1548.         ContentType $contentType,
  1549.         $mainLanguageCode
  1550.     ) {
  1551.         $fields = [];
  1553.         foreach ($contentUpdateStruct->fields as $field) {
  1554.             $fieldDefinition = $contentType->getFieldDefinition($field->fieldDefIdentifier);
  1556.             if ($fieldDefinition === null) {
  1557.                 throw new ContentValidationException(
  1558.                     "Field definition '%identifier%' does not exist in given ContentType",
  1559.                     ['%identifier%' => $field->fieldDefIdentifier]
  1560.                 );
  1561.             }
  1563.             if ($field->languageCode === null) {
  1564.                 if ($fieldDefinition->isTranslatable) {
  1565.                     $languageCode = $contentUpdateStruct->initialLanguageCode;
  1566.                 } else {
  1567.                     $languageCode = $mainLanguageCode;
  1568.                 }
  1569.                 $field = $this->cloneField($field, ['languageCode' => $languageCode]);
  1570.             }
  1572.             if (!$fieldDefinition->isTranslatable && ($field->languageCode != $mainLanguageCode)) {
  1573.                 throw new ContentValidationException(
  1574.                     "A value is set for non translatable field definition '%identifier%' with language '%languageCode%'",
  1575.                     ['%identifier%' => $field->fieldDefIdentifier, '%languageCode%' => $field->languageCode]
  1576.                 );
  1577.             }
  1579.             $fields[$field->fieldDefIdentifier][$field->languageCode] = $field;
  1580.         }
  1582.         return $fields;
  1583.     }
  1585.     /**
  1586.      * Publishes a content version.
  1587.      *
  1588.      * Publishes a content version and deletes archive versions if they overflow max archive versions.
  1589.      * Max archive versions are currently a configuration, but might be moved to be a param of ContentType in the future.
  1590.      *
  1591.      * @param \eZ\Publish\API\Repository\Values\Content\VersionInfo $versionInfo
  1592.      * @param string[] $translations
  1593.      *
  1594.      * @return \eZ\Publish\API\Repository\Values\Content\Content
  1595.      *
  1596.      * @throws \eZ\Publish\API\Repository\Exceptions\BadStateException if the version is not a draft
  1597.      * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException
  1598.      * @throws \eZ\Publish\API\Repository\Exceptions\NotFoundException
  1599.      * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException
  1600.      */
  1601.     public function publishVersion(APIVersionInfo $versionInfo, array $translations = Language::ALL)
  1602.     {
  1603.         $content = $this->internalLoadContent(
  1604.             $versionInfo->contentInfo->id,
  1605.             null,
  1606.             $versionInfo->versionNo
  1607.         );
  1609.         $targets = [];
  1610.         if (!empty($translations)) {
  1611.             $targets[] = (new Target\Builder\VersionBuilder())
  1612.                 ->publishTranslations($translations)
  1613.                 ->build();
  1614.         }
  1616.         if (!$this->repository->getPermissionResolver()->canUser(
  1617.             'content',
  1618.             'publish',
  1619.             $content,
  1620.             $targets
  1621.         )) {
  1622.             throw new UnauthorizedException(
  1623.                 'content', 'publish', ['contentId' => $content->id]
  1624.             );
  1625.         }
  1627.         $this->repository->beginTransaction();
  1628.         try {
  1629.             $this->copyTranslationsFromPublishedVersion($content->versionInfo, $translations);
  1630.             $content = $this->internalPublishVersion($content->getVersionInfo(), null);
  1631.             $this->repository->commit();
  1632.         } catch (Exception $e) {
  1633.             $this->repository->rollback();
  1634.             throw $e;
  1635.         }
  1637.         return $content;
  1638.     }
  1640.     /**
  1641.      * @param \eZ\Publish\API\Repository\Values\Content\VersionInfo $versionInfo
  1642.      * @param array $translations
  1643.      *
  1644.      * @throws \eZ\Publish\API\Repository\Exceptions\BadStateException
  1645.      * @throws \eZ\Publish\API\Repository\Exceptions\ContentFieldValidationException
  1646.      * @throws \eZ\Publish\API\Repository\Exceptions\ContentValidationException
  1647.      * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException
  1648.      * @throws \eZ\Publish\API\Repository\Exceptions\NotFoundException
  1649.      */
  1650.     protected function copyTranslationsFromPublishedVersion(APIVersionInfo $versionInfo, array $translations = []): void
  1651.     {
  1652.         $contendId = $versionInfo->contentInfo->id;
  1654.         $currentContent = $this->internalLoadContent($contendId);
  1655.         $currentVersionInfo = $currentContent->versionInfo;
  1657.         // Copying occurs only if:
  1658.         // - There is published Version
  1659.         // - Published version is older than the currently published one unless specific translations are provided.
  1660.         if (!$currentVersionInfo->isPublished() ||
  1661.             ($versionInfo->versionNo >= $currentVersionInfo->versionNo && empty($translations))) {
  1662.             return;
  1663.         }
  1665.         if (empty($translations)) {
  1666.             $languagesToCopy = array_diff(
  1667.                 $currentVersionInfo->languageCodes,
  1668.                 $versionInfo->languageCodes
  1669.             );
  1670.         } else {
  1671.             $languagesToCopy = array_diff(
  1672.                 $currentVersionInfo->languageCodes,
  1673.                 $translations
  1674.             );
  1675.         }
  1677.         if (empty($languagesToCopy)) {
  1678.             return;
  1679.         }
  1681.         $contentType = $this->repository->getContentTypeService()->loadContentType(
  1682.             $currentVersionInfo->contentInfo->contentTypeId
  1683.         );
  1685.         // Find only translatable fields to update with selected languages
  1686.         $updateStruct = $this->newContentUpdateStruct();
  1687.         $updateStruct->initialLanguageCode = $versionInfo->initialLanguageCode;
  1689.         $contentToPublish = $this->internalLoadContent($contendId, null, $versionInfo->versionNo);
  1690.         $fallbackUpdateStruct = $this->newContentUpdateStruct();
  1692.         foreach ($currentContent->getFields() as $field) {
  1693.             $fieldDefinition = $contentType->getFieldDefinition($field->fieldDefIdentifier);
  1695.             if (!$fieldDefinition->isTranslatable || !\in_array($field->languageCode, $languagesToCopy)) {
  1696.                 continue;
  1697.             }
  1699.             $fieldType = $this->fieldTypeRegistry->getFieldType(
  1700.                 $fieldDefinition->fieldTypeIdentifier
  1701.             );
  1703.             $newValue = $contentToPublish->getFieldValue(
  1704.                 $fieldDefinition->identifier,
  1705.                 $field->languageCode
  1706.             );
  1708.             $value = $field->value;
  1709.             if ($fieldDefinition->isRequired && $fieldType->isEmptyValue($value)) {
  1710.                 if (!$fieldType->isEmptyValue($fieldDefinition->defaultValue)) {
  1711.                     $value = $fieldDefinition->defaultValue;
  1712.                 } else {
  1713.                     $value = $contentToPublish->getFieldValue($field->fieldDefIdentifier, $versionInfo->initialLanguageCode);
  1714.                 }
  1715.                 $fallbackUpdateStruct->setField(
  1716.                     $field->fieldDefIdentifier,
  1717.                     $value,
  1718.                     $field->languageCode
  1719.                 );
  1720.                 continue;
  1721.             }
  1723.             if ($newValue !== null
  1724.                 && $field->value !== null
  1725.                 && $fieldType->toHash($newValue) === $fieldType->toHash($field->value)) {
  1726.                 continue;
  1727.             }
  1729.             $updateStruct->setField($field->fieldDefIdentifier, $value, $field->languageCode);
  1730.         }
  1732.         // Nothing to copy, skip update
  1733.         if (empty($updateStruct->fields)) {
  1734.             return;
  1735.         }
  1737.         // Do fallback only if content needs to be updated
  1738.         foreach ($fallbackUpdateStruct->fields as $fallbackField) {
  1739.             $updateStruct->setField($fallbackField->fieldDefIdentifier, $fallbackField->value, $fallbackField->languageCode);
  1740.         }
  1742.         $this->internalUpdateContent($versionInfo, $updateStruct);
  1743.     }
  1745.     /**
  1746.      * Publishes a content version.
  1747.      *
  1748.      * Publishes a content version and deletes archive versions if they overflow max archive versions.
  1749.      * Max archive versions are currently a configuration, but might be moved to be a param of ContentType in the future.
  1750.      *
  1751.      * @throws \eZ\Publish\API\Repository\Exceptions\BadStateException if the version is not a draft
  1752.      *
  1753.      * @param \eZ\Publish\API\Repository\Values\Content\VersionInfo $versionInfo
  1754.      * @param int|null $publicationDate If null existing date is kept if there is one, otherwise current time is used.
  1755.      *
  1756.      * @return \eZ\Publish\API\Repository\Values\Content\Content
  1757.      */
  1758.     protected function internalPublishVersion(APIVersionInfo $versionInfo, $publicationDate = null)
  1759.     {
  1760.         if (!$versionInfo->isDraft()) {
  1761.             throw new BadStateException('$versionInfo', 'Only versions in draft status can be published.');
  1762.         }
  1764.         $currentTime = $this->getUnixTimestamp();
  1765.         if ($publicationDate === null && $versionInfo->versionNo === 1) {
  1766.             $publicationDate = $currentTime;
  1767.         }
  1769.         $contentInfo = $versionInfo->getContentInfo();
  1770.         $metadataUpdateStruct = new SPIMetadataUpdateStruct();
  1771.         $metadataUpdateStruct->publicationDate = $publicationDate;
  1772.         $metadataUpdateStruct->modificationDate = $currentTime;
  1773.         $metadataUpdateStruct->isHidden = $contentInfo->isHidden;
  1775.         $contentId = $contentInfo->id;
  1776.         $spiContent = $this->persistenceHandler->contentHandler()->publish(
  1777.             $contentId,
  1778.             $versionInfo->versionNo,
  1779.             $metadataUpdateStruct
  1780.         );
  1782.         $content = $this->domainMapper->buildContentDomainObject(
  1783.             $spiContent,
  1784.             $this->repository->getContentTypeService()->loadContentType(
  1785.                 $spiContent->versionInfo->contentInfo->contentTypeId
  1786.             )
  1787.         );
  1789.         $this->publishUrlAliasesForContent($content);
  1791.         // Delete version archive overflow if any, limit is 0-50 (however 0 will mean 1 if content is unpublished)
  1792.         $archiveList = $this->persistenceHandler->contentHandler()->listVersions(
  1793.             $contentId,
  1794.             APIVersionInfo::STATUS_ARCHIVED,
  1795.             100 // Limited to avoid publishing taking to long, besides SE limitations this is why limit is max 50
  1796.         );
  1798.         $maxVersionArchiveCount = max(0, min(50, $this->settings['default_version_archive_limit']));
  1799.         while (!empty($archiveList) && count($archiveList) > $maxVersionArchiveCount) {
  1800.             /** @var \eZ\Publish\SPI\Persistence\Content\VersionInfo $archiveVersion */
  1801.             $archiveVersion = array_shift($archiveList);
  1802.             $this->persistenceHandler->contentHandler()->deleteVersion(
  1803.                 $contentId,
  1804.                 $archiveVersion->versionNo
  1805.             );
  1806.         }
  1808.         return $content;
  1809.     }
  1811.     /**
  1812.      * @return int
  1813.      */
  1814.     protected function getUnixTimestamp()
  1815.     {
  1816.         return time();
  1817.     }
  1819.     /**
  1820.      * Removes the given version.
  1821.      *
  1822.      * @throws \eZ\Publish\API\Repository\Exceptions\BadStateException if the version is in
  1823.      *         published state or is a last version of Content in non draft state
  1824.      * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the user is not allowed to remove this version
  1825.      *
  1826.      * @param \eZ\Publish\API\Repository\Values\Content\VersionInfo $versionInfo
  1827.      */
  1828.     public function deleteVersion(APIVersionInfo $versionInfo)
  1829.     {
  1830.         if ($versionInfo->isPublished()) {
  1831.             throw new BadStateException(
  1832.                 '$versionInfo',
  1833.                 'Version is published and can not be removed'
  1834.             );
  1835.         }
  1837.         if (!$this->repository->canUser('content', 'versionremove', $versionInfo)) {
  1838.             throw new UnauthorizedException(
  1839.                 'content',
  1840.                 'versionremove',
  1841.                 ['contentId' => $versionInfo->contentInfo->id, 'versionNo' => $versionInfo->versionNo]
  1842.             );
  1843.         }
  1845.         $versionList = $this->persistenceHandler->contentHandler()->listVersions(
  1846.             $versionInfo->contentInfo->id,
  1847.             null,
  1848.             2
  1849.         );
  1851.         if (count($versionList) === 1 && !$versionInfo->isDraft()) {
  1852.             throw new BadStateException(
  1853.                 '$versionInfo',
  1854.                 'Version is the last version of the Content and can not be removed'
  1855.             );
  1856.         }
  1858.         $this->repository->beginTransaction();
  1859.         try {
  1860.             $this->persistenceHandler->contentHandler()->deleteVersion(
  1861.                 $versionInfo->getContentInfo()->id,
  1862.                 $versionInfo->versionNo
  1863.             );
  1864.             $this->repository->commit();
  1865.         } catch (Exception $e) {
  1866.             $this->repository->rollback();
  1867.             throw $e;
  1868.         }
  1869.     }
  1871.     /**
  1872.      * Loads all versions for the given content.
  1873.      *
  1874.      * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the user is not allowed to list versions
  1875.      * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException if the given status is invalid
  1876.      *
  1877.      * @param \eZ\Publish\API\Repository\Values\Content\ContentInfo $contentInfo
  1878.      * @param int|null $status
  1879.      *
  1880.      * @return \eZ\Publish\API\Repository\Values\Content\VersionInfo[] Sorted by creation date
  1881.      */
  1882.     public function loadVersions(ContentInfo $contentInfo, ?int $status = null)
  1883.     {
  1884.         if (!$this->repository->canUser('content', 'versionread', $contentInfo)) {
  1885.             throw new UnauthorizedException('content', 'versionread', ['contentId' => $contentInfo->id]);
  1886.         }
  1888.         if ($status !== null && !in_array((int)$status, [VersionInfo::STATUS_DRAFT, VersionInfo::STATUS_PUBLISHED, VersionInfo::STATUS_ARCHIVED], true)) {
  1889.             throw new InvalidArgumentException(
  1890.                 'status',
  1891.                 sprintf(
  1892.                     'it can be one of %d (draft), %d (published), %d (archived), %d given',
  1893.                     VersionInfo::STATUS_DRAFT, VersionInfo::STATUS_PUBLISHED, VersionInfo::STATUS_ARCHIVED, $status
  1894.                 ));
  1895.         }
  1897.         $spiVersionInfoList = $this->persistenceHandler->contentHandler()->listVersions($contentInfo->id, $status);
  1899.         $versions = [];
  1900.         foreach ($spiVersionInfoList as $spiVersionInfo) {
  1901.             $versionInfo = $this->domainMapper->buildVersionInfoDomainObject($spiVersionInfo);
  1902.             if (!$this->repository->canUser('content', 'versionread', $versionInfo)) {
  1903.                 throw new UnauthorizedException('content', 'versionread', ['versionId' => $versionInfo->id]);
  1904.             }
  1906.             $versions[] = $versionInfo;
  1907.         }
  1909.         return $versions;
  1910.     }
  1912.     /**
  1913.      * Copies the content to a new location. If no version is given,
  1914.      * all versions are copied, otherwise only the given version.
  1915.      *
  1916.      * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the user is not allowed to copy the content to the given location
  1917.      *
  1918.      * @param \eZ\Publish\API\Repository\Values\Content\ContentInfo $contentInfo
  1919.      * @param \eZ\Publish\API\Repository\Values\Content\LocationCreateStruct $destinationLocationCreateStruct the target location where the content is copied to
  1920.      * @param \eZ\Publish\API\Repository\Values\Content\VersionInfo $versionInfo
  1921.      *
  1922.      * @return \eZ\Publish\API\Repository\Values\Content\Content
  1923.      */
  1924.     public function copyContent(ContentInfo $contentInfo, LocationCreateStruct $destinationLocationCreateStruct, APIVersionInfo $versionInfo = null)
  1925.     {
  1926.         $destinationLocation = $this->repository->getLocationService()->loadLocation(
  1927.             $destinationLocationCreateStruct->parentLocationId
  1928.         );
  1929.         if (!$this->repository->canUser('content', 'create', $contentInfo, [$destinationLocation])) {
  1930.             throw new UnauthorizedException(
  1931.                 'content',
  1932.                 'create',
  1933.                 [
  1934.                     'parentLocationId' => $destinationLocationCreateStruct->parentLocationId,
  1935.                     'sectionId' => $contentInfo->sectionId,
  1936.                 ]
  1937.             );
  1938.         }
  1939.         if (!$this->repository->canUser('content', 'manage_locations', $contentInfo, [$destinationLocation])) {
  1940.             throw new UnauthorizedException('content', 'manage_locations', ['contentId' => $contentInfo->id]);
  1941.         }
  1943.         $defaultObjectStates = $this->getDefaultObjectStates();
  1945.         $this->repository->beginTransaction();
  1946.         try {
  1947.             $spiContent = $this->persistenceHandler->contentHandler()->copy(
  1948.                 $contentInfo->id,
  1949.                 $versionInfo ? $versionInfo->versionNo : null,
  1950.                 $this->repository->getPermissionResolver()->getCurrentUserReference()->getUserId()
  1951.             );
  1953.             $objectStateHandler = $this->persistenceHandler->objectStateHandler();
  1954.             foreach ($defaultObjectStates as $objectStateGroupId => $objectState) {
  1955.                 $objectStateHandler->setContentState(
  1956.                     $spiContent->versionInfo->contentInfo->id,
  1957.                     $objectStateGroupId,
  1958.                     $objectState->id
  1959.                 );
  1960.             }
  1962.             $content = $this->internalPublishVersion(
  1963.                 $this->domainMapper->buildVersionInfoDomainObject($spiContent->versionInfo),
  1964.                 $spiContent->versionInfo->creationDate
  1965.             );
  1967.             $this->repository->getLocationService()->createLocation(
  1968.                 $content->getVersionInfo()->getContentInfo(),
  1969.                 $destinationLocationCreateStruct
  1970.             );
  1971.             $this->repository->commit();
  1972.         } catch (Exception $e) {
  1973.             $this->repository->rollback();
  1974.             throw $e;
  1975.         }
  1977.         return $this->internalLoadContent($content->id);
  1978.     }
  1980.     /**
  1981.      * Loads all outgoing relations for the given version.
  1982.      *
  1983.      * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the user is not allowed to read this version
  1984.      *
  1985.      * @param \eZ\Publish\API\Repository\Values\Content\VersionInfo $versionInfo
  1986.      *
  1987.      * @return \eZ\Publish\API\Repository\Values\Content\Relation[]
  1988.      */
  1989.     public function loadRelations(APIVersionInfo $versionInfo)
  1990.     {
  1991.         if ($versionInfo->isPublished()) {
  1992.             $function = 'read';
  1993.         } else {
  1994.             $function = 'versionread';
  1995.         }
  1997.         if (!$this->repository->canUser('content', $function, $versionInfo)) {
  1998.             throw new UnauthorizedException('content', $function);
  1999.         }
  2001.         return $this->internalLoadRelations($versionInfo);
  2002.     }
  2004.     /**
  2005.      * Loads all outgoing relations for the given version without checking the permissions.
  2006.      *
  2007.      * @throws \eZ\Publish\API\Repository\Exceptions\NotFoundException
  2008.      *
  2009.      * @return \eZ\Publish\API\Repository\Values\Content\Relation[]
  2010.      */
  2011.     protected function internalLoadRelations(APIVersionInfo $versionInfo): array
  2012.     {
  2013.         $contentInfo = $versionInfo->getContentInfo();
  2014.         $spiRelations = $this->persistenceHandler->contentHandler()->loadRelations(
  2015.             $contentInfo->id,
  2016.             $versionInfo->versionNo
  2017.         );
  2019.         /** @var $relations \eZ\Publish\API\Repository\Values\Content\Relation[] */
  2020.         $relations = [];
  2021.         foreach ($spiRelations as $spiRelation) {
  2022.             $destinationContentInfo = $this->internalLoadContentInfo($spiRelation->destinationContentId);
  2023.             if (!$this->repository->canUser('content', 'read', $destinationContentInfo)) {
  2024.                 continue;
  2025.             }
  2027.             $relations[] = $this->domainMapper->buildRelationDomainObject(
  2028.                 $spiRelation,
  2029.                 $contentInfo,
  2030.                 $destinationContentInfo
  2031.             );
  2032.         }
  2034.         return $relations;
  2035.     }
  2037.     /**
  2038.      * {@inheritdoc}
  2039.      */
  2040.     public function countReverseRelations(ContentInfo $contentInfo): int
  2041.     {
  2042.         if (!$this->repository->canUser('content', 'reverserelatedlist', $contentInfo)) {
  2043.             return 0;
  2044.         }
  2046.         return $this->persistenceHandler->contentHandler()->countReverseRelations(
  2047.             $contentInfo->id
  2048.         );
  2049.     }
  2051.     /**
  2052.      * Loads all incoming relations for a content object.
  2053.      *
  2054.      * The relations come only from published versions of the source content objects
  2055.      *
  2056.      * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the user is not allowed to read this version
  2057.      *
  2058.      * @param \eZ\Publish\API\Repository\Values\Content\ContentInfo $contentInfo
  2059.      *
  2060.      * @return \eZ\Publish\API\Repository\Values\Content\Relation[]
  2061.      */
  2062.     public function loadReverseRelations(ContentInfo $contentInfo)
  2063.     {
  2064.         if (!$this->repository->canUser('content', 'reverserelatedlist', $contentInfo)) {
  2065.             throw new UnauthorizedException('content', 'reverserelatedlist', ['contentId' => $contentInfo->id]);
  2066.         }
  2068.         $spiRelations = $this->persistenceHandler->contentHandler()->loadReverseRelations(
  2069.             $contentInfo->id
  2070.         );
  2072.         $returnArray = [];
  2073.         foreach ($spiRelations as $spiRelation) {
  2074.             $sourceContentInfo = $this->internalLoadContentInfo($spiRelation->sourceContentId);
  2075.             if (!$this->repository->canUser('content', 'read', $sourceContentInfo)) {
  2076.                 continue;
  2077.             }
  2079.             $returnArray[] = $this->domainMapper->buildRelationDomainObject(
  2080.                 $spiRelation,
  2081.                 $sourceContentInfo,
  2082.                 $contentInfo
  2083.             );
  2084.         }
  2086.         return $returnArray;
  2087.     }
  2089.     /**
  2090.      * {@inheritdoc}
  2091.      */
  2092.     public function loadReverseRelationList(ContentInfo $contentInfo, int $offset = 0, int $limit = -1): RelationList
  2093.     {
  2094.         $list = new RelationList();
  2095.         if (!$this->repository->getPermissionResolver()->canUser('content', 'reverserelatedlist', $contentInfo)) {
  2096.             return $list;
  2097.         }
  2099.         $list->totalCount = $this->persistenceHandler->contentHandler()->countReverseRelations(
  2100.             $contentInfo->id
  2101.         );
  2102.         if ($list->totalCount > 0) {
  2103.             $spiRelationList = $this->persistenceHandler->contentHandler()->loadReverseRelationList(
  2104.                 $contentInfo->id,
  2105.                 $offset,
  2106.                 $limit
  2107.             );
  2108.             foreach ($spiRelationList as $spiRelation) {
  2109.                 $sourceContentInfo = $this->internalLoadContentInfo($spiRelation->sourceContentId);
  2110.                 if ($this->repository->getPermissionResolver()->canUser('content', 'read', $sourceContentInfo)) {
  2111.                     $relation = $this->domainMapper->buildRelationDomainObject(
  2112.                         $spiRelation,
  2113.                         $sourceContentInfo,
  2114.                         $contentInfo
  2115.                     );
  2116.                     $list->items[] = new RelationListItem($relation);
  2117.                 } else {
  2118.                     $list->items[] = new UnauthorizedRelationListItem(
  2119.                         'content',
  2120.                         'read',
  2121.                         ['contentId' => $sourceContentInfo->id]
  2122.                     );
  2123.                 }
  2124.             }
  2125.         }
  2127.         return $list;
  2128.     }
  2130.     /**
  2131.      * Adds a relation of type common.
  2132.      *
  2133.      * The source of the relation is the content and version
  2134.      * referenced by $versionInfo.
  2135.      *
  2136.      * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the user is not allowed to edit this version
  2137.      * @throws \eZ\Publish\API\Repository\Exceptions\BadStateException if the version is not a draft
  2138.      *
  2139.      * @param \eZ\Publish\API\Repository\Values\Content\VersionInfo $sourceVersion
  2140.      * @param \eZ\Publish\API\Repository\Values\Content\ContentInfo $destinationContent the destination of the relation
  2141.      *
  2142.      * @return \eZ\Publish\API\Repository\Values\Content\Relation the newly created relation
  2143.      */
  2144.     public function addRelation(APIVersionInfo $sourceVersion, ContentInfo $destinationContent)
  2145.     {
  2146.         $sourceVersion = $this->loadVersionInfoById(
  2147.             $sourceVersion->contentInfo->id,
  2148.             $sourceVersion->versionNo
  2149.         );
  2151.         if (!$sourceVersion->isDraft()) {
  2152.             throw new BadStateException(
  2153.                 '$sourceVersion',
  2154.                 'Relations of type common can only be added to versions of status draft'
  2155.             );
  2156.         }
  2158.         if (!$this->repository->canUser('content', 'edit', $sourceVersion)) {
  2159.             throw new UnauthorizedException('content', 'edit', ['contentId' => $sourceVersion->contentInfo->id]);
  2160.         }
  2162.         $sourceContentInfo = $sourceVersion->getContentInfo();
  2164.         $this->repository->beginTransaction();
  2165.         try {
  2166.             $spiRelation = $this->persistenceHandler->contentHandler()->addRelation(
  2167.                 new SPIRelationCreateStruct(
  2168.                     [
  2169.                         'sourceContentId' => $sourceContentInfo->id,
  2170.                         'sourceContentVersionNo' => $sourceVersion->versionNo,
  2171.                         'sourceFieldDefinitionId' => null,
  2172.                         'destinationContentId' => $destinationContent->id,
  2173.                         'type' => APIRelation::COMMON,
  2174.                     ]
  2175.                 )
  2176.             );
  2177.             $this->repository->commit();
  2178.         } catch (Exception $e) {
  2179.             $this->repository->rollback();
  2180.             throw $e;
  2181.         }
  2183.         return $this->domainMapper->buildRelationDomainObject($spiRelation, $sourceContentInfo, $destinationContent);
  2184.     }
  2186.     /**
  2187.      * Removes a relation of type COMMON from a draft.
  2188.      *
  2189.      * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the user is not allowed edit this version
  2190.      * @throws \eZ\Publish\API\Repository\Exceptions\BadStateException if the version is not a draft
  2191.      * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException if there is no relation of type COMMON for the given destination
  2192.      *
  2193.      * @param \eZ\Publish\API\Repository\Values\Content\VersionInfo $sourceVersion
  2194.      * @param \eZ\Publish\API\Repository\Values\Content\ContentInfo $destinationContent
  2195.      */
  2196.     public function deleteRelation(APIVersionInfo $sourceVersion, ContentInfo $destinationContent)
  2197.     {
  2198.         $sourceVersion = $this->loadVersionInfoById(
  2199.             $sourceVersion->contentInfo->id,
  2200.             $sourceVersion->versionNo
  2201.         );
  2203.         if (!$sourceVersion->isDraft()) {
  2204.             throw new BadStateException(
  2205.                 '$sourceVersion',
  2206.                 'Relations of type common can only be removed from versions of status draft'
  2207.             );
  2208.         }
  2210.         if (!$this->repository->canUser('content', 'edit', $sourceVersion)) {
  2211.             throw new UnauthorizedException('content', 'edit', ['contentId' => $sourceVersion->contentInfo->id]);
  2212.         }
  2214.         $spiRelations = $this->persistenceHandler->contentHandler()->loadRelations(
  2215.             $sourceVersion->getContentInfo()->id,
  2216.             $sourceVersion->versionNo,
  2217.             APIRelation::COMMON
  2218.         );
  2220.         if (empty($spiRelations)) {
  2221.             throw new InvalidArgumentException(
  2222.                 '$sourceVersion',
  2223.                 'There are no relations of type COMMON for the given destination'
  2224.             );
  2225.         }
  2227.         // there should be only one relation of type COMMON for each destination,
  2228.         // but in case there were ever more then one, we will remove them all
  2229.         // @todo: alternatively, throw BadStateException?
  2230.         $this->repository->beginTransaction();
  2231.         try {
  2232.             foreach ($spiRelations as $spiRelation) {
  2233.                 if ($spiRelation->destinationContentId == $destinationContent->id) {
  2234.                     $this->persistenceHandler->contentHandler()->removeRelation(
  2235.                         $spiRelation->id,
  2236.                         APIRelation::COMMON
  2237.                     );
  2238.                 }
  2239.             }
  2240.             $this->repository->commit();
  2241.         } catch (Exception $e) {
  2242.             $this->repository->rollback();
  2243.             throw $e;
  2244.         }
  2245.     }
  2247.     /**
  2248.      * {@inheritdoc}
  2249.      */
  2250.     public function removeTranslation(ContentInfo $contentInfo, $languageCode)
  2251.     {
  2252.         @trigger_error(
  2253.             __METHOD__ . ' is deprecated, use deleteTranslation instead',
  2254.             E_USER_DEPRECATED
  2255.         );
  2256.         $this->deleteTranslation($contentInfo, $languageCode);
  2257.     }
  2259.     /**
  2260.      * Delete Content item Translation from all Versions (including archived ones) of a Content Object.
  2261.      *
  2262.      * NOTE: this operation is risky and permanent, so user interface should provide a warning before performing it.
  2263.      *
  2264.      * @throws \eZ\Publish\API\Repository\Exceptions\BadStateException if the specified Translation
  2265.      *         is the Main Translation of a Content Item.
  2266.      * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the user is not allowed
  2267.      *         to delete the content (in one of the locations of the given Content Item).
  2268.      * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException if languageCode argument
  2269.      *         is invalid for the given content.
  2270.      *
  2271.      * @param \eZ\Publish\API\Repository\Values\Content\ContentInfo $contentInfo
  2272.      * @param string $languageCode
  2273.      *
  2274.      * @since 6.13
  2275.      */
  2276.     public function deleteTranslation(ContentInfo $contentInfo, $languageCode)
  2277.     {
  2278.         if ($contentInfo->mainLanguageCode === $languageCode) {
  2279.             throw new BadStateException(
  2280.                 '$languageCode',
  2281.                 'Specified translation is the main translation of the Content Object'
  2282.             );
  2283.         }
  2285.         $translationWasFound = false;
  2286.         $this->repository->beginTransaction();
  2287.         try {
  2288.             $target = (new Target\Builder\VersionBuilder())->translateToAnyLanguageOf([$languageCode])->build();
  2290.             foreach ($this->loadVersions($contentInfo) as $versionInfo) {
  2291.                 if (!$this->repository->canUser('content', 'remove', $versionInfo, [$target])) {
  2292.                     throw new UnauthorizedException(
  2293.                         'content',
  2294.                         'remove',
  2295.                         ['contentId' => $contentInfo->id, 'versionNo' => $versionInfo->versionNo, 'languageCode' => $languageCode]
  2296.                     );
  2297.                 }
  2299.                 if (!in_array($languageCode, $versionInfo->languageCodes)) {
  2300.                     continue;
  2301.                 }
  2303.                 $translationWasFound = true;
  2305.                 // If the translation is the version's only one, delete the version
  2306.                 if (count($versionInfo->languageCodes) < 2) {
  2307.                     $this->persistenceHandler->contentHandler()->deleteVersion(
  2308.                         $versionInfo->getContentInfo()->id,
  2309.                         $versionInfo->versionNo
  2310.                     );
  2311.                 }
  2312.             }
  2314.             if (!$translationWasFound) {
  2315.                 throw new InvalidArgumentException(
  2316.                     '$languageCode',
  2317.                     sprintf(
  2318.                         '%s does not exist in the Content item(id=%d)',
  2319.                         $languageCode,
  2320.                         $contentInfo->id
  2321.                     )
  2322.                 );
  2323.             }
  2325.             $this->persistenceHandler->contentHandler()->deleteTranslationFromContent(
  2326.                 $contentInfo->id,
  2327.                 $languageCode
  2328.             );
  2329.             $locationIds = array_map(
  2330.                 function (Location $location) {
  2331.                     return $location->id;
  2332.                 },
  2333.                 $this->repository->getLocationService()->loadLocations($contentInfo)
  2334.             );
  2335.             $this->persistenceHandler->urlAliasHandler()->translationRemoved(
  2336.                 $locationIds,
  2337.                 $languageCode
  2338.             );
  2339.             $this->repository->commit();
  2340.         } catch (InvalidArgumentException $e) {
  2341.             $this->repository->rollback();
  2342.             throw $e;
  2343.         } catch (BadStateException $e) {
  2344.             $this->repository->rollback();
  2345.             throw $e;
  2346.         } catch (UnauthorizedException $e) {
  2347.             $this->repository->rollback();
  2348.             throw $e;
  2349.         } catch (Exception $e) {
  2350.             $this->repository->rollback();
  2351.             // cover generic unexpected exception to fulfill API promise on @throws
  2352.             throw new BadStateException('$contentInfo', 'Translation removal failed', $e);
  2353.         }
  2354.     }
  2356.     /**
  2357.      * Delete specified Translation from a Content Draft.
  2358.      *
  2359.      * @throws \eZ\Publish\API\Repository\Exceptions\BadStateException if the specified Translation
  2360.      *         is the only one the Content Draft has or it is the main Translation of a Content Object.
  2361.      * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the user is not allowed
  2362.      *         to edit the Content (in one of the locations of the given Content Object).
  2363.      * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException if languageCode argument
  2364.      *         is invalid for the given Draft.
  2365.      * @throws \eZ\Publish\API\Repository\Exceptions\NotFoundException if specified Version was not found
  2366.      *
  2367.      * @param \eZ\Publish\API\Repository\Values\Content\VersionInfo $versionInfo Content Version Draft
  2368.      * @param string $languageCode Language code of the Translation to be removed
  2369.      *
  2370.      * @return \eZ\Publish\API\Repository\Values\Content\Content Content Draft w/o the specified Translation
  2371.      *
  2372.      * @since 6.12
  2373.      */
  2374.     public function deleteTranslationFromDraft(APIVersionInfo $versionInfo, $languageCode)
  2375.     {
  2376.         if (!$versionInfo->isDraft()) {
  2377.             throw new BadStateException(
  2378.                 '$versionInfo',
  2379.                 'Version is not a draft, so Translations cannot be modified. Create a Draft before proceeding'
  2380.             );
  2381.         }
  2383.         if ($versionInfo->contentInfo->mainLanguageCode === $languageCode) {
  2384.             throw new BadStateException(
  2385.                 '$languageCode',
  2386.                 'Specified Translation is the main Translation of the Content Object. Change it before proceeding.'
  2387.             );
  2388.         }
  2390.         if (!$this->repository->canUser('content', 'edit', $versionInfo->contentInfo)) {
  2391.             throw new UnauthorizedException(
  2392.                 'content', 'edit', ['contentId' => $versionInfo->contentInfo->id]
  2393.             );
  2394.         }
  2396.         if (!in_array($languageCode, $versionInfo->languageCodes)) {
  2397.             throw new InvalidArgumentException(
  2398.                 '$languageCode',
  2399.                 sprintf(
  2400.                     'The Version (ContentId=%d, VersionNo=%d) is not translated into %s',
  2401.                     $versionInfo->contentInfo->id,
  2402.                     $versionInfo->versionNo,
  2403.                     $languageCode
  2404.                 )
  2405.             );
  2406.         }
  2408.         if (count($versionInfo->languageCodes) === 1) {
  2409.             throw new BadStateException(
  2410.                 '$languageCode',
  2411.                 'Specified Translation is the only one Content Object Version has'
  2412.             );
  2413.         }
  2415.         $this->repository->beginTransaction();
  2416.         try {
  2417.             $spiContent = $this->persistenceHandler->contentHandler()->deleteTranslationFromDraft(
  2418.                 $versionInfo->contentInfo->id,
  2419.                 $versionInfo->versionNo,
  2420.                 $languageCode
  2421.             );
  2422.             $this->repository->commit();
  2424.             return $this->domainMapper->buildContentDomainObject(
  2425.                 $spiContent,
  2426.                 $this->repository->getContentTypeService()->loadContentType(
  2427.                     $spiContent->versionInfo->contentInfo->contentTypeId
  2428.                 )
  2429.             );
  2430.         } catch (APINotFoundException $e) {
  2431.             // avoid wrapping expected NotFoundException in BadStateException handled below
  2432.             $this->repository->rollback();
  2433.             throw $e;
  2434.         } catch (Exception $e) {
  2435.             $this->repository->rollback();
  2436.             // cover generic unexpected exception to fulfill API promise on @throws
  2437.             throw new BadStateException('$contentInfo', 'Translation removal failed', $e);
  2438.         }
  2439.     }
  2441.     /**
  2442.      * Hides Content by making all the Locations appear hidden.
  2443.      * It does not persist hidden state on Location object itself.
  2444.      *
  2445.      * Content hidden by this API can be revealed by revealContent API.
  2446.      *
  2447.      * @see revealContent
  2448.      *
  2449.      * @param \eZ\Publish\API\Repository\Values\Content\ContentInfo $contentInfo
  2450.      */
  2451.     public function hideContent(ContentInfo $contentInfo): void
  2452.     {
  2453.         if (!$this->repository->canUser('content', 'hide', $contentInfo)) {
  2454.             throw new UnauthorizedException('content', 'hide', ['contentId' => $contentInfo->id]);
  2455.         }
  2457.         $this->repository->beginTransaction();
  2458.         try {
  2459.             $this->persistenceHandler->contentHandler()->updateMetadata(
  2460.                 $contentInfo->id,
  2461.                 new SPIMetadataUpdateStruct([
  2462.                     'isHidden' => true,
  2463.                 ])
  2464.             );
  2465.             $locationHandler = $this->persistenceHandler->locationHandler();
  2466.             $childLocations = $locationHandler->loadLocationsByContent($contentInfo->id);
  2467.             foreach ($childLocations as $childLocation) {
  2468.                 $locationHandler->setInvisible($childLocation->id);
  2469.             }
  2470.             $this->repository->commit();
  2471.         } catch (Exception $e) {
  2472.             $this->repository->rollback();
  2473.             throw $e;
  2474.         }
  2475.     }
  2477.     /**
  2478.      * Reveals Content hidden by hideContent API.
  2479.      * Locations which were hidden before hiding Content will remain hidden.
  2480.      *
  2481.      * @see hideContent
  2482.      *
  2483.      * @param \eZ\Publish\API\Repository\Values\Content\ContentInfo $contentInfo
  2484.      */
  2485.     public function revealContent(ContentInfo $contentInfo): void
  2486.     {
  2487.         if (!$this->repository->canUser('content', 'hide', $contentInfo)) {
  2488.             throw new UnauthorizedException('content', 'hide', ['contentId' => $contentInfo->id]);
  2489.         }
  2491.         $this->repository->beginTransaction();
  2492.         try {
  2493.             $this->persistenceHandler->contentHandler()->updateMetadata(
  2494.                 $contentInfo->id,
  2495.                 new SPIMetadataUpdateStruct([
  2496.                     'isHidden' => false,
  2497.                 ])
  2498.             );
  2499.             $locationHandler = $this->persistenceHandler->locationHandler();
  2500.             $childLocations = $locationHandler->loadLocationsByContent($contentInfo->id);
  2501.             foreach ($childLocations as $childLocation) {
  2502.                 $locationHandler->setVisible($childLocation->id);
  2503.             }
  2504.             $this->repository->commit();
  2505.         } catch (Exception $e) {
  2506.             $this->repository->rollback();
  2507.             throw $e;
  2508.         }
  2509.     }
  2511.     /**
  2512.      * Instantiates a new content create struct object.
  2513.      *
  2514.      * alwaysAvailable is set to the ContentType's defaultAlwaysAvailable
  2515.      *
  2516.      * @param \eZ\Publish\API\Repository\Values\ContentType\ContentType $contentType
  2517.      * @param string $mainLanguageCode
  2518.      *
  2519.      * @return \eZ\Publish\API\Repository\Values\Content\ContentCreateStruct
  2520.      */
  2521.     public function newContentCreateStruct(ContentType $contentType, $mainLanguageCode)
  2522.     {
  2523.         return new ContentCreateStruct(
  2524.             [
  2525.                 'contentType' => $contentType,
  2526.                 'mainLanguageCode' => $mainLanguageCode,
  2527.                 'alwaysAvailable' => $contentType->defaultAlwaysAvailable,
  2528.             ]
  2529.         );
  2530.     }
  2532.     /**
  2533.      * Instantiates a new content meta data update struct.
  2534.      *
  2535.      * @return \eZ\Publish\API\Repository\Values\Content\ContentMetadataUpdateStruct
  2536.      */
  2537.     public function newContentMetadataUpdateStruct()
  2538.     {
  2539.         return new ContentMetadataUpdateStruct();
  2540.     }
  2542.     /**
  2543.      * Instantiates a new content update struct.
  2544.      *
  2545.      * @return \eZ\Publish\API\Repository\Values\Content\ContentUpdateStruct
  2546.      */
  2547.     public function newContentUpdateStruct()
  2548.     {
  2549.         return new ContentUpdateStruct();
  2550.     }
  2552.     /**
  2553.      * @param \eZ\Publish\API\Repository\Values\User\User|null $user
  2554.      *
  2555.      * @return \eZ\Publish\API\Repository\Values\User\UserReference
  2556.      */
  2557.     private function resolveUser(?User $user): UserReference
  2558.     {
  2559.         if ($user === null) {
  2560.             $user = $this->repository->getPermissionResolver()->getCurrentUserReference();
  2561.         }
  2563.         return $user;
  2564.     }
  2565. }