Feature/entries with category features

src/controllers/ElementsController.php

@@ -1447,6 +1447,57 @@ public function actionGetElementHtml(): Response
         return $this->asJson(compact('html', 'headHtml'));
     }
 
+    /**
+     * Returns HTML for a structured elements field input based on a given list
+     * of selected element ids.
+     *
+     * @return Response
+     * @throws BadRequestHttpException
+     * @throws ForbiddenHttpException
+     * @since 4.0.0
+     */
+    public function actionStructuredInputHtml(): Response
+    {
+        $this->requireAcceptsJson();
+
+        $elementType = $this->request->getRequiredParam('elementType');
+        $elementIds = $this->request->getParam('elementIds', []);
+
+        $elements = [];
+
+        if (!empty($elementIds)) {
+            /** @var ElementInterface[] $elements */
+            $elements = $elementType::find()
+                ->id($elementIds)
+                ->siteId($this->request->getParam('siteId'))
+                ->status(null)
+                ->all();
+
+            // Fill in the gaps
+            $structuresService = Craft::$app->getStructures();
+            $structuresService->fillGapsInElements($elements);
+
+            // Enforce the branch limit
+            if ($branchLimit = $this->request->getParam('branchLimit')) {
+                $structuresService->applyBranchLimitToElements($elements, $branchLimit);
+            }
+        }
+
+        $html = $this->getView()->renderTemplate('_includes/forms/elementselect',
+            [
+                'elements' => $elements,
+                'id' => $this->request->getParam('containerId'),
+                'name' => $this->request->getParam('name'),
+                'selectionLabel' => $this->request->getParam('selectionLabel'),
+                'elementType' => $elementType,
+                'relateAncestors' => true,
+            ]);
+
+        return $this->asJson([
+            'html' => $html,
+        ]);
+    }
+
     /**
      * Returns the requested element, populated with any posted attributes.
      *

src/fields/BaseRelationField.php

@@ -35,6 +35,7 @@
 use craft\queue\jobs\LocalizeRelations;
 use craft\services\Elements;
 use craft\services\ElementSources;
+use craft\web\assets\elementfieldsettings\ElementFieldSettingsAsset;
 use DateTime;
 use GraphQL\Type\Definition\Type;
 use Illuminate\Support\Collection;
@@ -135,6 +136,20 @@ public static function valueType(): string
      */
     public bool $showSiteMenu = false;
 
+    /**
+     * @var bool Whether to automatically relate structural ancestors.
+     *
+     * @since 4.0.0
+     */
+    public bool $relateAncestors = false;
+
+    /**
+     * @var int|null Branch limit
+     *
+     * @since 4.0.0
+     */
+    public ?int $branchLimit = null;
+
     /**
      * @var string|null The view mode
      */
@@ -249,6 +264,14 @@ public function __construct(array $config = [])
             $config['showSiteMenu'] = true;
         }
 
+        // if relating ancestors, then clear min/max limits, otherwise clear branch limit
+        if (isset($config['relateAncestors']) && !empty($config['relateAncestors'])) {
+            $config['maxRelations'] = null;
+            $config['minRelations'] = null;
+        } else {
+            $config['branchLimit'] = null;
+        }
+
         parent::__construct($config);
     }
 
@@ -259,10 +282,57 @@ public function __construct(array $config = [])
     protected function defineRules(): array
     {
         $rules = parent::defineRules();
-        $rules[] = [['minRelations', 'maxRelations'], 'number', 'integerOnly' => true];
+        $rules[] = [['minRelations', 'maxRelations', 'branchLimit'], 'number', 'integerOnly' => true];
+        $rules[] = [['source', 'sources'], 'validateSources'];
         return $rules;
     }
 
