src/Entity/Campus.php line 14

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\CampusRepository;
  6. use App\Traits\EntityDateTimeAbleTrait;
  7. use App\Traits\SeoTrait;
  8. use Doctrine\Common\Collections\ArrayCollection;
  9. use Doctrine\Common\Collections\Collection;
  10. use Doctrine\ORM\Mapping as ORM;
  12. #[ORM\Entity(repositoryClass: CampusRepository::class)]
  13. #[ORM\HasLifecycleCallbacks]
  14. class Campus
  15. {
  17.     use EntityDateTimeAbleTrait;
  18.     use SeoTrait;
  20.     const STATUS_ACTIVE = 1;
  21.     const STATUS_INACTIVE = 0;
  23.     #[ORM\Id]
  24.     #[ORM\GeneratedValue]
  25.     #[ORM\Column(type: 'integer')]
  26.     private $id;
  28.     #[ORM\Column(type: 'string', length: 255)]
  29.     private ?string $name = null;
  31.     #[ORM\Column(type: 'string', length: 255)]
  32.     private $slug;
  34.     #[ORM\Column(type: 'integer')]
  35.     private ?int $status = null;
  37.     #[ORM\Column(type: 'integer', nullable: true)]
  38.     private ?int $ordering = null;
  40.     #[ORM\ManyToMany(targetEntity: User::class, mappedBy: 'campuses')]
  41.     private Collection $users;
  43.     #[ORM\OneToMany(targetEntity: Profile::class, mappedBy: 'campus')]
  44.     private Collection $profiles;
  46.     #[ORM\ManyToMany(targetEntity: Program::class, mappedBy: 'campuses')]
  47.     private Collection $programs;
  49.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  50.     private ?string $city = null;
  52.     #[ORM\OneToOne(targetEntity: Media::class, cascade: ['persist', 'remove'])]
  53.     private ?\App\Entity\Media $logo = null;
  55.     #[ORM\ManyToMany(targetEntity: Media::class, orphanRemoval: true, cascade: ['persist', 'remove'])]
  56.     private Collection $images;
  58.     #[ORM\Column(type: 'json', nullable: true)]
  59.     private ?array $youtubeUrl = [];
  61.     #[ORM\OneToMany(targetEntity: CampusCenter::class, mappedBy: 'campus', orphanRemoval: true, cascade: ['persist', 'remove'])]
  62.     private Collection $campusCenters;
  64.     #[ORM\OneToMany(targetEntity: CampusPresentationBlock::class, mappedBy: 'campus', orphanRemoval: true, cascade: ['persist', 'remove'])]
  65.     private Collection $presentationBlocks;
  67.     #[ORM\OneToMany(targetEntity: CampusArticle::class, mappedBy: 'campus', orphanRemoval: true, cascade: ['persist', 'remove'])]
  68.     private Collection $articles;
  70.     #[ORM\OneToMany(targetEntity: CampusKeyFigure::class, mappedBy: 'campus', orphanRemoval: true, cascade: ['persist', 'remove'])]
  71.     private Collection $keyFigures;
  73.     #[ORM\ManyToMany(targetEntity: Offer::class, mappedBy: 'campuses')]
  74.     private Collection $offers;
  76.     #[ORM\OneToMany(targetEntity: Candidate::class, mappedBy: 'campus')]
  77.     private Collection $candidates;
  79.     #[ORM\OneToOne(targetEntity: Media::class, cascade: ['persist', 'remove'])]
  80.     private ?\App\Entity\Media $imageDepiction = null;
  82.     #[ORM\OneToMany(targetEntity: Participate::class, mappedBy: 'campus')]
  83.     private Collection $participates;
  85.     #[ORM\OneToMany(mappedBy: 'campus', targetEntity: OpenDayPerson::class)]
  86.     private Collection $openDayPeople;
  88.     #[ORM\ManyToMany(targetEntity: Forum::class, mappedBy: 'campuses')]
  89.     private Collection $forums;
  91.     public function __construct()
  92.     {
  93.         $this->users = new ArrayCollection();
  94.         $this->profiles = new ArrayCollection();
  95.         $this->programs = new ArrayCollection();
  96.         $this->images = new ArrayCollection();
  97.         $this->campusCenters = new ArrayCollection();
  98.         $this->presentationBlocks = new ArrayCollection();
  99.         $this->articles = new ArrayCollection();
  100.         $this->keyFigures = new ArrayCollection();
  101.         $this->offers = new ArrayCollection();
  102.         $this->candidates = new ArrayCollection();
  103.         $this->participates = new ArrayCollection();
  104.         $this->openDayPeople = new ArrayCollection();
  105.         $this->forums = new ArrayCollection();
  106.     }
  108.     public function getId(): ?int
  109.     {
  110.         return $this->id;
  111.     }
  113.     public function getName(): ?string
  114.     {
  115.         return $this->name;
  116.     }
  118.     public function setName(string $name): self
  119.     {
  120.         $this->name = $name;
  122.         return $this;
  123.     }
  125.     public function getSlug(): ?string
  126.     {
  127.         return $this->slug;
  128.     }
  130.     public function setSlug(string $slug): self
  131.     {
  132.         $this->slug = $slug;
  133.         return $this;
  134.     }
  136.     public function getStatus(): ?int
  137.     {
  138.         return $this->status;
  139.     }
  141.     public function setStatus(int $status): self
  142.     {
  143.         $this->status = $status;
  145.         return $this;
  146.     }
  148.     public function getOrdering(): ?int
  149.     {
  150.         return $this->ordering;
  151.     }
  153.     public function setOrdering(?int $ordering): self
  154.     {
  155.         $this->ordering = $ordering;
  157.         return $this;
  158.     }
  160.     /**
  161.      * @return Collection<int, User>
  162.      */
  163.     public function getUsers(): Collection
  164.     {
  165.         return $this->users;
  166.     }
  168.     public function addUser(User $user): self
  169.     {
  170.         if (!$this->users->contains($user)) {
  171.             $this->users[] = $user;
  172.             $user->addCampus($this);
  173.         }
  175.         return $this;
  176.     }
  178.     public function removeUser(User $user): self
  179.     {
  180.         if ($this->users->removeElement($user)) {
  181.             $user->removeCampus($this);
  182.         }
  184.         return $this;
  185.     }
  187.     /**
  188.      * @return Collection<int, Profile>
  189.      */
  190.     public function getProfiles(): Collection
  191.     {
  192.         return $this->profiles;
  193.     }
  195.     public function addProfile(Profile $profile): self
  196.     {
  197.         if (!$this->profiles->contains($profile)) {
  198.             $this->profiles[] = $profile;
  199.             $profile->setCampus($this);
  200.         }
  202.         return $this;
  203.     }
  205.     public function removeProfile(Profile $profile): self
  206.     {
  207.         if ($this->profiles->removeElement($profile)) {
  208.             // set the owning side to null (unless already changed)
  209.             if ($profile->getCampus() === $this) {
  210.                 $profile->setCampus(null);
  211.             }
  212.         }
  214.         return $this;
  215.     }
  217.     /**
  218.      * @return Collection<int, Program>
  219.      */
  220.     public function getPrograms(): Collection
  221.     {
  222.         return $this->programs;
  223.     }
  225.     public function addProgram(Program $program): self
  226.     {
  227.         if (!$this->programs->contains($program)) {
  228.             $this->programs[] = $program;
  229.             $program->addCampus($this);
  230.         }
  232.         return $this;
  233.     }
  235.     public function removeProgram(Program $program): self
  236.     {
  237.         if ($this->programs->removeElement($program)) {
  238.             $program->removeCampus($this);
  239.         }
  241.         return $this;
  242.     }
  244.     public function getCity(): ?string
  245.     {
  246.         return $this->city;
  247.     }
  249.     public function setCity(string $city): self
  250.     {
  251.         $this->city = $city;
  253.         return $this;
  254.     }
  256.     public function getLogo(): ?Media
  257.     {
  258.         return $this->logo;
  259.     }
  261.     public function setLogo(?Media $logo): self
  262.     {
  263.         $this->logo = $logo;
  265.         return $this;
  266.     }
  268.     /**
  269.      * @return Collection<int, Media>
  270.      */
  271.     public function getImages(): Collection
  272.     {
  273.         return $this->images;
  274.     }
  276.     public function addImage(Media $image): self
  277.     {
  278.         if (!$this->images->contains($image)) {
  279.             $this->images[] = $image;
  280.         }
  282.         return $this;
  283.     }
  285.     public function removeImage(Media $image): self
  286.     {
  287.         $this->images->removeElement($image);
  289.         return $this;
  290.     }
  292.     public function getYoutubeUrl(): ?array
  293.     {
  294.         return $this->youtubeUrl;
  295.     }
  297.     public function setYoutubeUrl(?array $youtubeUrl): self
  298.     {
  299.         $this->youtubeUrl = $youtubeUrl;
  301.         return $this;
  302.     }
  304.     /**
  305.      * @return Collection<int, CampusCenter>
  306.      */
  307.     public function getCampusCenters(): Collection
  308.     {
  309.         return $this->campusCenters;
  310.     }
  312.     public function addCampusCenter(CampusCenter $campusCenter): self
  313.     {
  314.         if (!$this->campusCenters->contains($campusCenter)) {
  315.             $this->campusCenters[] = $campusCenter;
  316.             $campusCenter->setCampus($this);
  317.         }
  319.         return $this;
  320.     }
  322.     public function removeCampusCenter(CampusCenter $campusCenter): self
  323.     {
  324.         if ($this->campusCenters->removeElement($campusCenter)) {
  325.             // set the owning side to null (unless already changed)
  326.             if ($campusCenter->getCampus() === $this) {
  327.                 $campusCenter->setCampus(null);
  328.             }
  329.         }
  331.         return $this;
  332.     }
  334.     /**
  335.      * @return Collection<int, CampusPresentationBlock>
  336.      */
  337.     public function getPresentationBlocks(): Collection
  338.     {
  339.         return $this->presentationBlocks;
  340.     }
  342.     public function addPresentationBlock(CampusPresentationBlock $presentationBlock): self
  343.     {
  344.         if (!$this->presentationBlocks->contains($presentationBlock)) {
  345.             $this->presentationBlocks[] = $presentationBlock;
  346.             $presentationBlock->setCampus($this);
  347.         }
  349.         return $this;
  350.     }
  352.     public function removePresentationBlock(CampusPresentationBlock $presentationBlock): self
  353.     {
  354.         if ($this->presentationBlocks->removeElement($presentationBlock)) {
  355.             // set the owning side to null (unless already changed)
  356.             if ($presentationBlock->getCampus() === $this) {
  357.                 $presentationBlock->setCampus(null);
  358.             }
  359.         }
  361.         return $this;
  362.     }
  364.     /**
  365.      * @return Collection<int, CampusArticle>
  366.      */
  367.     public function getArticles(): Collection
  368.     {
  369.         return $this->articles;
  370.     }
  372.     public function addArticle(CampusArticle $article): self
  373.     {
  374.         if (!$this->articles->contains($article)) {
  375.             $this->articles[] = $article;
  376.             $article->setCampus($this);
  377.         }
  379.         return $this;
  380.     }
  382.     public function removeArticle(CampusArticle $article): self
  383.     {
  384.         if ($this->articles->removeElement($article)) {
  385.             // set the owning side to null (unless already changed)
  386.             if ($article->getCampus() === $this) {
  387.                 $article->setCampus(null);
  388.             }
  389.         }
  391.         return $this;
  392.     }
  394.     /**
  395.      * @return Collection<int, CampusKeyFigure>
  396.      */
  397.     public function getKeyFigures(): Collection
  398.     {
  399.         return $this->keyFigures;
  400.     }
  402.     public function addKeyFigure(CampusKeyFigure $keyFigure): self
  403.     {
  404.         if (!$this->keyFigures->contains($keyFigure)) {
  405.             $this->keyFigures[] = $keyFigure;
  406.             $keyFigure->setCampus($this);
  407.         }
  409.         return $this;
  410.     }
  412.     public function removeKeyFigure(CampusKeyFigure $keyFigure): self
  413.     {
  414.         if ($this->keyFigures->removeElement($keyFigure)) {
  415.             // set the owning side to null (unless already changed)
  416.             if ($keyFigure->getCampus() === $this) {
  417.                 $keyFigure->setCampus(null);
  418.             }
  419.         }
  421.         return $this;
  422.     }
  424.     /**
  425.      * @return Collection<int, Offer>
  426.      */
  427.     public function getOffers(): Collection
  428.     {
  429.         return $this->offers;
  430.     }
  432.     public function addOffer(Offer $offer): self
  433.     {
  434.         if (!$this->offers->contains($offer)) {
  435.             $this->offers[] = $offer;
  436.             $offer->addCampus($this);
  437.         }
  439.         return $this;
  440.     }
  442.     public function removeOffer(Offer $offer): self
  443.     {
  444.         if ($this->offers->removeElement($offer)) {
  445.             $offer->removeCampus($this);
  446.         }
  448.         return $this;
  449.     }
  451.     /**
  452.      * @return Collection<int, Candidate>
  453.      */
  454.     public function getCandidates(): Collection
  455.     {
  456.         return $this->candidates;
  457.     }
  459.     public function addCandidate(Candidate $candidate): self
  460.     {
  461.         if (!$this->candidates->contains($candidate)) {
  462.             $this->candidates[] = $candidate;
  463.             $candidate->setCampus($this);
  464.         }
  466.         return $this;
  467.     }
  469.     public function removeCandidate(Candidate $candidate): self
  470.     {
  471.         if ($this->candidates->removeElement($candidate)) {
  472.             // set the owning side to null (unless already changed)
  473.             if ($candidate->getCampus() === $this) {
  474.                 $candidate->setCampus(null);
  475.             }
  476.         }
  478.         return $this;
  479.     }
  481.     public function getImageDepiction(): ?Media
  482.     {
  483.         return $this->imageDepiction;
  484.     }
  486.     public function setImageDepiction(?Media $imageDepiction): self
  487.     {
  488.         $this->imageDepiction = $imageDepiction;
  490.         return $this;
  491.     }
  493.     /**
  494.      * @return Collection<int, Participate>
  495.      */
  496.     public function getParticipates(): Collection
  497.     {
  498.         return $this->participates;
  499.     }
  501.     public function addParticipate(Participate $participate): self
  502.     {
  503.         if (!$this->participates->contains($participate)) {
  504.             $this->participates[] = $participate;
  505.             $participate->setCampus($this);
  506.         }
  508.         return $this;
  509.     }
  511.     public function removeParticipate(Participate $participate): self
  512.     {
  513.         if ($this->participates->removeElement($participate)) {
  514.             // set the owning side to null (unless already changed)
  515.             if ($participate->getCampus() === $this) {
  516.                 $participate->setCampus(null);
  517.             }
  518.         }
  520.         return $this;
  521.     }
  523.     /**
  524.      * @return Collection<int, OpenDayPerson>
  525.      */
  526.     public function getOpenDayPeople(): Collection
  527.     {
  528.         return $this->openDayPeople;
  529.     }
  531.     public function addOpenDayPerson(OpenDayPerson $openDayPerson): static
  532.     {
  533.         if (!$this->openDayPeople->contains($openDayPerson)) {
  534.             $this->openDayPeople->add($openDayPerson);
  535.             $openDayPerson->setCampus($this);
  536.         }
  538.         return $this;
  539.     }
  541.     public function removeOpenDayPerson(OpenDayPerson $openDayPerson): static
  542.     {
  543.         if ($this->openDayPeople->removeElement($openDayPerson)) {
  544.             // set the owning side to null (unless already changed)
  545.             if ($openDayPerson->getCampus() === $this) {
  546.                 $openDayPerson->setCampus(null);
  547.             }
  548.         }
  550.         return $this;
  551.     }
  553.     /**
  554.      * @return Collection<int, Forum>
  555.      */
  556.     public function getForums(): Collection
  557.     {
  558.         return $this->forums;
  559.     }
  561.     public function addForum(Forum $forum): static
  562.     {
  563.         if (!$this->forums->contains($forum)) {
  564.             $this->forums->add($forum);
  565.             $forum->addCampus($this);
  566.         }
  568.         return $this;
  569.     }
  571.     public function removeForum(Forum $forum): static
  572.     {
  573.         if ($this->forums->removeElement($forum)) {
  574.             $forum->removeCampus($this);
  575.         }
  577.         return $this;
  578.     }
  579. }