src/Entity/Language.php line 14

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use Doctrine\Common\Collections\ArrayCollection;
  6. use Doctrine\Common\Collections\Collection;
  7. use Doctrine\DBAL\Types\Types;
  8. use Doctrine\ORM\Mapping as ORM;
  10. /**
  11.  * @ORM\Table(name="fs_language")
  12.  * @ORM\Entity
  13.  */
  14. class Language
  15. {
  16.     public function __toString(){
  17.         return $this->sign;
  18.     }
  20.     /**
  21.      * @ORM\Column(name="id", type="bigint")
  22.      * @ORM\Id
  23.      * @ORM\GeneratedValue(strategy="AUTO")
  24.      */
  25.     protected $id;
  26.     
  27.     /**
  28.      * @ORM\Column(name="name", type="string")
  29.      */
  30.     protected $name;
  31.     
  32.     /**
  33.      * @ORM\Column(name="sign", type="string")
  34.      */
  35.     protected $sign;
  36.             
  37.     // ONE TO MANY
  38.         /**
  39.          * @ORM\OneToMany(targetEntity="App\Entity\BaseDetailTranslation", mappedBy="language")
  40.          */
  41.         private $baseDetail;
  43.         /**
  44.          * @ORM\OneToMany(targetEntity="App\Entity\BaseDetailCategoryTranslation", mappedBy="language")
  45.          */
  46.         private $baseDetailCategories;
  48.         /**
  49.          * @ORM\OneToMany(targetEntity="App\Entity\BoatTranslation", mappedBy="language")
  50.          */
  51.         private $boats;
  53.         /**
  54.          * @ORM\OneToMany(targetEntity="App\Entity\BoatCategoryTranslation", mappedBy="language")
  55.          */
  56.         private $boatCategories;
  58.         /**
  59.          * @ORM\OneToMany(targetEntity="App\Entity\BoatDocumentTranslation", mappedBy="language")
  60.          */
  61.         private $boatDocuments;
  62.         
  63.         /**
  64.          * @ORM\OneToMany(targetEntity="App\Entity\BoatEquipmentTranslation", mappedBy="language")
  65.          */
  66.         private $boatEquipments;
  67.         
  68.         /**
  69.          * @ORM\OneToMany(targetEntity="App\Entity\BoatEquipmentCategoryTranslation", mappedBy="language")
  70.          */
  71.         private $boatEquipmentCategories;
  72.         
  73.         /**
  74.          * @ORM\OneToMany(targetEntity="App\Entity\BoatModelTranslation", mappedBy="language")
  75.          */
  76.         private $boatModels;
  77.         
  78.         /**
  79.          * @ORM\OneToMany(targetEntity="App\Entity\BoatServiceTranslation", mappedBy="language")
  80.          */
  81.         private $boatServices;
  82.         
  83.         /**
  84.          * @ORM\OneToMany(targetEntity="App\Entity\BoatServiceCategoryTranslation", mappedBy="language")
  85.          */
  86.         private $boatServiceCategories;
  88.         /**
  89.          * @ORM\OneToMany(targetEntity="App\Entity\BoatTypeTranslation", mappedBy="language")
  90.          */
  91.         private $boatTypes;
  92.         
  93.         /**
  94.          * @ORM\OneToMany(targetEntity="App\Entity\CountryTranslation", mappedBy="language")
  95.          */
  96.         private $countries;
  98.         /**
  99.          * @ORM\OneToMany(targetEntity="App\Entity\CatalogueTranslation", mappedBy="language")
  100.          */
  101.         private $catalogues;
  102.         
  103.         /**
  104.          * @ORM\OneToMany(targetEntity="App\Entity\FaqTranslation", mappedBy="language")
  105.          */
  106.         private $faqs;
  108.         /**
  109.          * @ORM\OneToMany(targetEntity="App\Entity\FaqCategoryTranslation", mappedBy="language")
  110.          */
  111.         private $faqCategories;
  113.         /**
  114.          * @ORM\OneToMany(targetEntity="App\Entity\HelpTranslation", mappedBy="language")
  115.          */
  116.         private $helps;
  118.         /**
  119.          * @ORM\OneToMany(targetEntity="App\Entity\ReservationRequestTypeTranslation", mappedBy="language")
  120.          */
  121.         private $reservationRequestTypes;
  122.         
  123.         /**
  124.          * @ORM\OneToMany(targetEntity="App\Entity\ReservationTypeTranslation", mappedBy="language")
  125.          */
  126.         private $reservationTypes;
  127.         
  128.         /**
  129.          * @ORM\OneToMany(targetEntity="App\Entity\TutorialTranslation", mappedBy="language")
  130.          */
  131.         private $tutorials;
  132.         
  133.         /**
  134.          * @ORM\OneToMany(targetEntity="App\Entity\TutorialCategoryTranslation", mappedBy="language")
  135.          */
  136.         private $tutorialCategories;
  137.     //
  139.     // MANY TO MANY
  140.         /**
  141.          * @ORM\ManyToMany(targetEntity="App\Entity\Dealer", mappedBy="languages")
  142.          */
  143.         private $dealers;
  145.         public function __construct()
  146.         {
  147.             $this->baseDetail = new ArrayCollection();
  148.             $this->baseDetailCategories = new ArrayCollection();
  149.             $this->boats = new ArrayCollection();
  150.             $this->boatCategories = new ArrayCollection();
  151.             $this->boatDocuments = new ArrayCollection();
  152.             $this->boatEquipments = new ArrayCollection();
  153.             $this->boatEquipmentCategories = new ArrayCollection();
  154.             $this->boatModels = new ArrayCollection();
  155.             $this->boatServices = new ArrayCollection();
  156.             $this->boatServiceCategories = new ArrayCollection();
  157.             $this->boatTypes = new ArrayCollection();
  158.             $this->countries = new ArrayCollection();
  159.             $this->catalogues = new ArrayCollection();
  160.             $this->faqs = new ArrayCollection();
  161.             $this->faqCategories = new ArrayCollection();
  162.             $this->helps = new ArrayCollection();
  163.             $this->reservationRequestTypes = new ArrayCollection();
  164.             $this->reservationTypes = new ArrayCollection();
  165.             $this->tutorials = new ArrayCollection();
  166.             $this->tutorialCategories = new ArrayCollection();
  167.             $this->dealers = new ArrayCollection();
  168.         }
  169.     //
  171.     public function getId(): ?string
  172.     {
  173.         return $this->id;
  174.     }
  176.     public function getName(): ?string
  177.     {
  178.         return $this->name;
  179.     }
  181.     public function setName(string $name): static
  182.     {
  183.         $this->name = $name;
  185.         return $this;
  186.     }
  188.     public function getSign(): ?string
  189.     {
  190.         return $this->sign;
  191.     }
  193.     public function setSign(string $sign): static
  194.     {
  195.         $this->sign = $sign;
  197.         return $this;
  198.     }
  200.     /**
  201.      * @return Collection<int, BaseDetailTranslation>
  202.      */
  203.     public function getBaseDetail(): Collection
  204.     {
  205.         return $this->baseDetail;
  206.     }
  208.     public function addBaseDetail(BaseDetailTranslation $baseDetail): static
  209.     {
  210.         if (!$this->baseDetail->contains($baseDetail)) {
  211.             $this->baseDetail->add($baseDetail);
  212.             $baseDetail->setLanguage($this);
  213.         }
  215.         return $this;
  216.     }
  218.     public function removeBaseDetail(BaseDetailTranslation $baseDetail): static
  219.     {
  220.         if ($this->baseDetail->removeElement($baseDetail)) {
  221.             // set the owning side to null (unless already changed)
  222.             if ($baseDetail->getLanguage() === $this) {
  223.                 $baseDetail->setLanguage(null);
  224.             }
  225.         }
  227.         return $this;
  228.     }
  230.     /**
  231.      * @return Collection<int, BaseDetailCategoryTranslation>
  232.      */
  233.     public function getBaseDetailCategories(): Collection
  234.     {
  235.         return $this->baseDetailCategories;
  236.     }
  238.     public function addBaseDetailCategory(BaseDetailCategoryTranslation $baseDetailCategory): static
  239.     {
  240.         if (!$this->baseDetailCategories->contains($baseDetailCategory)) {
  241.             $this->baseDetailCategories->add($baseDetailCategory);
  242.             $baseDetailCategory->setLanguage($this);
  243.         }
  245.         return $this;
  246.     }
  248.     public function removeBaseDetailCategory(BaseDetailCategoryTranslation $baseDetailCategory): static
  249.     {
  250.         if ($this->baseDetailCategories->removeElement($baseDetailCategory)) {
  251.             // set the owning side to null (unless already changed)
  252.             if ($baseDetailCategory->getLanguage() === $this) {
  253.                 $baseDetailCategory->setLanguage(null);
  254.             }
  255.         }
  257.         return $this;
  258.     }
  260.     /**
  261.      * @return Collection<int, BoatTranslation>
  262.      */
  263.     public function getBoats(): Collection
  264.     {
  265.         return $this->boats;
  266.     }
  268.     public function addBoat(BoatTranslation $boat): static
  269.     {
  270.         if (!$this->boats->contains($boat)) {
  271.             $this->boats->add($boat);
  272.             $boat->setLanguage($this);
  273.         }
  275.         return $this;
  276.     }
  278.     public function removeBoat(BoatTranslation $boat): static
  279.     {
  280.         if ($this->boats->removeElement($boat)) {
  281.             // set the owning side to null (unless already changed)
  282.             if ($boat->getLanguage() === $this) {
  283.                 $boat->setLanguage(null);
  284.             }
  285.         }
  287.         return $this;
  288.     }
  290.     /**
  291.      * @return Collection<int, BoatCategoryTranslation>
  292.      */
  293.     public function getBoatCategories(): Collection
  294.     {
  295.         return $this->boatCategories;
  296.     }
  298.     public function addBoatCategory(BoatCategoryTranslation $boatCategory): static
  299.     {
  300.         if (!$this->boatCategories->contains($boatCategory)) {
  301.             $this->boatCategories->add($boatCategory);
  302.             $boatCategory->setLanguage($this);
  303.         }
  305.         return $this;
  306.     }
  308.     public function removeBoatCategory(BoatCategoryTranslation $boatCategory): static
  309.     {
  310.         if ($this->boatCategories->removeElement($boatCategory)) {
  311.             // set the owning side to null (unless already changed)
  312.             if ($boatCategory->getLanguage() === $this) {
  313.                 $boatCategory->setLanguage(null);
  314.             }
  315.         }
  317.         return $this;
  318.     }
  320.     /**
  321.      * @return Collection<int, BoatDocumentTranslation>
  322.      */
  323.     public function getBoatDocuments(): Collection
  324.     {
  325.         return $this->boatDocuments;
  326.     }
  328.     public function addBoatDocument(BoatDocumentTranslation $boatDocument): static
  329.     {
  330.         if (!$this->boatDocuments->contains($boatDocument)) {
  331.             $this->boatDocuments->add($boatDocument);
  332.             $boatDocument->setLanguage($this);
  333.         }
  335.         return $this;
  336.     }
  338.     public function removeBoatDocument(BoatDocumentTranslation $boatDocument): static
  339.     {
  340.         if ($this->boatDocuments->removeElement($boatDocument)) {
  341.             // set the owning side to null (unless already changed)
  342.             if ($boatDocument->getLanguage() === $this) {
  343.                 $boatDocument->setLanguage(null);
  344.             }
  345.         }
  347.         return $this;
  348.     }
  350.     /**
  351.      * @return Collection<int, BoatEquipmentTranslation>
  352.      */
  353.     public function getBoatEquipments(): Collection
  354.     {
  355.         return $this->boatEquipments;
  356.     }
  358.     public function addBoatEquipment(BoatEquipmentTranslation $boatEquipment): static
  359.     {
  360.         if (!$this->boatEquipments->contains($boatEquipment)) {
  361.             $this->boatEquipments->add($boatEquipment);
  362.             $boatEquipment->setLanguage($this);
  363.         }
  365.         return $this;
  366.     }
  368.     public function removeBoatEquipment(BoatEquipmentTranslation $boatEquipment): static
  369.     {
  370.         if ($this->boatEquipments->removeElement($boatEquipment)) {
  371.             // set the owning side to null (unless already changed)
  372.             if ($boatEquipment->getLanguage() === $this) {
  373.                 $boatEquipment->setLanguage(null);
  374.             }
  375.         }
  377.         return $this;
  378.     }
  380.     /**
  381.      * @return Collection<int, BoatEquipmentCategoryTranslation>
  382.      */
  383.     public function getBoatEquipmentCategories(): Collection
  384.     {
  385.         return $this->boatEquipmentCategories;
  386.     }
  388.     public function addBoatEquipmentCategory(BoatEquipmentCategoryTranslation $boatEquipmentCategory): static
  389.     {
  390.         if (!$this->boatEquipmentCategories->contains($boatEquipmentCategory)) {
  391.             $this->boatEquipmentCategories->add($boatEquipmentCategory);
  392.             $boatEquipmentCategory->setLanguage($this);
  393.         }
  395.         return $this;
  396.     }
  398.     public function removeBoatEquipmentCategory(BoatEquipmentCategoryTranslation $boatEquipmentCategory): static
  399.     {
  400.         if ($this->boatEquipmentCategories->removeElement($boatEquipmentCategory)) {
  401.             // set the owning side to null (unless already changed)
  402.             if ($boatEquipmentCategory->getLanguage() === $this) {
  403.                 $boatEquipmentCategory->setLanguage(null);
  404.             }
  405.         }
  407.         return $this;
  408.     }
  410.     /**
  411.      * @return Collection<int, BoatModelTranslation>
  412.      */
  413.     public function getBoatModels(): Collection
  414.     {
  415.         return $this->boatModels;
  416.     }
  418.     public function addBoatModel(BoatModelTranslation $boatModel): static
  419.     {
  420.         if (!$this->boatModels->contains($boatModel)) {
  421.             $this->boatModels->add($boatModel);
  422.             $boatModel->setLanguage($this);
  423.         }
  425.         return $this;
  426.     }
  428.     public function removeBoatModel(BoatModelTranslation $boatModel): static
  429.     {
  430.         if ($this->boatModels->removeElement($boatModel)) {
  431.             // set the owning side to null (unless already changed)
  432.             if ($boatModel->getLanguage() === $this) {
  433.                 $boatModel->setLanguage(null);
  434.             }
  435.         }
  437.         return $this;
  438.     }
  440.     /**
  441.      * @return Collection<int, BoatServiceTranslation>
  442.      */
  443.     public function getBoatServices(): Collection
  444.     {
  445.         return $this->boatServices;
  446.     }
  448.     public function addBoatService(BoatServiceTranslation $boatService): static
  449.     {
  450.         if (!$this->boatServices->contains($boatService)) {
  451.             $this->boatServices->add($boatService);
  452.             $boatService->setLanguage($this);
  453.         }
  455.         return $this;
  456.     }
  458.     public function removeBoatService(BoatServiceTranslation $boatService): static
  459.     {
  460.         if ($this->boatServices->removeElement($boatService)) {
  461.             // set the owning side to null (unless already changed)
  462.             if ($boatService->getLanguage() === $this) {
  463.                 $boatService->setLanguage(null);
  464.             }
  465.         }
  467.         return $this;
  468.     }
  470.     /**
  471.      * @return Collection<int, BoatServiceCategoryTranslation>
  472.      */
  473.     public function getBoatServiceCategories(): Collection
  474.     {
  475.         return $this->boatServiceCategories;
  476.     }
  478.     public function addBoatServiceCategory(BoatServiceCategoryTranslation $boatServiceCategory): static
  479.     {
  480.         if (!$this->boatServiceCategories->contains($boatServiceCategory)) {
  481.             $this->boatServiceCategories->add($boatServiceCategory);
  482.             $boatServiceCategory->setLanguage($this);
  483.         }
  485.         return $this;
  486.     }
  488.     public function removeBoatServiceCategory(BoatServiceCategoryTranslation $boatServiceCategory): static
  489.     {
  490.         if ($this->boatServiceCategories->removeElement($boatServiceCategory)) {
  491.             // set the owning side to null (unless already changed)
  492.             if ($boatServiceCategory->getLanguage() === $this) {
  493.                 $boatServiceCategory->setLanguage(null);
  494.             }
  495.         }
  497.         return $this;
  498.     }
  500.     /**
  501.      * @return Collection<int, BoatTypeTranslation>
  502.      */
  503.     public function getBoatTypes(): Collection
  504.     {
  505.         return $this->boatTypes;
  506.     }
  508.     public function addBoatType(BoatTypeTranslation $boatType): static
  509.     {
  510.         if (!$this->boatTypes->contains($boatType)) {
  511.             $this->boatTypes->add($boatType);
  512.             $boatType->setLanguage($this);
  513.         }
  515.         return $this;
  516.     }
  518.     public function removeBoatType(BoatTypeTranslation $boatType): static
  519.     {
  520.         if ($this->boatTypes->removeElement($boatType)) {
  521.             // set the owning side to null (unless already changed)
  522.             if ($boatType->getLanguage() === $this) {
  523.                 $boatType->setLanguage(null);
  524.             }
  525.         }
  527.         return $this;
  528.     }
  530.     /**
  531.      * @return Collection<int, CountryTranslation>
  532.      */
  533.     public function getCountries(): Collection
  534.     {
  535.         return $this->countries;
  536.     }
  538.     public function addCountry(CountryTranslation $country): static
  539.     {
  540.         if (!$this->countries->contains($country)) {
  541.             $this->countries->add($country);
  542.             $country->setLanguage($this);
  543.         }
  545.         return $this;
  546.     }
  548.     public function removeCountry(CountryTranslation $country): static
  549.     {
  550.         if ($this->countries->removeElement($country)) {
  551.             // set the owning side to null (unless already changed)
  552.             if ($country->getLanguage() === $this) {
  553.                 $country->setLanguage(null);
  554.             }
  555.         }
  557.         return $this;
  558.     }
  560.     /**
  561.      * @return Collection<int, CatalogueTranslation>
  562.      */
  563.     public function getCatalogues(): Collection
  564.     {
  565.         return $this->catalogues;
  566.     }
  568.     public function addCatalogue(CatalogueTranslation $catalogue): static
  569.     {
  570.         if (!$this->catalogues->contains($catalogue)) {
  571.             $this->catalogues->add($catalogue);
  572.             $catalogue->setLanguage($this);
  573.         }
  575.         return $this;
  576.     }
  578.     public function removeCatalogue(CatalogueTranslation $catalogue): static
  579.     {
  580.         if ($this->catalogues->removeElement($catalogue)) {
  581.             // set the owning side to null (unless already changed)
  582.             if ($catalogue->getLanguage() === $this) {
  583.                 $catalogue->setLanguage(null);
  584.             }
  585.         }
  587.         return $this;
  588.     }
  590.     /**
  591.      * @return Collection<int, FaqTranslation>
  592.      */
  593.     public function getFaqs(): Collection
  594.     {
  595.         return $this->faqs;
  596.     }
  598.     public function addFaq(FaqTranslation $faq): static
  599.     {
  600.         if (!$this->faqs->contains($faq)) {
  601.             $this->faqs->add($faq);
  602.             $faq->setLanguage($this);
  603.         }
  605.         return $this;
  606.     }
  608.     public function removeFaq(FaqTranslation $faq): static
  609.     {
  610.         if ($this->faqs->removeElement($faq)) {
  611.             // set the owning side to null (unless already changed)
  612.             if ($faq->getLanguage() === $this) {
  613.                 $faq->setLanguage(null);
  614.             }
  615.         }
  617.         return $this;
  618.     }
  620.     /**
  621.      * @return Collection<int, FaqCategoryTranslation>
  622.      */
  623.     public function getFaqCategories(): Collection
  624.     {
  625.         return $this->faqCategories;
  626.     }
  628.     public function addFaqCategory(FaqCategoryTranslation $faqCategory): static
  629.     {
  630.         if (!$this->faqCategories->contains($faqCategory)) {
  631.             $this->faqCategories->add($faqCategory);
  632.             $faqCategory->setLanguage($this);
  633.         }
  635.         return $this;
  636.     }
  638.     public function removeFaqCategory(FaqCategoryTranslation $faqCategory): static
  639.     {
  640.         if ($this->faqCategories->removeElement($faqCategory)) {
  641.             // set the owning side to null (unless already changed)
  642.             if ($faqCategory->getLanguage() === $this) {
  643.                 $faqCategory->setLanguage(null);
  644.             }
  645.         }
  647.         return $this;
  648.     }
  650.     /**
  651.      * @return Collection<int, HelpTranslation>
  652.      */
  653.     public function getHelps(): Collection
  654.     {
  655.         return $this->helps;
  656.     }
  658.     public function addHelp(HelpTranslation $help): static
  659.     {
  660.         if (!$this->helps->contains($help)) {
  661.             $this->helps->add($help);
  662.             $help->setLanguage($this);
  663.         }
  665.         return $this;
  666.     }
  668.     public function removeHelp(HelpTranslation $help): static
  669.     {
  670.         if ($this->helps->removeElement($help)) {
  671.             // set the owning side to null (unless already changed)
  672.             if ($help->getLanguage() === $this) {
  673.                 $help->setLanguage(null);
  674.             }
  675.         }
  677.         return $this;
  678.     }
  680.     /**
  681.      * @return Collection<int, ReservationRequestTypeTranslation>
  682.      */
  683.     public function getReservationRequestTypes(): Collection
  684.     {
  685.         return $this->reservationRequestTypes;
  686.     }
  688.     public function addReservationRequestType(ReservationRequestTypeTranslation $reservationRequestType): static
  689.     {
  690.         if (!$this->reservationRequestTypes->contains($reservationRequestType)) {
  691.             $this->reservationRequestTypes->add($reservationRequestType);
  692.             $reservationRequestType->setLanguage($this);
  693.         }
  695.         return $this;
  696.     }
  698.     public function removeReservationRequestType(ReservationRequestTypeTranslation $reservationRequestType): static
  699.     {
  700.         if ($this->reservationRequestTypes->removeElement($reservationRequestType)) {
  701.             // set the owning side to null (unless already changed)
  702.             if ($reservationRequestType->getLanguage() === $this) {
  703.                 $reservationRequestType->setLanguage(null);
  704.             }
  705.         }
  707.         return $this;
  708.     }
  710.     /**
  711.      * @return Collection<int, ReservationTypeTranslation>
  712.      */
  713.     public function getReservationTypes(): Collection
  714.     {
  715.         return $this->reservationTypes;
  716.     }
  718.     public function addReservationType(ReservationTypeTranslation $reservationType): static
  719.     {
  720.         if (!$this->reservationTypes->contains($reservationType)) {
  721.             $this->reservationTypes->add($reservationType);
  722.             $reservationType->setLanguage($this);
  723.         }
  725.         return $this;
  726.     }
  728.     public function removeReservationType(ReservationTypeTranslation $reservationType): static
  729.     {
  730.         if ($this->reservationTypes->removeElement($reservationType)) {
  731.             // set the owning side to null (unless already changed)
  732.             if ($reservationType->getLanguage() === $this) {
  733.                 $reservationType->setLanguage(null);
  734.             }
  735.         }
  737.         return $this;
  738.     }
  740.     /**
  741.      * @return Collection<int, TutorialTranslation>
  742.      */
  743.     public function getTutorials(): Collection
  744.     {
  745.         return $this->tutorials;
  746.     }
  748.     public function addTutorial(TutorialTranslation $tutorial): static
  749.     {
  750.         if (!$this->tutorials->contains($tutorial)) {
  751.             $this->tutorials->add($tutorial);
  752.             $tutorial->setLanguage($this);
  753.         }
  755.         return $this;
  756.     }
  758.     public function removeTutorial(TutorialTranslation $tutorial): static
  759.     {
  760.         if ($this->tutorials->removeElement($tutorial)) {
  761.             // set the owning side to null (unless already changed)
  762.             if ($tutorial->getLanguage() === $this) {
  763.                 $tutorial->setLanguage(null);
  764.             }
  765.         }
  767.         return $this;
  768.     }
  770.     /**
  771.      * @return Collection<int, TutorialCategoryTranslation>
  772.      */
  773.     public function getTutorialCategories(): Collection
  774.     {
  775.         return $this->tutorialCategories;
  776.     }
  778.     public function addTutorialCategory(TutorialCategoryTranslation $tutorialCategory): static
  779.     {
  780.         if (!$this->tutorialCategories->contains($tutorialCategory)) {
  781.             $this->tutorialCategories->add($tutorialCategory);
  782.             $tutorialCategory->setLanguage($this);
  783.         }
  785.         return $this;
  786.     }
  788.     public function removeTutorialCategory(TutorialCategoryTranslation $tutorialCategory): static
  789.     {
  790.         if ($this->tutorialCategories->removeElement($tutorialCategory)) {
  791.             // set the owning side to null (unless already changed)
  792.             if ($tutorialCategory->getLanguage() === $this) {
  793.                 $tutorialCategory->setLanguage(null);
  794.             }
  795.         }
  797.         return $this;
  798.     }
  800.     /**
  801.      * @return Collection<int, Dealer>
  802.      */
  803.     public function getDealers(): Collection
  804.     {
  805.         return $this->dealers;
  806.     }
  808.     public function addDealer(Dealer $dealer): static
  809.     {
  810.         if (!$this->dealers->contains($dealer)) {
  811.             $this->dealers->add($dealer);
  812.             $dealer->addLanguage($this);
  813.         }
  815.         return $this;
  816.     }
  818.     public function removeDealer(Dealer $dealer): static
  819.     {
  820.         if ($this->dealers->removeElement($dealer)) {
  821.             $dealer->removeLanguage($this);
  822.         }
  824.         return $this;
  825.     }
  826. }