Copy field values from other sites

packages/craftcms-sass/_mixins.scss

@@ -190,10 +190,10 @@ $menuBorderRadius: $mediumBorderRadius;
     sans-serif;
 }
 
-@mixin fixed-width-font {
+@mixin fixed-width-font($size: 0.9em) {
   font-family: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, Courier,
     monospace;
-  font-size: 0.9em !important;
+  font-size: $size !important;
 }
 
 @function toRem($values...) {

packages/craftcms-webpack/Craft.d.ts

@@ -13,14 +13,24 @@ interface ProgressBarInterface {
   showProgressBar(): void;
 }
 
+type Site = {
+  handle: string;
+  id: number;
+  name: string;
+  uid: string;
+};
+
 // Declare existing variables, mock the things we'll use.
 declare var Craft: {
+  csrfTokenName?: string;
+  csrfTokenValue?: string;
   ProgressBar: ProgressBarInterface;
   t(category: string, message: string, params?: object): string;
   sendActionRequest(method: string, action: string, options?: object): Promise;
   initUiElements($container: JQuery): void;
   expandPostArray(arr: object): any;
   escapeHtml(str: string);
+  sites: Site[];
   Preview: any;
   cp: any;
 };

src/base/CopyableFieldInterface.php

@@ -0,0 +1,35 @@
+<?php
+/**
+ * @link https://craftcms.com/
+ * @copyright Copyright (c) Pixel & Tonic, Inc.
+ * @license https://craftcms.github.io/license/
+ */
+
+namespace craft\base;
+
+/**
+ * CopyableFieldInterface defines the common interface to be implemented by field classes
+ * that wish to support copying their values between sites in a multisite installation.
+ *
+ * @author Pixel & Tonic, Inc. <[email protected]>
+ * @since 5.5.0
+ */
+interface CopyableFieldInterface
+{
+    /**
+     * Returns whether the field is copyable between sites.
+     *
+     * @param ElementInterface|null $element
+     * @return bool
+     */
+    public function getIsCopyable(?ElementInterface $element = null): bool;
+
+    /**
+     * Copies field’s value from one element to another.
+     *
+     * @param ElementInterface $from
+     * @param ElementInterface $to
+     * @return bool
+     */
+    public function copyValueBetweenSites(ElementInterface $from, ElementInterface $to): bool;
+}

src/base/Element.php

@@ -35,6 +35,7 @@
 use craft\elements\User;
 use craft\enums\AttributeStatus;
 use craft\enums\Color;
+use craft\enums\MenuItemType;
 use craft\errors\InvalidFieldException;
 use craft\events\AuthorizationCheckEvent;
 use craft\events\DefineAttributeHtmlEvent;
@@ -2245,6 +2246,12 @@ private static function _indexOrderByColumns(
      */
     private $_serializeFields = false;
 
+    /**
+     * @var bool|null
+     * @see getIsCopyable()
+     */
+    private ?bool $_isCopyable = null;
+
     /**
      * @inheritdoc
      */
@@ -3605,6 +3612,31 @@ protected function safeActionMenuItems(): array
             ];
         }
 
+        // Copy content
+        $user = Craft::$app->getUser()->getIdentity();
+        if (
+            !$this->getIsRevision() &&
+            $this->canSave($user) &&
+            $this->getIsCopyable()
+        ) {
+            $copyContentId = sprintf('action-copy-content-%s', mt_rand());
+            $items[] = [
+                'id' => $copyContentId,
+                'icon' => 'clone',
+                'label' => Craft::t('app', 'Copy content from site'),
+                'type' => MenuItemType::Button,
+                'showInChips' => false,
+                'attributes' => [
+                    'data' => [
+                        'copy-content' => true,
+                    ],
+                    'aria' => [
+                        'label' => Craft::t('app', 'Copy content from site'),
+                    ],
+                ],
+            ];
+        }
+
         // Edit
         if (Craft::$app->getElements()->canView($this)) {
             $editId = sprintf('action-edit-%s', mt_rand());
@@ -5219,6 +5251,25 @@ public function getCurrentRevision(): ?ElementInterface
         return $this->_currentRevision ?: null;
     }
 
+    /**
+     * @inheritdoc
+     */
+    public function getIsCopyable(): bool
+    {
+        if (!isset($this->_isCopyable)) {
+            $this->_isCopyable = !(
+                !Craft::$app->getIsMultiSite() ||
+                // check if user can edit this element in other site ids
+                count(ElementHelper::editableSiteIdsForElement($this)) < 2 ||
+                // also check if the element exists in other sites
+                empty(array_diff(array_keys(ElementHelper::siteStatusesForElement($this, true)), [$this->siteId]))
+            );
+            ;
+        }
+
+        return $this->_isCopyable;
+    }
+
     // Indexes, etc.
     // -------------------------------------------------------------------------
 
@@ -5857,7 +5908,7 @@ public function beforeSave(bool $isNew): bool
             $this->trigger(self::EVENT_BEFORE_SAVE, $event);
             return $event->isValid;
         }
