vendor/easycorp/easyadmin-bundle/src/Collection/FieldCollection.php line 153

Open in your IDE?
  1. <?php
  3. namespace EasyCorp\Bundle\EasyAdminBundle\Collection;
  5. use EasyCorp\Bundle\EasyAdminBundle\Contracts\Collection\CollectionInterface;
  6. use EasyCorp\Bundle\EasyAdminBundle\Contracts\Field\FieldInterface;
  7. use EasyCorp\Bundle\EasyAdminBundle\Dto\FieldDto;
  8. use EasyCorp\Bundle\EasyAdminBundle\Field\Field;
  10. /**
  11.  * @author Javier Eguiluz <javier.eguiluz@gmail.com>
  12.  */
  13. final class FieldCollection implements CollectionInterface
  14. {
  15.     /** @var FieldDto[] */
  16.     private array $fields;
  18.     /**
  19.      * @param FieldInterface[]|string[] $fields
  20.      */
  21.     private function __construct(iterable $fields)
  22.     {
  23.         $this->fields = $this->processFields($fields);
  24.     }
  26.     public function __clone()
  27.     {
  28.         $clonedFields = [];
  29.         foreach ($this->fields as $fieldDto) {
  30.             $clonedFieldDto = clone $fieldDto;
  31.             $clonedFields[$clonedFieldDto->getUniqueId()] = $clonedFieldDto;
  32.         }
  34.         $this->fields = $clonedFields;
  35.     }
  37.     /**
  38.      * @param FieldInterface[]|string[] $fields
  39.      */
  40.     public static function new(iterable $fields): self
  41.     {
  42.         return new self($fields);
  43.     }
  45.     public function get(string $fieldUniqueId): ?FieldDto
  46.     {
  47.         return $this->fields[$fieldUniqueId] ?? null;
  48.     }
  50.     /**
  51.      * It returns the first field associated to the given property or null if none found.
  52.      * Some pages (index/detail) can render the same field more than once.
  53.      * In those cases, this method always returns the first field occurrence.
  54.      */
  55.     public function getByProperty(string $propertyName): ?FieldDto
  56.     {
  57.         foreach ($this->fields as $field) {
  58.             if ($propertyName === $field->getProperty()) {
  59.                 return $field;
  60.             }
  61.         }
  63.         return null;
  64.     }
  66.     public function set(FieldDto $newOrUpdatedField): void
  67.     {
  68.         $this->fields[$newOrUpdatedField->getUniqueId()] = $newOrUpdatedField;
  69.     }
  71.     public function unset(FieldDto $removedField): void
  72.     {
  73.         unset($this->fields[$removedField->getUniqueId()]);
  74.     }
  76.     public function add(FieldDto $newField): void
  77.     {
  78.         $this->fields[$newField->getUniqueId()] = $newField;
  79.     }
  81.     public function prepend(FieldDto $newField): void
  82.     {
  83.         $this->fields = array_merge([$newField->getUniqueId() => $newField], $this->fields);
  84.     }
  86.     public function insertBefore(FieldDto $newField, FieldDto $existingField): void
  87.     {
  88.         $newFields = [];
  89.         $existingFieldUniqueId = $existingField->getUniqueId();
  90.         foreach ($this->fields as $fieldUniqueId => $field) {
  91.             if ($existingFieldUniqueId === $fieldUniqueId) {
  92.                 $newFields[$newField->getUniqueId()] = $newField;
  93.             }
  95.             $newFields[$fieldUniqueId] = $field;
  96.         }
  98.         $this->fields = $newFields;
  99.     }
  101.     public function first(): ?FieldDto
  102.     {
  103.         if (0 === \count($this->fields)) {
  104.             return null;
  105.         }
  107.         return $this->fields[array_key_first($this->fields)];
  108.     }
  110.     public function isEmpty(): bool
  111.     {
  112.         return 0 === \count($this->fields);
  113.     }
  115.     public function offsetExists(mixed $offset): bool
  116.     {
  117.         return \array_key_exists($offset, $this->fields);
  118.     }
  120.     public function offsetGet(mixed $offset): FieldDto
  121.     {
  122.         return $this->fields[$offset];
  123.     }
  125.     public function offsetSet(mixed $offset, mixed $value): void
  126.     {
  127.         $this->fields[$offset] = $value;
  128.     }
  130.     public function offsetUnset(mixed $offset): void
  131.     {
  132.         unset($this->fields[$offset]);
  133.     }
  135.     public function count(): int
  136.     {
  137.         return \count($this->fields);
  138.     }
  140.     /**
  141.      * @return \ArrayIterator<FieldDto>
  142.      */
  143.     public function getIterator(): \ArrayIterator
  144.     {
  145.         return new \ArrayIterator($this->fields);
  146.     }
  148.     /**
  149.      * @param FieldInterface[]|string[] $fields
  150.      *
  151.      * @return FieldDto[]
  152.      */
  153.     private function processFields(iterable $fields): array
  154.     {
  155.         $dtos = [];
  157.         // for DX reasons, fields can be configured as a FieldInterface object and
  158.         // as a simple string with the name of the Doctrine property
  159.         /** @var FieldInterface|string $field */
  160.         foreach ($fields as $field) {
  161.             if (\is_string($field)) {
  162.                 $field = Field::new($field);
  163.             }
  165.             $dto = $field->getAsDto();
  166.             if (null === $dto->getFieldFqcn()) {
  167.                 $dto->setFieldFqcn($field::class);
  168.             }
  169.             $dtos[$dto->getUniqueId()] = $dto;
  170.         }
  172.         return $dtos;
  173.     }
  174. }