src/Entity/Game.php line 16

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\Locality;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use Symfony\Component\HttpFoundation\File\File;
  10. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  12. /**
  13.  * @ORM\Entity(repositoryClass="App\Repository\GameRepository")
  14.  * @Vich\Uploadable
  15.  */
  16. class Game
  17. {
  18.   /**
  19.    * @ORM\Id()
  20.    * @ORM\GeneratedValue()
  21.    * @ORM\Column(type="integer")
  22.    */
  23.   private $id;
  25.   /**
  26.    * @ORM\ManyToOne(targetEntity="App\Entity\Season", inversedBy="games")
  27.    * @ORM\JoinColumn(nullable=false)
  28.    */
  29.   private $season;
  31.   /**
  32.    * @ORM\Column(type="string", length=255)
  33.    */
  34.   private $rival;
  36.   /**
  37.    * @ORM\OneToOne(targetEntity=Locality::class)
  38.    */
  39.   private $locality;
  41.   /**
  42.    * @ORM\Column(type="integer")
  43.    */
  44.   private $day;
  46.   /**
  47.    * @ORM\Column(type="datetime")
  48.    */
  49.   private $date;
  51.   /**
  52.    * @ORM\Column(type="integer")
  53.    */
  54.   private $goals;
  56.   /**
  57.    * @ORM\Column(type="integer")
  58.    */
  59.   private $rivalGoals;
  61.   /**
  62.    * @ORM\Column(type="string", length=255, nullable=true)
  63.    */
  64.   private $image;
  66.   /**
  67.    * @Vich\UploadableField(mapping="game_images", fileNameProperty="image")
  68.    * @var File
  69.    */
  70.   private $imageFile;
  72.   /**
  73.    * @ORM\Column(type="datetime", nullable=true)
  74.    * @var \DateTime
  75.    */
  76.   private $updatedAt;
  78.   /**
  79.    * @ORM\OneToOne(targetEntity="App\Entity\Convocatoria", mappedBy="game", cascade={"persist", "remove"})
  80.    */
  81.   private $convocatoria;
  83.   /**
  84.    * @ORM\OneToMany(targetEntity=Minutes::class, mappedBy="game_id")
  85.    */
  86.   private $minutes;
  88.   /**
  89.    * @ORM\OneToOne(targetEntity=Competition::class)
  90.    */
  91.   private $competition;
  93.   /**
  94.    * @ORM\Column(type="integer")
  95.    */
  96.   private $shots_goal;
  98.   /**
  99.    * @ORM\Column(type="integer")
  100.    */
  101.   private $shots_opponent;
  103.   /**
  104.    * @ORM\Column(type="integer")
  105.    */
  106.   private $corners_favor;
  108.   /**
  109.    * @ORM\Column(type="integer")
  110.    */
  111.   private $corners_against;
  113.   /**
  114.    * @ORM\Column(type="integer")
  115.    */
  116.   private $penalties_favor;
  118.   /**
  119.    * @ORM\Column(type="integer")
  120.    */
  121.   private $penalties_against;
  123.   /**
  124.    * @ORM\Column(type="integer")
  125.    */
  126.   private $fouls_favor;
  128.   /**
  129.    * @ORM\Column(type="integer")
  130.    */
  131.   private $fouls_against;
  133.   /**
  134.    * @ORM\OneToOne(targetEntity=GameAlignment::class, inversedBy="game", cascade={"persist", "remove"})
  135.    */
  136.   private $alignment;
  138.   /**
  139.    * @ORM\Column(type="integer", options={"default" : 90})
  140.    */
  141.   private $timeMatch;
  143.   /**
  144.    * @ORM\Column(type="integer", options={"default" : 11})
  145.    */
  146.   private $category;
  148.   /**
  149.    * @ORM\OneToOne(targetEntity=GameAlignment::class, inversedBy="game", cascade={"persist", "remove"})
  150.    */
  151.   private $rival_alignment;
  154.   /**
  155.    * @ORM\Column(type="integer", options={"default" : 0})
  156.    */
  157.   private $total_shots;
  159.   /**
  160.    * @ORM\Column(type="integer", options={"default" : 0})
  161.    */
  162.   private $total_shots_against;
  164.   /**
  165.    * @ORM\Column(type="integer", options={"default" : 0})
  166.    */
  167.   private $yellow_cards;
  169.   /**
  170.    * @ORM\Column(type="integer", options={"default" : 0})
  171.    */
  173.   private $yellow_cards_against;
  175.   /**
  176.    * @ORM\Column(type="integer", options={"default" : 0})
  177.    */
  179.   private $red_cards;
  181.   /**
  182.    * @ORM\Column(type="integer", options={"default" : 0})
  183.    */
  185.   private $red_cards_against;
  187.   /**
  188.    * @ORM\Column(type="integer", options={"default" : 0})
  189.    */
  190.   private $currentPositionLeague;
  192.   /**
  193.    * @ORM\OneToMany(targetEntity=KilometersTraveled::class, mappedBy="game")
  194.    */
  195.   private $kilometersTraveleds;
  197.   /**
  198.    * @ORM\OneToMany(targetEntity=ShotsOnGoal::class, mappedBy="game")
  199.    */
  200.   private $shotsOnGoals;
  202.   /**
  203.    * @ORM\OneToMany(targetEntity=GamePlayerStatistics::class, mappedBy="game")
  204.    */
  205.   private $seasonplayer;
  207.   /**
  208.    * @ORM\OneToMany(targetEntity=GamePlayerStatistics::class, mappedBy="game")
  209.    */
  210.   private $gamePlayerStatistics;
  212.   /**
  213.    * @ORM\Column(type="integer", nullable=true)
  214.    */
  215.   private $opponentCurrentPositionLeague;
  217.   /**
  218.    * @ORM\ManyToOne(targetEntity=Difficulty::class, inversedBy="pressureRivals")
  219.    */
  220.   private $pressureRival;
  222.   /**
  223.    * @ORM\Column(type="datetime", nullable=true)
  224.    * @var \DateTime
  225.    */
  226.   private $deletedAt;
  228.   public function __construct()
  229.   {
  230.     $this->minutes = new ArrayCollection();
  231.     $this->kilometersTraveleds = new ArrayCollection();
  232.     $this->shotsOnGoals = new ArrayCollection();
  233.     $this->seasonplayer = new ArrayCollection();
  234.     $this->gamePlayerStatistics = new ArrayCollection();
  235.   }
  237.   public function getId(): ?int
  238.   {
  239.     return $this->id;
  240.   }
  242.   public function getSeason(): ?Season
  243.   {
  244.     return $this->season;
  245.   }
  247.   public function setSeason(?Season $season): self
  248.   {
  249.     $this->season = $season;
  251.     return $this;
  252.   }
  254.   public function getRival(): ?string
  255.   {
  256.     return $this->rival;
  257.   }
  259.   public function setRival(string $rival): self
  260.   {
  261.     $this->rival = $rival;
  263.     return $this;
  264.   }
  266.   public function getLocality(): ?Locality
  267.   {
  268.     return $this->locality;
  269.   }
  271.   public function setLocality(Locality $locality): self
  272.   {
  273.     $this->locality = $locality;
  275.     return $this;
  276.   }
  278.   public function getDay(): ?int
  279.   {
  280.     return $this->day;
  281.   }
  283.   public function setDay(int $day): self
  284.   {
  285.     $this->day = $day;
  287.     return $this;
  288.   }
  290.   public function getDate(): ?\DateTimeInterface
  291.   {
  292.     return $this->date;
  293.   }
  295.   public function setDate(\DateTimeInterface $date): self
  296.   {
  297.     $this->date = $date;
  299.     return $this;
  300.   }
  302.   public function getGoals(): ?int
  303.   {
  304.     return $this->goals;
  305.   }
  307.   public function setGoals(int $goals): self
  308.   {
  309.     $this->goals = $goals;
  311.     return $this;
  312.   }
  314.   public function getRivalGoals(): ?int
  315.   {
  316.     return $this->rivalGoals;
  317.   }
  319.   public function setRivalGoals(int $rivalGoals): self
  320.   {
  321.     $this->rivalGoals = $rivalGoals;
  323.     return $this;
  324.   }
  326.   /**
  327.    * @return \DateTime
  328.    */
  329.   public function getUpdatedAt(): \DateTime
  330.   {
  331.     return $this->updatedAt;
  332.   }
  334.   /**
  335.    * @param \DateTime $updatedAt
  336.    * @return Game
  337.    */
  338.   public function setUpdatedAt(\DateTime $updatedAt): Game
  339.   {
  340.     $this->updatedAt = $updatedAt;
  341.     return $this;
  342.   }
  344.   /**
  345.    * @param File|null $image
  346.    * @return Game
  347.    */
  348.   public function setImageFile(File $image = null)
  349.   {
  350.     $this->imageFile = $image;
  352.     // VERY IMPORTANT:
  353.     // It is required that at least one field changes if you are using Doctrine,
  354.     // otherwise the event listeners won't be called and the file is lost
  355.     if ($image) {
  356.       // if 'updatedAt' is not defined in your entity, use another property
  357.       $this->updatedAt = new \DateTime('now');
  358.     }
  359.     return $this;
  360.   }
  362.   public function getImageFile()
  363.   {
  364.     return $this->imageFile;
  365.   }
  367.   public function getImage(): ?string
  368.   {
  369.     return $this->image;
  370.   }
  372.   public function setImage(?string $image): self
  373.   {
  374.     $this->image = $image;
  376.     return $this;
  377.   }
  379.   public function getConvocatoria(): ?Convocatoria
  380.   {
  381.     return $this->convocatoria;
  382.   }
  384.   public function setConvocatoria(Convocatoria $convocatoria): self
  385.   {
  386.     $this->convocatoria = $convocatoria;
  388.     // set the owning side of the relation if necessary
  389.     if ($convocatoria->getGame() !== $this) {
  390.       $convocatoria->setGame($this);
  391.     }
  393.     return $this;
  394.   }
  396.   public function __toArray($imagePath)
  397.   {
  399.     return [
  400.       "id" => $this->getId(),
  401.       "rival" => $this->getRival(),
  402.       "locality" => $this->getLocality() ? $this->getLocality()->getName() : null,
  403.       "locality_id" => $this->getLocality() ? $this->getLocality()->getId() : null,
  404.       "day" => $this->getDay(),
  405.       "date" => $this->getDate()->format("d/m/Y H:i"),
  406.       "goals" => $this->getGoals(),
  407.       "rivalGoals" => $this->getRivalGoals(),
  408.       "image" => !empty($this->getImage()) ? $imagePath . $this->getImage() : "",
  409.       "competition" => $this->getCompetition() ? $this->getCompetition()->getName() : null,
  410.       "competition_id" => $this->getCompetition() ? $this->getCompetition()->getId() : null,
  411.       "timeMatch" => $this->getTimeMatch(),
  412.       "category" => $this->getCategory(),
  413.       "shots_goal" => $this->getShotsGoal(),
  414.       "shots_opponent" => $this->getShotsOpponent(),
  415.       "corners_favor" => $this->getCornersFavor(),
  416.       "corners_against" => $this->getCornersAgainst(),
  417.       "penalties_favor" => $this->getPenaltiesFavor(),
  418.       "penalties_against" => $this->getPenaltiesAgainst(),
  419.       "fouls_favor" => $this->getFoulsFavor(),
  420.       "fouls_against" => $this->getFoulsAgainst(),
  421.       "rival_tactic" => $this->getRivalAlignment() != null ? $this->getRivalAlignment()->getTactic() : "",
  422.       'total_shots' => $this->getTotalShots() ?? 0,
  423.       'total_shots_against' => $this->getTotalShotsAgainst() ?? 0,
  424.       'yellow_cards' => $this->getYellowCards() ?? 0,
  425.       'yellow_cards_against' => $this->getYellowCardsAgainst() ?? 0,
  426.       'red_cards' => $this->getRedCards() ?? 0,
  427.       'opponentCurrentPositionLeague' => $this->getOpponentCurrentPositionLeague() ?? 0,
  428.       'pressureRival' => $this->getPressureRival() ? $this->getPressureRival()->__toArray() : null,
  429.       'pressureRivalId' => $this->getPressureRival() ? $this->getPressureRival()->getId() : null,
  430.       'red_cards_against' => $this->getRedCardsAgainst() ?? 0,
  431.       'alignment' => $this->getAlignment() ? $this->getAlignment()->__toArray() : null,
  432.       'currentPositionLeague' => $this->getCurrentPositionLeague()
  433.     ];
  434.   }
  436.   /**
  437.    * @return Collection|Minutes[]
  438.    */
  439.   public function getMinutes(): Collection
  440.   {
  441.     return $this->minutes;
  442.   }
  444.   public function addMinute(Minutes $minute): self
  445.   {
  446.     if (!$this->minutes->contains($minute)) {
  447.       $this->minutes[] = $minute;
  448.       $minute->setGameId($this);
  449.     }
  451.     return $this;
  452.   }
  454.   public function removeMinute(Minutes $minute): self
  455.   {
  456.     if ($this->minutes->contains($minute)) {
  457.       $this->minutes->removeElement($minute);
  458.       // set the owning side to null (unless already changed)
  459.       if ($minute->getGameId() === $this) {
  460.         $minute->setGameId(null);
  461.       }
  462.     }
  464.     return $this;
  465.   }
  467.   public function getShotsGoal(): ?int
  468.   {
  469.     return $this->shots_goal;
  470.   }
  472.   public function setShotsGoal(int $shots_goal): self
  473.   {
  474.     $this->shots_goal = $shots_goal;
  476.     return $this;
  477.   }
  479.   public function getShotsOpponent(): ?int
  480.   {
  481.     return $this->shots_opponent;
  482.   }
  484.   public function setShotsOpponent(int $shots_opponent): self
  485.   {
  486.     $this->shots_opponent = $shots_opponent;
  488.     return $this;
  489.   }
  491.   public function getCornersFavor(): ?int
  492.   {
  493.     return $this->corners_favor;
  494.   }
  496.   public function setCornersFavor(int $corners_favor): self
  497.   {
  498.     $this->corners_favor = $corners_favor;
  500.     return $this;
  501.   }
  503.   public function getCornersAgainst(): ?int
  504.   {
  505.     return $this->corners_against;
  506.   }
  508.   public function setCornersAgainst(int $corners_against): self
  509.   {
  510.     $this->corners_against = $corners_against;
  512.     return $this;
  513.   }
  515.   public function getPenaltiesFavor(): ?int
  516.   {
  517.     return $this->penalties_favor;
  518.   }
  520.   public function setPenaltiesFavor(int $penalties_favor): self
  521.   {
  522.     $this->penalties_favor = $penalties_favor;
  524.     return $this;
  525.   }
  527.   public function getPenaltiesAgainst(): ?int
  528.   {
  529.     return $this->penalties_against;
  530.   }
  532.   public function setPenaltiesAgainst(int $penalties_against): self
  533.   {
  534.     $this->penalties_against = $penalties_against;
  536.     return $this;
  537.   }
  539.   public function getFoulsFavor(): ?int
  540.   {
  541.     return $this->fouls_favor;
  542.   }
  544.   public function setFoulsFavor(int $fouls_favor): self
  545.   {
  546.     $this->fouls_favor = $fouls_favor;
  548.     return $this;
  549.   }
  551.   public function getFoulsAgainst(): ?int
  552.   {
  553.     return $this->fouls_against;
  554.   }
  556.   public function setFoulsAgainst(int $fouls_against): self
  557.   {
  558.     $this->fouls_against = $fouls_against;
  560.     return $this;
  561.   }
  563.   public function getAlignment(): ?GameAlignment
  564.   {
  565.     return $this->alignment;
  566.   }
  568.   public function setAlignment(?GameAlignment $alignment): self
  569.   {
  570.     $this->alignment = $alignment;
  572.     return $this;
  573.   }
  575.   public function getTimeMatch(): ?int
  576.   {
  577.     return $this->timeMatch;
  578.   }
  580.   public function setTimeMatch(?int $timeMatch): self
  581.   {
  582.     $this->timeMatch = $timeMatch;
  584.     return $this;
  585.   }
  587.   public function getCategory(): ?int
  588.   {
  589.     return $this->category;
  590.   }
  592.   public function setCategory(int $category): self
  593.   {
  594.     $this->category = $category;
  596.     return $this;
  597.   }
  599.   public function getRivalAlignment(): ?GameAlignment
  600.   {
  601.     return $this->rival_alignment;
  602.   }
  604.   public function setRivalAlignment(?GameAlignment $alignment): self
  605.   {
  606.     $this->rival_alignment = $alignment;
  608.     return $this;
  609.   }
  611.   public function getTotalShots(): ?int
  612.   {
  613.     return $this->total_shots;
  614.   }
  616.   public function setTotalShots(?int $total_shots): self
  617.   {
  618.     $this->total_shots = $total_shots;
  620.     return $this;
  621.   }
  623.   public function getTotalShotsAgainst(): ?int
  624.   {
  625.     return $this->total_shots_against;
  626.   }
  628.   public function setTotalShotsAgainst(?int $total_shots_against): self
  629.   {
  630.     $this->total_shots_against = $total_shots_against;
  632.     return $this;
  633.   }
  635.   public function getYellowCards(): ?int
  636.   {
  637.     return $this->yellow_cards;
  638.   }
  640.   public function setYellowCards(?int $yellow_cards): self
  641.   {
  642.     $this->yellow_cards = $yellow_cards;
  644.     return $this;
  645.   }
  647.   public function getYellowCardsAgainst(): ?int
  648.   {
  649.     return $this->yellow_cards_against;
  650.   }
  652.   public function setYellowCardsAgainst(?int $yellow_cards_against): self
  653.   {
  654.     $this->yellow_cards_against = $yellow_cards_against;
  656.     return $this;
  657.   }
  659.   public function getRedCards(): ?int
  660.   {
  661.     return $this->red_cards;
  662.   }
  664.   public function setRedCards(?int $red_cards): self
  665.   {
  666.     $this->red_cards = $red_cards;
  668.     return $this;
  669.   }
  671.   public function getRedCardsAgainst(): ?int
  672.   {
  673.     return $this->red_cards_against;
  674.   }
  676.   public function setRedCardsAgainst(?int $red_cards_against): self
  677.   {
  678.     $this->red_cards_against = $red_cards_against;
  680.     return $this;
  681.   }
  683.   public function getCurrentPositionLeague(): ?int
  684.   {
  685.     return $this->currentPositionLeague;
  686.   }
  688.   public function setCurrentPositionLeague(?int $currentPositionLeague): self
  689.   {
  690.     $this->currentPositionLeague = $currentPositionLeague;
  692.     return $this;
  693.   }
  695.   /**
  696.    * @return Collection|KilometersTraveled[]
  697.    */
  698.   public function getKilometersTraveleds(): Collection
  699.   {
  700.     return $this->kilometersTraveleds;
  701.   }
  703.   public function addKilometersTraveled(KilometersTraveled $kilometersTraveled): self
  704.   {
  705.     if (!$this->kilometersTraveleds->contains($kilometersTraveled)) {
  706.       $this->kilometersTraveleds[] = $kilometersTraveled;
  707.       $kilometersTraveled->setGame($this);
  708.     }
  710.     return $this;
  711.   }
  713.   public function removeKilometersTraveled(KilometersTraveled $kilometersTraveled): self
  714.   {
  715.     if ($this->kilometersTraveleds->contains($kilometersTraveled)) {
  716.       $this->kilometersTraveleds->removeElement($kilometersTraveled);
  717.       // set the owning side to null (unless already changed)
  718.       if ($kilometersTraveled->getGame() === $this) {
  719.         $kilometersTraveled->setGame(null);
  720.       }
  721.     }
  723.     return $this;
  724.   }
  726.   /**
  727.    * @return Collection|ShotsOnGoal[]
  728.    */
  729.   public function getShotsOnGoals(): Collection
  730.   {
  731.     return $this->shotsOnGoals;
  732.   }
  734.   public function addShotsOnGoal(ShotsOnGoal $shotsOnGoal): self
  735.   {
  736.     if (!$this->shotsOnGoals->contains($shotsOnGoal)) {
  737.       $this->shotsOnGoals[] = $shotsOnGoal;
  738.       $shotsOnGoal->setGame($this);
  739.     }
  741.     return $this;
  742.   }
  744.   public function removeShotsOnGoal(ShotsOnGoal $shotsOnGoal): self
  745.   {
  746.     if ($this->shotsOnGoals->contains($shotsOnGoal)) {
  747.       $this->shotsOnGoals->removeElement($shotsOnGoal);
  748.       // set the owning side to null (unless already changed)
  749.       if ($shotsOnGoal->getGame() === $this) {
  750.         $shotsOnGoal->setGame(null);
  751.       }
  752.     }
  754.     return $this;
  755.   }
  757.   /**
  758.    * @return Collection|GamePlayerStatistics[]
  759.    */
  760.   public function getSeasonplayer(): Collection
  761.   {
  762.     return $this->seasonplayer;
  763.   }
  765.   public function addSeasonplayer(GamePlayerStatistics $seasonplayer): self
  766.   {
  767.     if (!$this->seasonplayer->contains($seasonplayer)) {
  768.       $this->seasonplayer[] = $seasonplayer;
  769.       $seasonplayer->setGame($this);
  770.     }
  772.     return $this;
  773.   }
  775.   public function removeSeasonplayer(GamePlayerStatistics $seasonplayer): self
  776.   {
  777.     if ($this->seasonplayer->contains($seasonplayer)) {
  778.       $this->seasonplayer->removeElement($seasonplayer);
  779.       // set the owning side to null (unless already changed)
  780.       if ($seasonplayer->getGame() === $this) {
  781.         $seasonplayer->setGame(null);
  782.       }
  783.     }
  785.     return $this;
  786.   }
  788.   /**
  789.    * @return Collection|GamePlayerStatistics[]
  790.    */
  791.   public function getGamePlayerStatistics(): Collection
  792.   {
  793.     return $this->gamePlayerStatistics;
  794.   }
  796.   public function addGamePlayerStatistic(GamePlayerStatistics $gamePlayerStatistic): self
  797.   {
  798.     if (!$this->gamePlayerStatistics->contains($gamePlayerStatistic)) {
  799.       $this->gamePlayerStatistics[] = $gamePlayerStatistic;
  800.       $gamePlayerStatistic->setGame($this);
  801.     }
  803.     return $this;
  804.   }
  806.   public function removeGamePlayerStatistic(GamePlayerStatistics $gamePlayerStatistic): self
  807.   {
  808.     if ($this->gamePlayerStatistics->contains($gamePlayerStatistic)) {
  809.       $this->gamePlayerStatistics->removeElement($gamePlayerStatistic);
  810.       // set the owning side to null (unless already changed)
  811.       if ($gamePlayerStatistic->getGame() === $this) {
  812.         $gamePlayerStatistic->setGame(null);
  813.       }
  814.     }
  816.     return $this;
  817.   }
  820.   public function getCompetition(): ?Competition
  821.   {
  822.     return $this->competition;
  823.   }
  825.   public function setCompetition(?Competition $competition): self
  826.   {
  827.     $this->competition = $competition;
  829.     return $this;
  830.   }
  832.   public function getOpponentCurrentPositionLeague(): ?int
  833.   {
  834.     return $this->opponentCurrentPositionLeague;
  835.   }
  837.   public function setOpponentCurrentPositionLeague(?int $opponentCurrentPositionLeague): self
  838.   {
  839.     $this->opponentCurrentPositionLeague = $opponentCurrentPositionLeague;
  841.     return $this;
  842.   }
  844.   public function getPressureRival(): ?Difficulty
  845.   {
  846.     return $this->pressureRival;
  847.   }
  849.   public function setPressureRival(?Difficulty $pressureRival): self
  850.   {
  851.     $this->pressureRival = $pressureRival;
  853.     return $this;
  854.   }
  856.   public function getDeletedAt(): ?\DateTimeInterface
  857.   {
  858.     return $this->deletedAt;
  859.   }
  861.   public function setDeletedAt(?\DateTimeInterface $deletedAt): self
  862.   {
  863.     $this->deletedAt = $deletedAt;
  865.     return $this;
  866.   }
  867. }