src/Entity/Rule.php line 16

  1. <?php
  3. namespace App\Entity;
  5. use App\Enum\RuleType;
  6. use App\Enum\RuleRateType;
  7. use App\Enum\RuleMultiplier;
  8. use App\Repository\RuleRepository;
  9. use Doctrine\Common\Collections\ArrayCollection;
  10. use Doctrine\Common\Collections\Collection;
  11. use Doctrine\DBAL\Types\Types;
  12. use Doctrine\ORM\Mapping as ORM;
  13. use Gedmo\Timestampable\Traits\TimestampableEntity;
  15. #[ORM\Entity(repositoryClass: RuleRepository::class)]
  16. class Rule
  17. {
  18.     use TimestampableEntity;
  19.     #[ORM\Id]
  20.     #[ORM\GeneratedValue]
  21.     #[ORM\Column]
  22.     private ?int $id = null;
  24.     #[ORM\Column(length: 255, nullable: true)]
  25.     private ?string $name = null;
  27.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  28.     private ?string $description = null;
  30.     #[ORM\Column(length: 255, nullable: true)]
  31.     private ?RuleType $type = null;
  33.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  34.     private ?\DateTimeInterface $activeStartDate = null;
  36.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  37.     private ?\DateTimeInterface $activeEndDate = null;
  39.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  40.     private ?\DateTimeInterface $effectiveStartDate = null;
  42.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  43.     private ?\DateTimeInterface $effectiveEndDate = null;
  45.     #[ORM\Column(length: 255, nullable: true)]
  46.     private ?string $inputType = null;
  48.     #[ORM\Column(length: 255, nullable: true)]
  49.     private ?RuleMultiplier $multiplier = null;
  51.     #[ORM\Column(length: 255, nullable: true)]
  52.     private ?RuleRateType $rateType = null;
  54.     #[ORM\ManyToOne(inversedBy: 'rules')]
  55.     private ?NamedRelationship $namedRelationship = null;
  57.     #[ORM\Column]
  58.     private ?bool $rollableOnReporting = null;
  60.     #[ORM\OneToMany(mappedBy: 'rule', targetEntity: RuleVersion::class)]
  61.     private Collection $ruleVersions;
  63.     #[ORM\OneToMany(mappedBy: 'rule', targetEntity: RuleResult::class)]
  64.     private Collection $ruleResults;
  66.     #[ORM\ManyToMany(targetEntity: Plan::class, mappedBy: 'rules')]
  67.     private Collection $plans;
  69.     public function __construct()
  70.     {
  71.         $this->ruleVersions = new ArrayCollection();
  72.         $this->ruleResults = new ArrayCollection();
  73.         $this->plans = new ArrayCollection();
  74.     }
  76.     public function getId(): ?int
  77.     {
  78.         return $this->id;
  79.     }
  81.     public function getName(): ?string
  82.     {
  83.         return $this->name;
  84.     }
  86.     public function setName(?string $name): self
  87.     {
  88.         $this->name = $name;
  90.         return $this;
  91.     }
  93.     public function getDescription(): ?string
  94.     {
  95.         return $this->description;
  96.     }
  98.     public function setDescription(?string $description): self
  99.     {
  100.         $this->description = $description;
  102.         return $this;
  103.     }
  105.     public function getType(): ?RuleType
  106.     {
  107.         return $this->type;
  108.     }
  110.     public function setType(?RuleType $type): self
  111.     {
  112.         $this->type = $type;
  114.         return $this;
  115.     }
  117.     public function getActiveStartDate(): ?\DateTimeInterface
  118.     {
  119.         return $this->activeStartDate;
  120.     }
  122.     public function setActiveStartDate(?\DateTimeInterface $activeStartDate): self
  123.     {
  124.         $this->activeStartDate = $activeStartDate;
  126.         return $this;
  127.     }
  129.     public function getActiveEndDate(): ?\DateTimeInterface
  130.     {
  131.         return $this->activeEndDate;
  132.     }
  134.     public function setActiveEndDate(?\DateTimeInterface $activeEndDate): self
  135.     {
  136.         $this->activeEndDate = $activeEndDate;
  138.         return $this;
  139.     }
  141.     public function getEffectiveEndDate(): ?\DateTimeInterface
  142.     {
  143.         return $this->effectiveEndDate;
  144.     }
  146.     public function setEffectiveEndDate(?\DateTimeInterface $effectiveEndDate): self
  147.     {
  148.         $this->effectiveEndDate = $effectiveEndDate;
  150.         return $this;
  151.     }
  153.     public function getInputType(): ?string
  154.     {
  155.         return $this->inputType;
  156.     }
  158.     public function setInputType(?string $inputType): self
  159.     {
  160.         $this->inputType = $inputType;
  162.         return $this;
  163.     }
  165.     public function getMultiplier(): ?RuleMultiplier
  166.     {
  167.         return $this->multiplier;
  168.     }
  170.     public function setMultiplier(?RuleMultiplier $multiplier): self
  171.     {
  172.         $this->multiplier = $multiplier;
  174.         return $this;
  175.     }
  177.     public function getRateType(): ?RuleRateType
  178.     {
  179.         return $this->rateType;
  180.     }
  182.     public function setRateType(?RuleRateType $rateType): self
  183.     {
  184.         $this->rateType = $rateType;
  186.         return $this;
  187.     }
  189.     public function getNamedRelationship(): ?NamedRelationship
  190.     {
  191.         return $this->namedRelationship;
  192.     }
  194.     public function setNamedRelationship(?NamedRelationship $namedRelationship): self
  195.     {
  196.         $this->namedRelationship = $namedRelationship;
  198.         return $this;
  199.     }
  201.     public function isRollableOnReporting(): ?bool
  202.     {
  203.         return $this->rollableOnReporting;
  204.     }
  206.     public function setRollableOnReporting(bool $rollableOnReporting): self
  207.     {
  208.         $this->rollableOnReporting = $rollableOnReporting;
  210.         return $this;
  211.     }
  213.     /**
  214.      * @return Collection<int, RuleVersion>
  215.      */
  216.     public function getRuleVersions(): Collection
  217.     {
  218.         return $this->ruleVersions;
  219.     }
  221.     public function addRuleVersion(RuleVersion $ruleVersion): self
  222.     {
  223.         if (!$this->ruleVersions->contains($ruleVersion)) {
  224.             $this->ruleVersions->add($ruleVersion);
  225.             $ruleVersion->setRule($this);
  226.         }
  228.         return $this;
  229.     }
  231.     public function removeRuleVersion(RuleVersion $ruleVersion): self
  232.     {
  233.         if ($this->ruleVersions->removeElement($ruleVersion)) {
  234.             // set the owning side to null (unless already changed)
  235.             if ($ruleVersion->getRule() === $this) {
  236.                 $ruleVersion->setRule(null);
  237.             }
  238.         }
  240.         return $this;
  241.     }
  243.     /**
  244.      * @return Collection<int, RuleResult>
  245.      */
  246.     public function getRuleResults(): Collection
  247.     {
  248.         return $this->ruleResults;
  249.     }
  251.     public function addRuleResult(RuleResult $ruleResult): static
  252.     {
  253.         if (!$this->ruleResults->contains($ruleResult)) {
  254.             $this->ruleResults->add($ruleResult);
  255.             $ruleResult->setRule($this);
  256.         }
  258.         return $this;
  259.     }
  261.     public function removeRuleResult(RuleResult $ruleResult): static
  262.     {
  263.         if ($this->ruleResults->removeElement($ruleResult)) {
  264.             // set the owning side to null (unless already changed)
  265.             if ($ruleResult->getRule() === $this) {
  266.                 $ruleResult->setRule(null);
  267.             }
  268.         }
  270.         return $this;
  271.     }
  273.     /**
  274.      * @return Collection<int, Plan>
  275.      */
  276.     public function getPlans(): Collection
  277.     {
  278.         return $this->plans;
  279.     }
  281.     public function addPlan(Plan $plan): static
  282.     {
  283.         if (!$this->plans->contains($plan)) {
  284.             $this->plans->add($plan);
  285.             $plan->addRule($this);
  286.         }
  288.         return $this;
  289.     }
  291.     public function removePlan(Plan $plan): static
  292.     {
  293.         if ($this->plans->removeElement($plan)) {
  294.             $plan->removeRule($this);
  295.         }
  297.         return $this;
  298.     }
  300.     public function __toString(): string
  301.     {
  302.         return $this->getName();
  303.         return sprintf('%s - %s', $this->getName(), $this->getType()->title());
  304.     }
  305. }