Issue #3540305 by phenaproxima, thejimbirch: The addComponentToLayout config...

 */

#[ConfigAction(

  id: 'add_layout_component',

  admin_label: new TranslatableMarkup('Add component to layout'),

  admin_label: new TranslatableMarkup('Add component(s) to layout'),

  deriver: AddComponentDeriver::class,

)]

final class AddComponent implements ConfigActionPluginInterface, ContainerFactoryPluginInterface {

    private readonly ConfigManagerInterface $configManager,

    private readonly UuidInterface $uuidGenerator,

    private readonly string $pluginId,

    private readonly bool $multiple,

  ) {}

  /**

      $container->get(ConfigManagerInterface::class),

      $container->get(UuidInterface::class),

      $plugin_id,

      $plugin_definition['multiple'],

    );

  }

  /**

   * {@inheritdoc}

   */

  public function apply(string $configName, mixed $value): void {

    assert(is_array($value));

    $section_delta = $value['section'];

    $position = $value['position'];

  public function apply(string $configName, mixed $values): void {

    assert(is_array($values));

    assert(is_int($section_delta));

    assert(is_int($position));

    if ($this->multiple) {

      assert(array_is_list($values));

    }

    else {

      $values = [$values];

    }

    $entity = $this->configManager->loadConfigEntityByName($configName);

    if (!$entity instanceof SectionListInterface) {

      throw new ConfigActionException("No entity found for applying the addComponentToLayout action.");

    }

    foreach ($values as $value) {

      $this->applySingle($entity, $value);

    }

    $entity->save();

  }

  /**

   * Adds a single component to the layout.

   *

   * @param \Drupal\layout_builder\SectionListInterface $entity

   *   The entity with a layout.

   * @param array $value

   *   The data for the config action.

   */

  private function applySingle(SectionListInterface $entity, array $value): void {

    $section_delta = $value['section'];

    $position = $value['position'];

    assert(is_int($section_delta));

    assert(is_int($position));

    $section = $entity->getSection($section_delta);

    $component = $value['component'];

    $position = min($position, count($section->getComponentsByRegion($region)));

    $section->insertComponent($position, $component);

    $entity->setSection($section_delta, $section);

    $entity->save();

  }

}

      }

    }

    $base_plugin_definition['entity_types'] = $entity_types;

    $this->derivatives['addComponentToLayout'] = $base_plugin_definition;

    $this->derivatives['addComponentToLayout'] = $base_plugin_definition + [

      'multiple' => FALSE,

    ];

    $this->derivatives['addComponentsToLayout'] = $base_plugin_definition + [

      'multiple' => TRUE,

    ];

    return $this->derivatives;

  }

use Drupal\Core\Config\Action\ConfigActionException;

use Drupal\Core\Config\Action\ConfigActionManager;

use Drupal\Core\Entity\Entity\EntityViewDisplay;

use Drupal\Core\Entity\EntityTypeManagerInterface;

use Drupal\entity_test\EntityTestHelper;

use Drupal\KernelTests\KernelTestBase;

use Drupal\layout_builder\Plugin\ConfigAction\AddComponent;

use Drupal\layout_builder\Plugin\ConfigAction\Deriver\AddComponentDeriver;

use Drupal\layout_builder\Plugin\SectionStorage\DefaultsSectionStorage;

use Drupal\layout_builder\Section;

use Drupal\layout_builder\SectionListInterface;

use Drupal\layout_builder\SectionStorage\SectionStorageManagerInterface;

use PHPUnit\Framework\Attributes\CoversClass;

use PHPUnit\Framework\Attributes\Group;

/**

 * @coversDefaultClass \Drupal\layout_builder\Plugin\ConfigAction\AddComponent

 *

 * @group layout_builder

 * Tests that `addComponentToLayout` config action.

 */

#[Group('layout_builder')]

#[CoversClass(AddComponent::class)]

#[CoversClass(AddComponentDeriver::class)]

class AddComponentTest extends KernelTestBase {

  /**

      ]);

  }

  /**

   * Tests that the deriver produces the expected derivatives.

   */

  public function testDerivativeDefinitions(): void {

    $singular = $this->configActionManager->getDefinition('add_layout_component:addComponentToLayout');

    $plural = $this->configActionManager->getDefinition('add_layout_component:addComponentsToLayout');

    // These actions should be limited to entity types that carry section lists.

    $this->assertSame(['entity_view_display'], $singular['entity_types']);

    // The `multiple` flag should differ.

    $this->assertFalse($singular['multiple']);

    $this->assertTrue($plural['multiple']);

    // There should only be two derivatives (the singular and the plural).

    $definitions = array_filter(

      array_keys($this->configActionManager->getDefinitions()),

      fn (string $id): bool => str_starts_with($id, 'add_layout_component:'),

    );

    $this->assertCount(2, $definitions);

  }