-        
+
         return true;
     }
 

src/base/ElementInterface.php

@@ -1602,6 +1602,16 @@ public function setRevisionNotes(?string $notes): void;
      */
     public function getCurrentRevision(): ?self;
 
+    /**
+     * Return if the element is copyable between sites.
+     * Checks if it's a multisite installation, if user can edit the element in other sites,
+     * and if the element actually exists in other sites.
+     *
+     * @return bool
+     * @since 5.5.0
+     */
+    public function getIsCopyable(): bool;
+
     // Indexes, etc.
     // -------------------------------------------------------------------------
 

src/base/ElementTrait.php

@@ -252,4 +252,10 @@ trait ElementTrait
      * @since 3.2.0
      */
     public bool $hardDelete = false;
+
+    /**
+     * @var bool Whether the element is having its values copied across sites.
+     * @since 5.5.0
+     */
+    public bool $copying = false;
 }

src/base/Field.php

@@ -611,6 +611,41 @@ public function getTranslationKey(ElementInterface $element): string
         return ElementHelper::translationKey($element, $this->translationMethod, $this->translationKeyFormat);
     }
 
+    /**
+     * @see CopyableFieldInterface::getIsCopyable()
+     * @since 5.5.0
+     */
+    public function getIsCopyable(?ElementInterface $element = null): bool
+    {
+        return $this->getIsTranslatable($element) && $element?->getIsCopyable();
+    }
+
+    /**
+     * @see CopyableFieldInterface::copyValueBetweenSites()
+     * @since 5.5.0
+     */
+    public function copyValueBetweenSites(ElementInterface $from, ElementInterface $to): bool
+    {
+        $fromValue = $this->serializeValue($from->getFieldValue($this->handle), $from);
+        $toValue = $this->serializeValue($to->getFieldValue($this->handle), $to);
+
+        if ($fromValue != $toValue) {
+            $to->setFieldValue($this->handle, $fromValue);
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Returns whether field contains nested elements, and uses the nested element manager.
+     * @since 5.5.0
+     */
+    public function getIsNested(?ElementInterface $element = null): bool
+    {
+        return $this instanceof ElementContainerFieldInterface;
+    }
+
     /**
      * @inheritdoc
      */
@@ -919,7 +954,7 @@ public function serializeValue(mixed $value, ?ElementInterface $element): mixed
     }
 
     /**
-     * @inheritdoc
+     * Copies field’s value from one element to another.
      */
     public function copyValue(ElementInterface $from, ElementInterface $to): void
     {

src/controllers/ElementsController.php

@@ -531,6 +531,110 @@ public function actionEdit(?ElementInterface $element, ?int $elementId = null):
         return $response;
     }
 
+    /**
+     * Returns result of copying field value from another site
+     *
+     * @return Response
+     * @throws BadRequestHttpException
+     * @throws ForbiddenHttpException
+     * @throws ServerErrorHttpException
+     * @throws Throwable
+     * @throws \craft\errors\ElementNotFoundException
+     * @throws \craft\errors\InvalidFieldException
+     * @throws \craft\errors\MissingComponentException
+     * @throws \yii\base\Exception
+     * @throws \yii\db\Exception
+     * @since 5.5.0
+     */
+    public function actionCopyFieldValuesFromSite(): Response
+    {
+        $this->requireCpRequest();
+
+        /** @var Element|Response|null $element */
+        $element = $this->_element(checkForProvisionalDraft: true);
+
+        if ($element instanceof Response) {
+            return $element;
+        }
+
+        if (!$element || $element->getIsRevision()) {
+            throw new BadRequestHttpException('No element was identified by the request.');
+        }
+
+        // if $fieldHandle is null, we're copying all element fields
+        $fieldHandle = $this->request->getBodyParam('fieldHandle', null);
+        $copyFromSiteId = $this->request->getRequiredBodyParam('copyFromSiteId');
+        $namespace = $this->request->getBodyParam('namespace');
+
+        if ($fieldHandle === '' || empty($copyFromSiteId)) {
+            throw new BadRequestHttpException("Request missing required param");
+        }
+
+        $elementsService = Craft::$app->getElements();
+
+        // check if this entry exists for other sites
+        if (empty($siteIdsForElement = $elementsService->getEnabledSiteIdsForElement($element->id))) {
+            $errorMsg = Craft::t('app', 'Couldn’t find this {type} on other sites.', [
+                'type' => $element::lowerDisplayName(),
+            ]);
+
+            return $this->_asFailure($element, $errorMsg);
+        }
+
+        // Check if the site id requested exists for the element
+        if (!in_array($copyFromSiteId, $siteIdsForElement, false)) {
+            $errorMsg = Craft::t('app', 'Couldn’t find this {type} on the site you selected.', [
+                'type' => $element::lowerDisplayName(),
+            ]);
+
+            return $this->_asFailure($element, $errorMsg);
+        }
+
+        // Now we can actually copy things
+        $updates = $elementsService->copyFieldValuesFromSite($element, $fieldHandle, $copyFromSiteId);
+        if (count(array_keys($updates)) === 0) {
+            return $this->_asSuccess(Craft::t('app', 'Nothing to copy.'), $element, [
+                'fragments' => [],
+            ]);
+        }
+
+        $fragments = [];
+        $view = Craft::$app->getView();
+        $layout = $element->getFieldLayout();
+
+        // Loop over each of the updated fields and gather the HTML of the field
+        foreach ($layout->getTabs() as $tab) {
+            foreach ($tab->getElements() as $layoutElement) {
+                if ($layoutElement instanceof BaseField) {
+                    $attribute = $layoutElement->attribute();
+
+                    // Only return attributes that were updated
+                    if (in_array($attribute, array_keys($updates))) {
+                        $html = $view->namespaceInputs(function() use ($element, $layoutElement) {
+                            return $layoutElement->formHtml($element);
+                        }, $namespace); // you have to pass the $namespace here or some attrs won't get properly namespaced (e.g. title)
+
+                        if ($html) {
+                            $html = Html::modifyTagAttributes($html, [
+                                'data' => [
+                                    'layout-element' => $layoutElement->uid,
+                                ],
+                            ]);
+                        }
+
+                        $fragments[$layoutElement->uid] = $html;
+                    }
+                }
+            }
+        }
+
+        return $this->_asSuccess('Content copied.', $element, [
+            'headHtml' => $view->getHeadHtml(),
+            'bodyHtml' => $view->getBodyHtml(),
+            'fragments' => $fragments,
+        ]);
+    }
+
     /**
      * Returns an element revisions index screen.
      *

src/elements/NestedElementManager.php

@@ -656,7 +656,9 @@ public function maintainNestedElements(ElementInterface $owner, bool $isNew): vo
     {
         $resetValue = false;
 
-        if ($owner->duplicateOf !== null) {
+        if ($owner->copying) {
+            $this->duplicateNestedElements($owner->duplicateOf, $owner, true, !$isNew, true);
+        } elseif ($owner->duplicateOf !== null) {
             // If this is a draft, its nested element ownership will be duplicated by Drafts::createDraft()
             if ($owner->getIsRevision()) {
                 $this->createRevisions($owner->duplicateOf, $owner);
@@ -956,7 +958,7 @@ private function duplicateNestedElements(
 
         $transaction = Craft::$app->getDb()->beginTransaction();
         try {
-            $setCanonicalId = $target->getIsDerivative() && $target->getCanonical()->id !== $target->id;
+            $setCanonicalId = !$target->copying && $target->getIsDerivative() && $target->getCanonical()->id !== $target->id;
 
             /** @var NestedElementInterface[] $elements */
             foreach ($elements as $element) {