+    /**
+     * Ensure only one structured source is selected when relateAncestors is true.
+     *
+     * @param string $attribute
+     */
+    public function validateSources($attribute): void
+    {
+        if (!$this->relateAncestors) {
+            return;
+        }
+
+        $inputSources = $this->getInputSources();
+
+        if ($inputSources === null) {
+            $this->addError($attribute, Craft::t('app', 'One source needs to be selected when relating ancestors.'));
+            return;
+        }
+
+        if (is_string($inputSources)) {
+            $inputSources = [$inputSources];
+        }
+
+        $elementSources = ArrayHelper::whereIn(
+            Craft::$app->elementSources->getSources(static::elementType()),
+            'key',
+            $inputSources
+        );
+
+        if (count($elementSources) > 1) {
+            $this->addError($attribute, Craft::t('app', 'Only one source allowed when relating ancestors.'));
+        }
+
+        foreach ($elementSources as $elementSource) {
+            if (!isset($elementSource['structureId'])) {
+                $this->addError(
+                    $attribute,
+                    Craft::t(
+                        'app',
+                        '{source} is not a structured source. Only structured sources may be used when relating ancestors.',
+                        ['source' => $elementSource['label']]
+                    )
+                );
+            }
+        }
+    }
+
     /**
      * @inheritdoc
      */
@@ -280,6 +350,9 @@ public function settingsAttributes(): array
         $attributes[] = 'targetSiteId';
         $attributes[] = 'validateRelatedElements';
         $attributes[] = 'viewMode';
+        $attributes[] = 'allowSelfRelations';
+        $attributes[] = 'relateAncestors';
+        $attributes[] = 'branchLimit';
 
         return $attributes;
     }
@@ -304,7 +377,18 @@ public function getSettings(): array
     public function getSettingsHtml(): ?string
     {
         $variables = $this->settingsTemplateVariables();
-        return Craft::$app->getView()->renderTemplate($this->settingsTemplate, $variables);
+        $view = Craft::$app->getView();
+
+        $view->registerAssetBundle(ElementFieldSettingsAsset::class);
+        $view->registerJs("new Craft.ElementFieldSettings(
+            '{$view->namespaceInputId('relate-ancestors')}',
+	        '{$view->namespaceInputId('sources-field')}',
+	        '{$view->namespaceInputId('branch-limit')}',
+	        '{$view->namespaceInputId('min-relations')}',
+	        '{$view->namespaceInputId('max-relations')}',
+        )");
+
+        return $view->renderTemplate($this->settingsTemplate, $variables);
     }
 
     /**
@@ -361,7 +445,7 @@ public function validateRelationCount(ElementInterface $element): void
      */
     public function validateRelatedElements(ElementInterface $element): void
     {
-        // Prevent circular relations from worrying about this entry
+        // Prevent circular relations from worrying about this element
         $sourceId = $element->getCanonicalId();
         $sourceValidates = self::$_relatedElementValidates[$sourceId][$element->siteId] ?? null;
         self::$_relatedElementValidates[$sourceId][$element->siteId] = true;
@@ -489,6 +573,25 @@ public function normalizeValue(mixed $value, ?ElementInterface $element = null):
                     Craft::configure($query, $source['criteria']);
                 }
             }
+
+            if ($this->relateAncestors) {
+                $structuresService = Craft::$app->getStructures();
+
+                /** @var ElementInterface[] $structureElements */
+                $structureElements = (clone($query))
+                    ->status(null)
+                    ->all();
+
+                // Fill in any gaps
+                $structuresService->fillGapsInElements($structureElements);
+
+                // Enforce the branch limit
+                if ($this->branchLimit) {
+                    $structuresService->applyBranchLimitToElements($structureElements, $this->branchLimit);
+                }
+
+                $query->id(ArrayHelper::getColumn($structureElements, 'id'));
+            }
         } else {
             $query->id(false);
         }
@@ -757,6 +860,10 @@ public function getEagerLoadingMap(array $sourceElements): array|null|false
             }
         }
 