  /**

   * Tests adding multiple components at once.

   */

  public function testAddMultipleComponents(): void {

    $uuid1 = '955493d5-f4c0-4fd1-a8aa-6bcf92d455e6';

    $uuid2 = 'b6e2f3d1-a496-426c-b0e5-eff1d14fc461';

    $this->configActionManager->applyAction(

      'addComponentsToLayout',

      'core.entity_view_display.entity_test.bundle_with_extra_fields.default',

      [

        [

          'section' => 0,

          'position' => 0,

          'component' => [

            'region' => [

              'layout_twocol_section' => 'first',

            ],

            'default_region' => 'content',

            'configuration' => [

              'id' => 'my_plugin_id',

            ],

            'uuid' => $uuid1,

          ],

        ],

        [

          'section' => 0,

          'position' => 1,

          'component' => [

            'region' => [

              'layout_twocol_section' => 'first',

            ],

            'default_region' => 'content',

            'configuration' => [

              'id' => 'my_plugin_id',

            ],

            'uuid' => $uuid2,

          ],

        ],

      ],

    );

    $display = EntityViewDisplay::load('entity_test.bundle_with_extra_fields.default');

    $components = $display?->getSection(0)->getComponents();

    $this->assertArrayHasKey($uuid1, $components);

    $this->assertArrayHasKey($uuid2, $components);

  }

}

<?php

declare(strict_types=1);

namespace Drupal\Tests\layout_builder\Unit\Plugin\ConfigAction\Deriver;

use Drupal\Core\Entity\EntityTypeInterface;

use Drupal\Core\Entity\EntityTypeManagerInterface;

use Drupal\layout_builder\Plugin\ConfigAction\Deriver\AddComponentDeriver;

use Drupal\layout_builder\SectionListInterface;

use Drupal\Core\Config\Entity\ConfigEntityInterface;

use Drupal\Tests\UnitTestCase;

use Prophecy\PhpUnit\ProphecyTrait;

/**

 * @coversDefaultClass \Drupal\layout_builder\Plugin\ConfigAction\Deriver\AddComponentDeriver

 * @group layout_builder

 */

class AddComponentDeriverTest extends UnitTestCase {

  use ProphecyTrait;

  /**

   * Tests derivative generation for entities implementing SectionListInterface.

   *

   * @covers ::getDerivativeDefinitions

   */

  public function testGetDerivativeDefinitions(): void {

    $entityTypeManager = $this->prophesize(EntityTypeManagerInterface::class);

    $deriver = new AddComponentDeriver($entityTypeManager->reveal());

    $entity_types = [];

    // Create a mock entity type that implements both required interfaces.

    $valid_entity_type = $this->prophesize(EntityTypeInterface::class);

    $valid_entity_type->entityClassImplements(ConfigEntityInterface::class)->willReturn(TRUE);

    $valid_entity_type->entityClassImplements(SectionListInterface::class)->willReturn(TRUE);

    $valid_entity_type->id()->willReturn('valid_type');

    $entity_types['valid_type'] = $valid_entity_type->reveal();

    // Create a mock entity type that only implements ConfigEntityInterface.

    $config_only_type = $this->prophesize(EntityTypeInterface::class);

    $config_only_type->entityClassImplements(ConfigEntityInterface::class)->willReturn(TRUE);

    $config_only_type->entityClassImplements(SectionListInterface::class)->willReturn(FALSE);

    $entity_types['config_only'] = $config_only_type->reveal();

    // Create a mock entity type that only implements SectionListInterface.

    $section_only_type = $this->prophesize(EntityTypeInterface::class);

    $section_only_type->entityClassImplements(ConfigEntityInterface::class)->willReturn(FALSE);

    $section_only_type->entityClassImplements(SectionListInterface::class)->willReturn(TRUE);

    $entity_types['section_only'] = $section_only_type->reveal();

    $entityTypeManager->getDefinitions()->willReturn($entity_types);

    $base_plugin_definition = [];

    $derivatives = $deriver->getDerivativeDefinitions($base_plugin_definition);

    $this->assertCount(1, $derivatives, 'Only one derivative should be generated.');

    $this->assertArrayHasKey('addComponentToLayout', $derivatives, 'The derivative should be keyed by addComponentToLayout.');

    $this->assertEquals(['valid_type'], $derivatives['addComponentToLayout']['entity_types'], 'Only the valid entity type should be included in the derivative definition.');

  }

}