src/App/Model/Query/ConditionQuery/ConditionSchema.php line 124

Open in your IDE?
  1. <?php
  3. namespace App\Model\Query\ConditionQuery;
  5. use JsonSerializable;
  7. /**
  8.  * Represents the configuration of a single type of filter.
  9.  *
  10.  * @see https://coda.io/d/_diyKeRjYYS-/Flexible-Messaging-Prototype_suNzV#_luVi2
  11.  */
  12. final class ConditionSchema implements JsonSerializable
  13. {
  14.     use ConditionFilterTrait;
  16.     /**
  17.      * @var ConditionConfig|null
  18.      */
  19.     private ?ConditionConfig $conditionConfig = null;
  21.     /**
  22.      * @var string|null
  23.      */
  24.     private ?string $category = null;
  26.     /**
  27.      * @var string|null
  28.      */
  29.     private ?string $name = null;
  31.     /**
  32.      * @var AbstractType|null
  33.      */
  34.     private ?AbstractType $type = null;
  36.     /**
  37.      * @param string|null $filter
  38.      * @param string|null $name
  39.      * @param AbstractType|null $type
  40.      */
  41.     public function __construct(
  42.         ?string $filter = null,
  43.         ?string $name = null,
  44.         ?AbstractType $type = null
  45.     )
  46.     {
  47.         $this
  48.             ->setFilter($filter)
  49.             ->setName($name)
  50.             ->setType($type);
  51.     }
  53.     /**
  54.      * @return string|null
  55.      */
  56.     public function getName(): ?string
  57.     {
  58.         return $this->name;
  59.     }
  61.     /**
  62.      * @param string|null $name
  63.      * @return $this
  64.      */
  65.     public function setName(?string $name): self
  66.     {
  67.         $this->name = $name ?: null;
  68.         return $this;
  69.     }
  71.     /**
  72.      * @return string|null
  73.      */
  74.     public function getCategory(): ?string
  75.     {
  76.         return $this->category;
  77.     }
  79.     /**
  80.      * @param string|null $category
  81.      * @return $this
  82.      */
  83.     public function setCategory(?string $category): self
  84.     {
  85.         $this->category = $category ?: null;
  86.         return $this;
  87.     }
  89.     /**
  90.      * @return AbstractType|null
  91.      */
  92.     public function getType(): ?AbstractType
  93.     {
  94.         return $this->type;
  95.     }
  97.     /**
  98.      * @param AbstractType|null $type
  99.      * @return $this
  100.      */
  101.     public function setType(?AbstractType $type): self
  102.     {
  103.         $this->type = $type;
  104.         return $this;
  105.     }
  107.     /**
  108.      * {@inheritDoc}
  109.      */
  110.     public function jsonSerialize(): array
  111.     {
  112.         return [
  113.             'filter' => $this->getFilter(),
  114.             'category' => $this->getCategory(),
  115.             'name' => $this->getName(),
  116.             'type' => $this->getType()->jsonSerialize(),
  117.         ];
  118.     }
  120.     /**
  121.      * @param array $serialized
  122.      * @return $this
  123.      */
  124.     public function jsonUnserialize(array $serialized): self
  125.     {
  126.         return $this
  127.             ->setFilter($serialized['filter'] ?? null)
  128.             ->setCategory($serialized['category'] ?? null)
  129.             ->setName($serialized['name'] ?? null)
  130.             ->setType(
  131.                 $serialized['type'] ? AbstractType::factory(
  132.                     $serialized['type'],
  133.                 ) : null,
  134.             );
  135.     }
  137.     /**
  138.      * @param array $serialized
  139.      * @return ConditionSchema
  140.      */
  141.     static public function factory(array $serialized): ConditionSchema
  142.     {
  143.         if ( ! isset($serialized['filter']) || ! is_string($serialized['filter'])) {
  144.             throw new \Exception('Invalid filter');
  145.         }
  146.         if ( ! isset($serialized['name']) || ! is_string($serialized['name'])) {
  147.             throw new \Exception('Invalid name');
  148.         }
  149.         if ( ! isset($serialized['type'])) {
  150.             throw new \Exception('Invalid type');
  151.         }
  152.         return (new ConditionSchema())->jsonUnserialize($serialized);
  153.     }
  155.     /**
  156.      * @return void
  157.      */
  158.     public function __clone()
  159.     {
  160.         $this->conditionConfig = null;
  161.     }
  163.     /**
  164.      * @return ConditionConfig|null
  165.      */
  166.     public function getConditionConfig(): ?ConditionConfig
  167.     {
  168.         return $this->conditionConfig;
  169.     }
  171.     /**
  172.      * @param ConditionConfig|null $conditionConfig
  173.      * @return $this
  174.      */
  175.     public function setConditionConfig(?ConditionConfig $conditionConfig): self
  176.     {
  177.         if ($conditionConfig && $this->conditionConfig) {
  178.             throw new \Exception('Schema has already been assigned to a configuration.');
  179.         }
  180.         $this->conditionConfig = $conditionConfig;
  181.         return $this;
  182.     }
  183. }