src/CasinoBundle/Entity/Slot.php line 41

Open in your IDE?
  1. <?php
  3. namespace App\CasinoBundle\Entity;
  5. use App\CmsBundle\Entity\LogInterface;
  6. use App\CmsBundle\Entity\LogTrait;
  7. use App\CmsBundle\Entity\PublishedTrait;
  8. use App\CmsBundle\Entity\Site;
  9. use App\CmsBundle\Entity\SlugTrait;
  10. use App\CmsBundle\Entity\IdTrait;
  11. use App\CmsBundle\Enum\LogActionEnum;
  12. use Doctrine\Common\Collections\ArrayCollection;
  13. use Doctrine\Common\Collections\Collection;
  14. use Doctrine\ORM\Mapping as ORM;
  15. use App\CmsBundle\Entity\TimeStampedTrait;
  16. use DateTime;
  18. /**
  19.  * Slot
  20.  *
  21.  * @ORM\Table(
  22.  *     name="slot",
  23.  *     indexes={
  24.  *         @ORM\Index(name="slot_published_index", columns={"published"}),
  25.  *         @ORM\Index(name="slot_layout_index", columns={"layout"}),
  26.  *         @ORM\Index(name="slot_enable_game_index", columns={"enable_game"})
  27.  *     },
  28.  *     uniqueConstraints={
  29.  *         @ORM\UniqueConstraint(name="slot_slug_uindex", columns={"slug"})
  30.  *     }
  31.  * )
  32.  * @ORM\Entity(
  33.  *     repositoryClass="App\CasinoBundle\Repository\SlotRepository"
  34.  * )
  35.  * @ORM\HasLifecycleCallbacks()
  36.  * @ORM\Cache(
  37.  *     usage="NONSTRICT_READ_WRITE",
  38.  *     region="one_day"
  39.  * )
  40.  */
  41. class Slot implements LogInterface
  42. {
  43.     use IdTrait, NameTrait, TimeStampedTrait, AliasTrait, SlugTrait, AliasTrait, SlotcatalogIdTrait, PublishedTrait, LogTrait;
  45.     /**
  46.      * @ORM\Column(
  47.      *     type="text",
  48.      *     nullable=true
  49.      * )
  50.      */
  51.     private $info;
  53.     /**
  54.      * @var Software|null
  55.      * @ORM\ManyToOne(
  56.      *     targetEntity="Software",
  57.      *     inversedBy="slots"
  58.      * )
  59.      * @ORM\JoinColumn(
  60.      *     name="software_id",
  61.      *     referencedColumnName="id",
  62.      *     nullable=true
  63.      * )
  64.      */
  65.     private $software;
  67.     /**
  68.      * @var GameType|null
  69.      * @ORM\ManyToOne(
  70.      *     targetEntity="GameType",
  71.      *     inversedBy="slots"
  72.      * )
  73.      * @ORM\JoinColumn(
  74.      *     name="game_type_id",
  75.      *     referencedColumnName="id",
  76.      *     nullable=true
  77.      * )
  78.      */
  79.     private $gameType;
  81.     /**
  82.      * @ORM\Column(
  83.      *     type="float",
  84.      *     nullable=true
  85.      * )
  86.      */
  87.     private $rtp;
  89.     /**
  90.      * @ORM\OneToMany(
  91.      *     targetEntity="App\CasinoBundle\Entity\SlotScreenshot",
  92.      *     mappedBy="slot",
  93.      *     cascade={"persist"},
  94.      *     orphanRemoval=true
  95.      * )
  96.      * @ORM\OrderBy(
  97.      *     {"position" = "ASC"}
  98.      * )
  99.      */
  100.     private $slotScreenshots;
  102.     /**
  103.      * @ORM\OneToMany(
  104.      *     targetEntity="App\CasinoBundle\Entity\SlotCasinoGeo",
  105.      *     mappedBy="slot",
  106.      *     cascade={"persist"},
  107.      *     orphanRemoval=true
  108.      * )
  109.      */
  110.     private $slotCasinosGeos;
  112.     /**
  113.      * @ORM\ManyToMany(
  114.      *     targetEntity="SlotTag",
  115.      *     inversedBy="slots",
  116.      *     cascade={"persist"}
  117.      * )
  118.      */
  119.     private $slotTags;
  121.     /**
  122.      * @ORM\ManyToMany(
  123.      *     targetEntity="SlotFeature",
  124.      *     inversedBy="slots",
  125.      *     cascade={"persist"}
  126.      * )
  127.      */
  128.     private $slotFeatures;
  130.     /**
  131.      * @ORM\ManyToMany(
  132.      *     targetEntity="SlotTheme",
  133.      *     fetch="EXTRA_LAZY",
  134.      *     inversedBy="slots",
  135.      *     cascade={"persist"}
  136.      * )
  137.      */
  138.     private $slotThemes;
  140.     /**
  141.      * @ORM\ManyToMany(
  142.      *     targetEntity="SlotDevice",
  143.      *     inversedBy="slots",
  144.      *     cascade={"persist"}
  145.      * )
  146.      */
  147.     private $slotDevices;
  149.     /**
  150.      * @var DateTime
  151.      *
  152.      * @ORM\Column(
  153.      *     type="datetime",
  154.      *     nullable=true)
  155.      */
  156.     private $release;
  158.     /**
  159.      * @ORM\Column(
  160.      *     name="min_bet",
  161.      *     type="float",
  162.      *     nullable=true
  163.      * )
  164.      */
  165.     private $minBet;
  167.     /**
  168.      * @ORM\Column(
  169.      *     name="max_bet",
  170.      *     type="float",
  171.      *     nullable=true
  172.      * )
  173.      */
  174.     private $maxBet;
  176.     /**
  177.      * @ORM\Column(
  178.      *     type="integer",
  179.      *     nullable=true
  180.      * )
  181.      */
  182.     private $type;
  184.     /**
  185.      * @ORM\Column(
  186.      *     type="string",
  187.      *     length=255,
  188.      *     nullable=true
  189.      * )
  190.      */
  191.     private $videoUrl;
  193.     /**
  194.      * @ORM\Column(
  195.      *     type="integer",
  196.      *     nullable=true
  197.      * )
  198.      */
  199.     private $rank;
  201.     /**
  202.      * @ORM\Column(
  203.      *     type="integer",
  204.      *     nullable=true
  205.      * )
  206.      */
  207.     private $paylines;
  209.     /**
  210.      * @ORM\Column(
  211.      *     type="string",
  212.      *     length=255,
  213.      *     nullable=true
  214.      * )
  215.      */
  216.     private $layout;
  218.     /**
  219.      * @ORM\Column(
  220.      *     type="string",
  221.      *     length=255,
  222.      *     nullable=true
  223.      * )
  224.      */
  225.     private $technology;
  227.     /**
  228.      * @ORM\Column(
  229.      *     type="string",
  230.      *     length=255,
  231.      *     nullable=true
  232.      * )
  233.      */
  234.     private $variance;
  236.     /**
  237.      * @ORM\Column(
  238.      *     type="integer",
  239.      *     nullable=true
  240.      * )
  241.      */
  242.     private $maxWin;
  244.     /**
  245.      * @ORM\Column(
  246.      *     type="text",
  247.      *     nullable=true
  248.      * )
  249.      */
  250.     private $source;
  252.     /**
  253.      * @ORM\Column(
  254.      *     type="string",
  255.      *     length=255,
  256.      *     nullable=true
  257.      * )
  258.      */
  259.     private $galleryHash;
  261.     /**
  262.      * @ORM\Column(
  263.      *     type="string",
  264.      *     length=255,
  265.      *     nullable=true
  266.      * )
  267.      */
  268.     private $dataHash;
  270.     /**
  271.      * @ORM\Column(
  272.      *     type="boolean",
  273.      *     nullable=false,
  274.      *     options={"default" = false}
  275.      * )
  276.      */
  277.     private $enableGame = false;
  279.     /**
  280.      * @ORM\OneToMany(
  281.      *     targetEntity="App\CasinoBundle\Entity\Alias",
  282.      *     mappedBy="slot",
  283.      *     cascade={"persist"},
  284.      *     orphanRemoval=true
  285.      * )
  286.      */
  287.     private Collection $aliases;
  289.     /**
  290.      * @ORM\Column(
  291.      *     type="text",
  292.      *     nullable=true
  293.      * )
  294.      */
  295.     private $countries;
  297.     /**
  298.      * @ORM\ManyToMany(
  299.      *     targetEntity="App\CasinoBundle\Entity\Casino",
  300.      *     mappedBy="slots"
  301.      * )
  302.      */
  303.     private $casinos;
  305.     /**
  306.      * @ORM\ManyToMany(
  307.      *     targetEntity="App\CmsBundle\Entity\Site",
  308.      *     fetch="EXTRA_LAZY",
  309.      *     cascade={"persist"}
  310.      * )
  311.      * @ORM\JoinTable(
  312.      *     name="slot_site",
  313.      *     joinColumns={
  314.      *          @ORM\JoinColumn(name="slot_id", referencedColumnName="id")
  315.      *     },
  316.      *     inverseJoinColumns={
  317.      *          @ORM\JoinColumn(name="site_id", referencedColumnName="id")
  318.      *     }
  319.      * )
  320.      */
  321.     protected Collection $sites;
  323.     /**
  324.      * @ORM\ManyToMany(
  325.      *     targetEntity="App\CasinoBundle\Entity\NewBonus",
  326.      *     mappedBy="slots",
  327.      *     cascade={"persist"}
  328.      * )
  329.      */
  330.     private Collection $newBonuses;
  332.     /**
  333.      * @ORM\OneToMany(
  334.      *     targetEntity="App\CasinoBundle\Entity\IssueReport",
  335.      *     mappedBy="slot",
  336.      * )
  337.      */
  338.     private Collection $issueReports;
  340.     public function __construct()
  341.     {
  342.         $this->slotTags = new ArrayCollection();
  343.         $this->slotScreenshots = new ArrayCollection();
  344.         $this->slotCasinosGeos = new ArrayCollection();
  345.         $this->slotThemes = new ArrayCollection();
  346.         $this->slotFeatures = new ArrayCollection();
  347.         $this->slotDevices = new ArrayCollection();
  348.         $this->aliases = new ArrayCollection();
  349.         $this->sites = new ArrayCollection();
  350.         $this->casinos = new ArrayCollection();
  351.         $this->newBonuses = new ArrayCollection();
  352.         $this->issueReports = new ArrayCollection();
  353.     }
  355.     public function __toString(): string
  356.     {
  357.         return $this->name;
  358.     }
  360.     public function getCountries(): ?string
  361.     {
  362.         return $this->countries;
  363.     }
  365.     public function setCountries(?string $countries = null): self
  366.     {
  367.         $this->countries = $countries;
  368.         return $this;
  369.     }
  371.     public function getNameWithSoftware(): ?string
  372.     {
  373.         $software = ($this->software)
  374.             ? ' - ' . $this->software->getName()
  375.             : '';
  377.         return $this->getName() . $software;
  378.     }
  380.     public function getNameWithSlugAndSoftware(): ?string
  381.     {
  382.         $software = ($this->software)
  383.             ? ' - ' . $this->software->getName()
  384.             : '';
  386.         return $this->getName() . ' (' . $this->getSlug() . ') ' . $software;
  387.     }
  389.     public function getSoftware(): ?Software
  390.     {
  391.         return $this->software;
  392.     }
  395.     public function setSoftware(?Software $software): self
  396.     {
  397.         $this->software = $software;
  398.         return $this;
  399.     }
  402.     public function getGameType(): ?GameType
  403.     {
  404.         return $this->gameType;
  405.     }
  407.     public function setGameType(?GameType $gameType): self
  408.     {
  409.         $this->gameType = $gameType;
  410.         if ($gameType) {
  411.             $gameType->addSlot($this);
  412.         } else {
  413.             $gameType->removeSlot($this);
  414.         }
  415.         return $this;
  416.     }
  418.     public function getRtp(): ?float
  419.     {
  420.         return $this->rtp;
  421.     }
  423.     public function setRtp($rtp): self
  424.     {
  425.         $this->rtp = ($rtp) ? floatval($rtp) : null;
  426.         return $this;
  427.     }
  429.     public function getInfo(): ?string
  430.     {
  431.         return $this->info;
  432.     }
  434.     public function setInfo(?string $info): self
  435.     {
  436.         $this->info = $info;
  437.         return $this;
  438.     }
  440.     public function getRelease(): ?DateTime
  441.     {
  442.         return $this->release;
  443.     }
  445.     public function setRelease(?DateTime $release): self
  446.     {
  447.         $this->release = $release;
  448.         return $this;
  449.     }
  451.     public function getMinBet(): ?float
  452.     {
  453.         return $this->minBet;
  454.     }
  456.     public function setMinBet(?float $minBet): self
  457.     {
  458.         $this->minBet = $minBet;
  459.         return $this;
  460.     }
  462.     public function getMaxBet(): ?float
  463.     {
  464.         return $this->maxBet;
  465.     }
  467.     public function setMaxBet(?float $maxBet): self
  468.     {
  469.         $this->maxBet = $maxBet;
  470.         return $this;
  471.     }
  473.     public function setType(?int $type): self
  474.     {
  475.         $this->type = $type;
  476.         return $this;
  477.     }
  479.     public function getType(): ?int
  480.     {
  481.         return $this->type;
  482.     }
  484.     public function getVideoUrl(): ?string
  485.     {
  486.         return $this->videoUrl;
  487.     }
  489.     public function setVideoUrl(?string $videoUrl): self
  490.     {
  491.         $this->videoUrl = $videoUrl;
  492.         return $this;
  493.     }
  495.     public function getRank(): ?int
  496.     {
  497.         return $this->rank;
  498.     }
  500.     public function setRank(?int $rank): self
  501.     {
  502.         $this->rank = $rank;
  503.         return $this;
  504.     }
  506.     public function getPaylines(): ?int
  507.     {
  508.         return $this->paylines;
  509.     }
  511.     public function setPaylines(?int $paylines): self
  512.     {
  513.         $this->paylines = $paylines;
  514.         return $this;
  515.     }
  517.     public function getLayout(): ?string
  518.     {
  519.         return $this->layout;
  520.     }
  522.     public function setLayout(?string $layout): self
  523.     {
  524.         $this->layout = $layout;
  525.         return $this;
  526.     }
  528.     public function getGalleryHash(): ?string
  529.     {
  530.         return $this->galleryHash;
  531.     }
  533.     public function setGalleryHash(?string $hash): self
  534.     {
  535.         $this->galleryHash = $hash;
  536.         return $this;
  537.     }
  539.     public function getDataHash(): ?string
  540.     {
  541.         return $this->dataHash;
  542.     }
  544.     public function setDataHash(?string $hash): self
  545.     {
  546.         $this->dataHash = $hash;
  547.         return $this;
  548.     }
  550.     public function getTechnology(): ?string
  551.     {
  552.         return $this->technology;
  553.     }
  555.     public function setTechnology(?string $technology): self
  556.     {
  557.         $this->technology = $technology;
  558.         return $this;
  559.     }
  561.     public function getVariance(): ?string
  562.     {
  563.         return $this->variance;
  564.     }
  566.     public function setVariance(?string $variance): self
  567.     {
  568.         $this->variance = $variance;
  569.         return $this;
  570.     }
  572.     public function getMaxWin(): ?int
  573.     {
  574.         return $this->maxWin;
  575.     }
  577.     public function setMaxWin(?int $maxWin): self
  578.     {
  579.         $this->maxWin = $maxWin;
  580.         return $this;
  581.     }
  583.     public function getSource(): ?string
  584.     {
  585.         return $this->source;
  586.     }
  588.     public function setSource(?string $source): self
  589.     {
  590.         $this->source = $source;
  591.         return $this;
  592.     }
  594.     /**
  595.      * @return Collection|SlotScreenshot[]
  596.      */
  597.     public function getScreenshots()
  598.     {
  599.         return $this->slotScreenshots;
  600.     }
  602.     public function addScreenshot(SlotScreenshot $screenshot): self
  603.     {
  604.         if (!$this->slotScreenshots->contains($screenshot)) {
  605.             $this->slotScreenshots[] = $screenshot;
  606.             $screenshot->setSlot($this);
  607.             $this->addCollectionLog(LogActionEnum::ADD, 'screenshot', $screenshot);
  608.         }
  609.         return $this;
  610.     }
  612.     public function removeScreenshot(SlotScreenshot $screenshot): self
  613.     {
  614.         if ($this->slotScreenshots->contains($screenshot)) {
  615.             $this->slotScreenshots->removeElement($screenshot);
  616.             $screenshot->setSlot(null);
  617.             $this->addCollectionLog(LogActionEnum::REMOVE, 'screenshot', $screenshot);
  618.         }
  619.         return $this;
  620.     }
  622.     /**
  623.      * @return Collection|SlotCasinoGeo[]
  624.      */
  625.     public function getSlotCasinosGeos()
  626.     {
  627.         return $this->slotCasinosGeos;
  628.     }
  630.     public function addSlotCasinosGeos(SlotCasinoGeo $slotCasinoGeo): self
  631.     {
  632.         if (!$this->slotCasinosGeos->contains($slotCasinoGeo)) {
  633.             $this->slotCasinosGeos[] = $slotCasinoGeo;
  634.             $slotCasinoGeo->setSlot($this);
  635.             $this->addCollectionLog(LogActionEnum::ADD, 'slotCasinoGeo', $slotCasinoGeo);
  636.         }
  637.         return $this;
  638.     }
  640.     public function removeSlotCasinosGeos(SlotCasinoGeo $slotCasinoGeo): self
  641.     {
  642.         if ($this->slotCasinosGeos->contains($slotCasinoGeo)) {
  643.             $this->slotCasinosGeos->removeElement($slotCasinoGeo);
  644.             $slotCasinoGeo->setSlot(null);
  645.             $this->addCollectionLog(LogActionEnum::REMOVE, 'slotCasinoGeo', $slotCasinoGeo);
  646.         }
  647.         return $this;
  648.     }
  650.     public function getSlotDevices()
  651.     {
  652.         return $this->slotDevices;
  653.     }
  655.     public function addSlotDevice(SlotDevice $device): self
  656.     {
  657.         if (!$this->slotDevices->contains($device)) {
  658.             $this->slotDevices[] = $device;
  659.             $device->addSlot($this);
  660.             $this->addCollectionLog(LogActionEnum::ADD, 'slotDevice', $device);
  661.         }
  662.         return $this;
  663.     }
  665.     public function removeSlotDevice(SlotDevice $device): self
  666.     {
  667.         if ($this->slotDevices->contains($device)) {
  668.             $this->slotDevices->removeElement($device);
  669.             $device->removeSlot($this);
  670.             $this->addCollectionLog(LogActionEnum::REMOVE, 'slotDevice', $device);
  671.         }
  672.         return $this;
  673.     }
  675.     public function getSlotTags()
  676.     {
  677.         return $this->slotTags;
  678.     }
  680.     public function addSlotTag(SlotTag $tag): self
  681.     {
  682.         if (!$this->slotTags->contains($tag)) {
  683.             $this->slotTags[] = $tag;
  684.             $tag->addSlot($this);
  685.             $this->addCollectionLog(LogActionEnum::ADD, 'slotTag', $tag);
  686.         }
  687.         return $this;
  688.     }
  690.     public function removeSlotTag(SlotTag $tag): self
  691.     {
  692.         if ($this->slotTags->contains($tag)) {
  693.             $this->slotTags->removeElement($tag);
  694.             $tag->removeSlot($this);
  695.             $this->addCollectionLog(LogActionEnum::REMOVE, 'slotTag', $tag);
  696.         }
  697.         return $this;
  698.     }
  700.     public function getSlotFeatures()
  701.     {
  702.         return $this->slotFeatures;
  703.     }
  705.     public function addSlotFeature(SlotFeature $slotFeature): self
  706.     {
  707.         if (!$this->slotFeatures->contains($slotFeature)) {
  708.             $this->slotFeatures[] = $slotFeature;
  709.             $slotFeature->addSlot($this);
  710.             $this->addCollectionLog(LogActionEnum::ADD, 'slotFeature', $slotFeature);
  711.         }
  712.         return $this;
  713.     }
  715.     public function removeSlotFeature(SlotFeature $slotFeature): self
  716.     {
  717.         if ($this->slotFeatures->contains($slotFeature)) {
  718.             $this->slotFeatures->removeElement($slotFeature);
  719.             $slotFeature->removeSlot($this);
  720.             $this->addCollectionLog(LogActionEnum::REMOVE, 'slotFeature', $slotFeature);
  721.         }
  722.         return $this;
  723.     }
  725.     public function getSlotThemes()
  726.     {
  727.         return $this->slotThemes;
  728.     }
  730.     public function addSlotTheme(SlotTheme $slotTheme): self
  731.     {
  732.         if (!$this->slotThemes->contains($slotTheme)) {
  733.             $this->slotThemes[] = $slotTheme;
  734.             $slotTheme->addSlot($this);
  735.             $this->addCollectionLog(LogActionEnum::ADD, 'slotTheme', $slotTheme);
  736.         }
  737.         return $this;
  738.     }
  740.     public function removeSlotTheme(SlotTheme $slotTheme): self
  741.     {
  742.         if ($this->slotThemes->contains($slotTheme)) {
  743.             $this->slotThemes->removeElement($slotTheme);
  744.             $slotTheme->removeSlot($this);
  745.             $this->addCollectionLog(LogActionEnum::REMOVE, 'slotTheme', $slotTheme);
  746.         }
  747.         return $this;
  748.     }
  750.     public function setEnableGame(bool $enableGame): self
  751.     {
  752.         $this->enableGame = $enableGame;
  753.         return $this;
  754.     }
  756.     public function getEnableGame(): bool
  757.     {
  758.         return $this->enableGame;
  759.     }
  761.     /**
  762.      * @return Collection|Casino[]
  763.      */
  764.     public function getCasinos(): Collection
  765.     {
  766.         return $this->casinos;
  767.     }
  769.     /**
  770.      * @param Casino $casino
  771.      * @return $this
  772.      */
  773.     public function addCasino(Casino $casino): self
  774.     {
  775.         if (!$this->casinos->contains($casino)) {
  776.             $this->casinos[] = $casino;
  777.             $casino->addSlot($this);
  778.             $this->addCollectionLog(LogActionEnum::ADD, 'casino', $casino);
  779.         }
  780.         return $this;
  781.     }
  783.     /**
  784.      * @param Casino $casino
  785.      * @return $this
  786.      */
  787.     public function removeCasino(Casino $casino): self
  788.     {
  789.         if ($this->casinos->contains($casino)) {
  790.             $this->casinos->removeElement($casino);
  791.             $casino->removeSlot($this);
  792.             $this->addCollectionLog(LogActionEnum::REMOVE, 'casino', $casino);
  793.         }
  794.         return $this;
  795.     }
  797.     /**
  798.      * @return Collection|Site[]
  799.      */
  800.     public function getSites(): Collection
  801.     {
  802.         return $this->sites;
  803.     }
  805.     /**
  806.      * @param Site $site
  807.      * @return $this
  808.      */
  809.     public function addSite(Site $site): self
  810.     {
  811.         if (!$this->sites->contains($site)) {
  812.             $this->sites[] = $site;
  813.             $this->addCollectionLog(LogActionEnum::ADD, 'site', $site);
  814.         }
  815.         return $this;
  816.     }
  818.     /**
  819.      * @param Site $site
  820.      * @return $this
  821.      */
  822.     public function removeSite(Site $site): self
  823.     {
  824.         if ($this->sites->contains($site)) {
  825.             $this->sites->removeElement($site);
  826.             $this->addCollectionLog(LogActionEnum::REMOVE, 'site', $site);
  827.         }
  828.         return $this;
  829.     }
  832.     /**
  833.      * @return Collection|NewBonus[]
  834.      */
  835.     public function getNewBonuses(): Collection
  836.     {
  837.         return $this->newBonuses;
  838.     }
  840.     /**
  841.      * @param NewBonus $newBonus
  842.      * @return $this
  843.      */
  844.     public function addNewBonus(NewBonus $newBonus): self
  845.     {
  846.         if (!$this->newBonuses->contains($newBonus)) {
  847.             $this->newBonuses[] = $newBonus;
  848.             $newBonus->addSlot($this);
  849.             $this->addCollectionLog(LogActionEnum::ADD, 'newBonus', $newBonus);
  850.         }
  851.         return $this;
  852.     }
  854.     /**
  855.      * @param NewBonus $newBonus
  856.      * @return $this
  857.      */
  858.     public function removeNewBonus(NewBonus $newBonus): self
  859.     {
  860.         if ($this->newBonuses->contains($newBonus)) {
  861.             $this->newBonuses->removeElement($newBonus);
  862.             $newBonus->removeSlot($this);
  863.             $this->addCollectionLog(LogActionEnum::REMOVE, 'newBonus', $newBonus);
  864.         }
  865.         return $this;
  866.     }
  868.     /**
  869.      * @return Collection|IssueReport[]
  870.      */
  871.     public function getIssueReports(): Collection
  872.     {
  873.         return $this->issueReports;
  874.     }
  876.     /**
  877.      * @param IssueReport $issueReport
  878.      * @return $this
  879.      */
  880.     public function addIssueReport(IssueReport $issueReport): self
  881.     {
  882.         if (!$this->issueReports->contains($issueReport)) {
  883.             $this->issueReports[] = $issueReport;
  884.             $issueReport->setSlot($this);
  885.             $this->addCollectionLog(LogActionEnum::ADD, 'issueReport', $issueReport);
  886.         }
  887.         return $this;
  888.     }
  890.     /**
  891.      * @param IssueReport $issueReport
  892.      * @return $this
  893.      */
  894.     public function removeIssueReport(IssueReport $issueReport): self
  895.     {
  896.         if ($this->issueReports->contains($issueReport)) {
  897.             $this->issueReports->removeElement($issueReport);
  898.             $issueReport->setSlot(null);
  899.             $this->addCollectionLog(LogActionEnum::REMOVE, 'issueReport', $issueReport);
  900.         }
  901.         return $this;
  902.     }
  903. }