src/Entity/Year.php line 12

  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\YearRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use Gedmo\Timestampable\Traits\TimestampableEntity;
  11. #[ORM\Entity(repositoryClass: YearRepository::class)]
  12. class Year
  13. {
  14.     use TimestampableEntity;
  15.     #[ORM\Id]
  16.     #[ORM\GeneratedValue]
  17.     #[ORM\Column]
  18.     private ?int $id = null;
  20.     #[ORM\Column]
  21.     private ?int $year = null;
  23.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: PaymentPeriod::class, orphanRemoval: true)]
  24.     private Collection $paymentPeriods;
  26.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Plan::class, orphanRemoval: true)]
  27.     private Collection $plans;
  29.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: CreditRule::class, orphanRemoval: true)]
  30.     private Collection $creditRules;
  32.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: CommissionRule::class, orphanRemoval: true)]
  33.     private Collection $commissionRules;
  35.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: RuleConditionOld::class, orphanRemoval: true)]
  36.     private Collection $ruleConditionsOld;
  38.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: AttainmentMeasure::class, orphanRemoval: true)]
  39.     private Collection $attainmentMeasures;
  41.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: CreditRuleResultFormula::class, orphanRemoval: true)]
  42.     private Collection $creditRuleResultFormulas;
  44.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: CreditType::class, orphanRemoval: true)]
  45.     private Collection $creditTypes;
  49.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Quota::class, orphanRemoval: true)]
  50.     private Collection $quotas;
  52.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: QuotaTier::class, orphanRemoval: true)]
  53.     private Collection $quotaTiers;
  55.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: RateTable::class, orphanRemoval: true)]
  56.     private Collection $rateTables;
  58.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: RateTableTier::class, orphanRemoval: true)]
  59.     private Collection $rateTableTiers;
  61.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Title::class, orphanRemoval: true)]
  62.     private Collection $titles;
  64.     public function __construct()
  65.     {
  66.         $this->paymentPeriods = new ArrayCollection();
  67.         $this->plans = new ArrayCollection();
  68.         $this->creditRules = new ArrayCollection();
  69.         $this->commissionRules = new ArrayCollection();
  70.         $this->ruleConditionsOld = new ArrayCollection();
  71.         $this->attainmentMeasures = new ArrayCollection();
  72.         $this->creditRuleResultFormulas = new ArrayCollection();
  73.         $this->creditTypes = new ArrayCollection();
  74.         $this->quotas = new ArrayCollection();
  75.         $this->quotaTiers = new ArrayCollection();
  76.         $this->rateTables = new ArrayCollection();
  77.         $this->rateTableTiers = new ArrayCollection();
  78.         $this->titles = new ArrayCollection();
  79.     }
  81.     public function getId(): ?int
  82.     {
  83.         return $this->id;
  84.     }
  86.     public function getYear(): ?int
  87.     {
  88.         return $this->year;
  89.     }
  91.     public function setYear(int $year): self
  92.     {
  93.         $this->year = $year;
  95.         return $this;
  96.     }
  98.     /**
  99.      * @return Collection<int, PaymentPeriod>
  100.      */
  101.     public function getPaymentPeriods(): Collection
  102.     {
  103.         return $this->paymentPeriods;
  104.     }
  106.     public function addPaymentPeriod(PaymentPeriod $paymentPeriod): self
  107.     {
  108.         if (!$this->paymentPeriods->contains($paymentPeriod)) {
  109.             $this->paymentPeriods->add($paymentPeriod);
  110.             $paymentPeriod->setYear($this);
  111.         }
  113.         return $this;
  114.     }
  116.     public function removePaymentPeriod(PaymentPeriod $paymentPeriod): self
  117.     {
  118.         if ($this->paymentPeriods->removeElement($paymentPeriod)) {
  119.             // set the owning side to null (unless already changed)
  120.             if ($paymentPeriod->getYear() === $this) {
  121.                 $paymentPeriod->setYear(null);
  122.             }
  123.         }
  125.         return $this;
  126.     }
  128.     /**
  129.      * @return Collection<int, Plan>
  130.      */
  131.     public function getPlans(): Collection
  132.     {
  133.         return $this->plans;
  134.     }
  136.     public function addPlan(Plan $plan): self
  137.     {
  138.         if (!$this->plans->contains($plan)) {
  139.             $this->plans->add($plan);
  140.             $plan->setYear($this);
  141.         }
  143.         return $this;
  144.     }
  146.     public function removePlan(Plan $plan): self
  147.     {
  148.         if ($this->plans->removeElement($plan)) {
  149.             // set the owning side to null (unless already changed)
  150.             if ($plan->getYear() === $this) {
  151.                 $plan->setYear(null);
  152.             }
  153.         }
  155.         return $this;
  156.     }
  158.     /**
  159.      * @return Collection<int, CreditRule>
  160.      */
  161.     public function getCreditRules(): Collection
  162.     {
  163.         return $this->creditRules;
  164.     }
  166.     public function addCreditRule(CreditRule $creditRule): self
  167.     {
  168.         if (!$this->creditRules->contains($creditRule)) {
  169.             $this->creditRules->add($creditRule);
  170.             $creditRule->setYear($this);
  171.         }
  173.         return $this;
  174.     }
  176.     public function removeCreditRule(CreditRule $creditRule): self
  177.     {
  178.         if ($this->creditRules->removeElement($creditRule)) {
  179.             // set the owning side to null (unless already changed)
  180.             if ($creditRule->getYear() === $this) {
  181.                 $creditRule->setYear(null);
  182.             }
  183.         }
  185.         return $this;
  186.     }
  188.     /**
  189.      * @return Collection<int, CommissionRule>
  190.      */
  191.     public function getCommissionRules(): Collection
  192.     {
  193.         return $this->commissionRules;
  194.     }
  196.     public function addCommissionRule(CommissionRule $commissionRule): self
  197.     {
  198.         if (!$this->commissionRules->contains($commissionRule)) {
  199.             $this->commissionRules->add($commissionRule);
  200.             $commissionRule->setYear($this);
  201.         }
  203.         return $this;
  204.     }
  206.     public function removeCommissionRule(CommissionRule $commissionRule): self
  207.     {
  208.         if ($this->commissionRules->removeElement($commissionRule)) {
  209.             // set the owning side to null (unless already changed)
  210.             if ($commissionRule->getYear() === $this) {
  211.                 $commissionRule->setYear(null);
  212.             }
  213.         }
  215.         return $this;
  216.     }
  218.     /**
  219.      * @return Collection<int, RuleConditionOld>
  220.      */
  221.     public function getRuleConditions(): Collection
  222.     {
  223.         return $this->ruleConditionsOld;
  224.     }
  226.     public function addRuleCondition(RuleConditionOld $ruleCondition): self
  227.     {
  228.         if (!$this->ruleConditionsOld->contains($ruleCondition)) {
  229.             $this->ruleConditionsOld->add($ruleCondition);
  230.             $ruleCondition->setYear($this);
  231.         }
  233.         return $this;
  234.     }
  236.     public function removeRuleCondition(RuleConditionOld $ruleCondition): self
  237.     {
  238.         if ($this->ruleConditionsOld->removeElement($ruleCondition)) {
  239.             // set the owning side to null (unless already changed)
  240.             if ($ruleCondition->getYear() === $this) {
  241.                 $ruleCondition->setYear(null);
  242.             }
  243.         }
  245.         return $this;
  246.     }
  248.     /**
  249.      * @return Collection<int, AttainmentMeasure>
  250.      */
  251.     public function getAttainmentMeasures(): Collection
  252.     {
  253.         return $this->attainmentMeasures;
  254.     }
  256.     public function addAttainmentMeasure(AttainmentMeasure $attainmentMeasure): self
  257.     {
  258.         if (!$this->attainmentMeasures->contains($attainmentMeasure)) {
  259.             $this->attainmentMeasures->add($attainmentMeasure);
  260.             $attainmentMeasure->setYear($this);
  261.         }
  263.         return $this;
  264.     }
  266.     public function removeAttainmentMeasure(AttainmentMeasure $attainmentMeasure): self
  267.     {
  268.         if ($this->attainmentMeasures->removeElement($attainmentMeasure)) {
  269.             // set the owning side to null (unless already changed)
  270.             if ($attainmentMeasure->getYear() === $this) {
  271.                 $attainmentMeasure->setYear(null);
  272.             }
  273.         }
  275.         return $this;
  276.     }
  278.     /**
  279.      * @return Collection<int, CreditRuleResultFormula>
  280.      */
  281.     public function getCreditRuleResultFormulas(): Collection
  282.     {
  283.         return $this->creditRuleResultFormulas;
  284.     }
  286.     public function addCreditRuleResultFormula(CreditRuleResultFormula $creditRuleResultFormula): self
  287.     {
  288.         if (!$this->creditRuleResultFormulas->contains($creditRuleResultFormula)) {
  289.             $this->creditRuleResultFormulas->add($creditRuleResultFormula);
  290.             $creditRuleResultFormula->setYear($this);
  291.         }
  293.         return $this;
  294.     }
  296.     public function removeCreditRuleResultFormula(CreditRuleResultFormula $creditRuleResultFormula): self
  297.     {
  298.         if ($this->creditRuleResultFormulas->removeElement($creditRuleResultFormula)) {
  299.             // set the owning side to null (unless already changed)
  300.             if ($creditRuleResultFormula->getYear() === $this) {
  301.                 $creditRuleResultFormula->setYear(null);
  302.             }
  303.         }
  305.         return $this;
  306.     }
  308.     /**
  309.      * @return Collection<int, CreditType>
  310.      */
  311.     public function getCreditTypes(): Collection
  312.     {
  313.         return $this->creditTypes;
  314.     }
  316.     public function addCreditType(CreditType $creditType): self
  317.     {
  318.         if (!$this->creditTypes->contains($creditType)) {
  319.             $this->creditTypes->add($creditType);
  320.             $creditType->setYear($this);
  321.         }
  323.         return $this;
  324.     }
  326.     public function removeCreditType(CreditType $creditType): self
  327.     {
  328.         if ($this->creditTypes->removeElement($creditType)) {
  329.             // set the owning side to null (unless already changed)
  330.             if ($creditType->getYear() === $this) {
  331.                 $creditType->setYear(null);
  332.             }
  333.         }
  335.         return $this;
  336.     }
  338.     /**
  339.      * @return Collection<int, Quota>
  340.      */
  341.     public function getQuotas(): Collection
  342.     {
  343.         return $this->quotas;
  344.     }
  346.     public function addQuota(Quota $quota): self
  347.     {
  348.         if (!$this->quotas->contains($quota)) {
  349.             $this->quotas->add($quota);
  350.             $quota->setYear($this);
  351.         }
  353.         return $this;
  354.     }
  356.     public function removeQuota(Quota $quota): self
  357.     {
  358.         if ($this->quotas->removeElement($quota)) {
  359.             // set the owning side to null (unless already changed)
  360.             if ($quota->getYear() === $this) {
  361.                 $quota->setYear(null);
  362.             }
  363.         }
  365.         return $this;
  366.     }
  368.     /**
  369.      * @return Collection<int, QuotaTier>
  370.      */
  371.     public function getQuotaTiers(): Collection
  372.     {
  373.         return $this->quotaTiers;
  374.     }
  376.     public function addQuotaTier(QuotaTier $quotaTier): self
  377.     {
  378.         if (!$this->quotaTiers->contains($quotaTier)) {
  379.             $this->quotaTiers->add($quotaTier);
  380.             $quotaTier->setYear($this);
  381.         }
  383.         return $this;
  384.     }
  386.     public function removeQuotaTier(QuotaTier $quotaTier): self
  387.     {
  388.         if ($this->quotaTiers->removeElement($quotaTier)) {
  389.             // set the owning side to null (unless already changed)
  390.             if ($quotaTier->getYear() === $this) {
  391.                 $quotaTier->setYear(null);
  392.             }
  393.         }
  395.         return $this;
  396.     }
  398.     /**
  399.      * @return Collection<int, RateTable>
  400.      */
  401.     public function getRateTables(): Collection
  402.     {
  403.         return $this->rateTables;
  404.     }
  406.     public function addRateTable(RateTable $rateTable): self
  407.     {
  408.         if (!$this->rateTables->contains($rateTable)) {
  409.             $this->rateTables->add($rateTable);
  410.             $rateTable->setYear($this);
  411.         }
  413.         return $this;
  414.     }
  416.     public function removeRateTable(RateTable $rateTable): self
  417.     {
  418.         if ($this->rateTables->removeElement($rateTable)) {
  419.             // set the owning side to null (unless already changed)
  420.             if ($rateTable->getYear() === $this) {
  421.                 $rateTable->setYear(null);
  422.             }
  423.         }
  425.         return $this;
  426.     }
  428.     /**
  429.      * @return Collection<int, RateTableTier>
  430.      */
  431.     public function getRateTableTiers(): Collection
  432.     {
  433.         return $this->rateTableTiers;
  434.     }
  436.     public function addRateTableTier(RateTableTier $rateTableTier): self
  437.     {
  438.         if (!$this->rateTableTiers->contains($rateTableTier)) {
  439.             $this->rateTableTiers->add($rateTableTier);
  440.             $rateTableTier->setYear($this);
  441.         }
  443.         return $this;
  444.     }
  446.     public function removeRateTableTier(RateTableTier $rateTableTier): self
  447.     {
  448.         if ($this->rateTableTiers->removeElement($rateTableTier)) {
  449.             // set the owning side to null (unless already changed)
  450.             if ($rateTableTier->getYear() === $this) {
  451.                 $rateTableTier->setYear(null);
  452.             }
  453.         }
  455.         return $this;
  456.     }
  458.     /**
  459.      * @return Collection<int, Title>
  460.      */
  461.     public function getTitles(): Collection
  462.     {
  463.         return $this->titles;
  464.     }
  466.     public function addTitle(Title $title): self
  467.     {
  468.         if (!$this->titles->contains($title)) {
  469.             $this->titles->add($title);
  470.             $title->setYear($this);
  471.         }
  473.         return $this;
  474.     }
  476.     public function removeTitle(Title $title): self
  477.     {
  478.         if ($this->titles->removeElement($title)) {
  479.             // set the owning side to null (unless already changed)
  480.             if ($title->getYear() === $this) {
  481.                 $title->setYear(null);
  482.             }
  483.         }
  485.         return $this;
  486.     }
  488.     public function __toString() {
  489.         return (string) $this->year;
  490.     }
  491. }