+        if ($this->relateAncestors) {
+            $criteria['orderBy'] = ['structureelements.lft' => SORT_ASC];
+        }
+
         return [
             'elementType' => static::elementType(),
             'map' => $map,
@@ -805,7 +912,7 @@ public function afterElementSave(ElementInterface $element, bool $isNew): void
     {
         // Skip if nothing changed, or the element is just propagating and we're not localizing relations
         if (
-            $element->isFieldDirty($this->handle) &&
+            ($element->isFieldDirty($this->handle) || $this->relateAncestors) &&
             (!$element->propagating || $this->localizeRelations)
         ) {
             /** @var ElementQueryInterface|Collection $value */
@@ -823,6 +930,32 @@ public function afterElementSave(ElementInterface $element, bool $isNew): void
                 $targetIds = $this->_all($value, $element)->ids();
             }
 
+            if ($this->relateAncestors) {
+                $structuresService = Craft::$app->getStructures();
+
+                /** @var ElementInterface $class */
+                $class = static::elementType();
+
+                /** @var ElementInterface[] $structureElements */
+                $structureElements = $class::find()
+                    ->id($targetIds)
+                    ->drafts(null)
+                    ->revisions(null)
+                    ->provisionalDrafts(null)
+                    ->status(null)
+                    ->all();
+
+                // Fill in any gaps
+                $structuresService->fillGapsInElements($structureElements);
+
+                // Enforce the branch limit
+                if ($this->branchLimit) {
+                    $structuresService->applyBranchLimitToElements($structureElements, $this->branchLimit);
+                }
+
+                $targetIds = ArrayHelper::getColumn($structureElements, 'id');
+            }
+
             /** @var int|int[]|false|null $targetIds */
             Craft::$app->getRelations()->saveRelations($this, $element, $targetIds);
 
@@ -1065,7 +1198,9 @@ protected function inputTemplateVariables(array|ElementQueryInterface $value = n
             'condition' => $this->getSelectionCondition(),
             'criteria' => $selectionCriteria,
             'showSiteMenu' => ($this->targetSiteId || !$this->showSiteMenu) ? false : 'auto',
-            'allowSelfRelations' => $this->allowSelfRelations,
+            'allowSelfRelations' => (bool)$this->allowSelfRelations,
+            'relateAncestors' => (bool)$this->relateAncestors,
+            'branchLimit' => $this->branchLimit,
             'sourceElementId' => !empty($element->id) ? $element->id : null,
             'disabledElementIds' => $disabledElementIds,
             'limit' => $this->allowLimit ? $this->maxRelations : null,

src/fields/Categories.php

@@ -11,7 +11,6 @@
 use craft\base\ElementInterface;
 use craft\elements\Category;
 use craft\elements\db\CategoryQuery;
-use craft\elements\db\ElementQueryInterface;
 use craft\gql\arguments\elements\Category as CategoryArguments;
 use craft\gql\interfaces\elements\Category as CategoryInterface;
 use craft\gql\resolvers\elements\Category as CategoryResolver;
@@ -64,40 +63,36 @@ public static function valueType(): string
         return CategoryQuery::class;
     }
 
-    /**
-     * @inheritdoc
-     */
-    public bool $allowLimit = false;
-
     /**
      * @inheritdoc
      */
     public bool $allowMultipleSources = false;
 
-    /**
-     * @var int|null Branch limit
-     */
-    public ?int $branchLimit = null;
-
     /**
      * @inheritdoc
      */
-    protected string $settingsTemplate = '_components/fieldtypes/Categories/settings.twig';
+    public bool $relateAncestors = true;
 
     /**
      * @inheritdoc
      */
-    protected string $inputTemplate = '_components/fieldtypes/Categories/input.twig';
+    protected string $settingsTemplate = '_components/fieldtypes/elementfieldsettings';
 
     /**
      * @inheritdoc
      */
-    protected ?string $inputJsClass = 'Craft.CategorySelectInput';
+    protected bool $sortable = false;
 
     /**
      * @inheritdoc
      */
-    protected bool $sortable = false;
+    public function __construct(array $config = [])
+    {
+        // allow categories to limit selection if `relateAncestors` isn't checked
+        $config['allowLimit'] = true;
+
+        parent::__construct($config);
+    }
 
     /**
      * @inheritdoc
@@ -144,17 +139,6 @@ protected function inputHtml(mixed $value, ?ElementInterface $element = null): s
         return parent::inputHtml($value, $element);
     }
 
-    /**
-     * @inheritdoc
-     */
-    protected function inputTemplateVariables(array|ElementQueryInterface $value = null, ?ElementInterface $element = null): array
-    {
-        $variables = parent::inputTemplateVariables($value, $element);
-        $variables['branchLimit'] = $this->branchLimit;
-
-        return $variables;
-    }
-
     public function getEagerLoadingMap(array $sourceElements): array|null|false
     {
         $map = parent::getEagerLoadingMap($sourceElements);