src/Entity/Webfactory/Actualites/WebfactoryActualiteCategory.php line 12

Open in your IDE?
  1. <?php
  3. namespace App\Entity\Webfactory\Actualites;
  5. use App\Repository\Webfactory\Actualites\WebfactoryActualiteCategoryRepository;
  6. use DateTimeImmutable;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\ORM\Mapping as ORM;
  11. #[ORM\Entity(repositoryClass: WebfactoryActualiteCategoryRepository::class)]
  12. class WebfactoryActualiteCategory
  13. {
  14.     #[ORM\Id]
  15.     #[ORM\GeneratedValue]
  16.     #[ORM\Column]
  17.     private ?int $id = null;
  19.     #[ORM\Column(length: 255)]
  20.     private ?string $adherent = null;
  22.     #[ORM\Column]
  23.     private ?DateTimeImmutable $created_at;
  25.     #[ORM\Column]
  26.     private ?DateTimeImmutable $updated_at;
  28.     #[ORM\OneToMany(mappedBy: 'webfactory_category', targetEntity: WebfactoryActualiteCategoryContenu::class, cascade: ['persist', 'remove'])]
  29.     private Collection $webfactoryActualiteCategoryContenus;
  31.     #[ORM\OneToMany(mappedBy: 'actualiteCategory', targetEntity: WebfactoryActualite::class)]
  32.     private Collection $webfactoryActualites;
  34.     #[ORM\OneToMany(mappedBy: 'webfactoryCategory', targetEntity: WebfactoryActualiteBibliotheque::class)]
  35.     private Collection $webfactoryActualiteBibliotheques;
  37.     public function __construct()
  38.     {
  39.         $this->webfactoryActualiteCategoryContenus = new ArrayCollection();
  40.         $this->webfactoryActualites = new ArrayCollection();
  41.         $this->created_at = new DateTimeImmutable("now");
  42.         $this->updated_at = new DateTimeImmutable("now");
  43.         $this->webfactoryActualiteBibliotheques = new ArrayCollection();
  44.     }
  46.     public function getId(): ?int
  47.     {
  48.         return $this->id;
  49.     }
  51.     public function setId(?int $id): void
  52.     {
  53.         $this->id = $id;
  54.     }
  56.     public function getAdherent(): ?string
  57.     {
  58.         return $this->adherent;
  59.     }
  61.     public function setAdherent(string $adherent): static
  62.     {
  63.         $this->adherent = $adherent;
  65.         return $this;
  66.     }
  68.     public function getCreatedAt(): ?DateTimeImmutable
  69.     {
  70.         return $this->created_at;
  71.     }
  73.     public function setCreatedAt(DateTimeImmutable $created_at): static
  74.     {
  75.         $this->created_at = $created_at;
  77.         return $this;
  78.     }
  80.     public function getUpdatedAt(): ?DateTimeImmutable
  81.     {
  82.         return $this->updated_at;
  83.     }
  85.     public function setUpdatedAt(DateTimeImmutable $updated_at): static
  86.     {
  87.         $this->updated_at = $updated_at;
  89.         return $this;
  90.     }
  92.     /**
  93.      * @return Collection<int, WebfactoryActualiteCategoryContenu>
  94.      */
  95.     public function getWebfactoryActualiteCategoryContenus(): Collection
  96.     {
  97.         return $this->webfactoryActualiteCategoryContenus;
  98.     }
  100.     public function addWebfactoryActualiteCategoryContenu(WebfactoryActualiteCategoryContenu $webfactoryActualiteCategoryContenu): static
  101.     {
  102.         if (!$this->webfactoryActualiteCategoryContenus->contains($webfactoryActualiteCategoryContenu)) {
  103.             $this->webfactoryActualiteCategoryContenus->add($webfactoryActualiteCategoryContenu);
  104.             $webfactoryActualiteCategoryContenu->setWebfactoryCategory($this);
  105.         }
  107.         return $this;
  108.     }
  110.     public function removeWebfactoryActualiteCategoryContenu(WebfactoryActualiteCategoryContenu $webfactoryActualiteCategoryContenu): static
  111.     {
  112.         if ($this->webfactoryActualiteCategoryContenus->removeElement($webfactoryActualiteCategoryContenu)) {
  113.             // set the owning side to null (unless already changed)
  114.             if ($webfactoryActualiteCategoryContenu->getWebfactoryCategory() === $this) {
  115.                 $webfactoryActualiteCategoryContenu->setWebfactoryCategory(null);
  116.             }
  117.         }
  119.         return $this;
  120.     }
  122.     /**
  123.      * @return Collection<int, WebfactoryActualite>
  124.      */
  125.     public function getWebfactoryActualites(): Collection
  126.     {
  127.         return $this->webfactoryActualites;
  128.     }
  130.     public function addWebfactoryActualite(WebfactoryActualite $webfactoryActualite): static
  131.     {
  132.         if (!$this->webfactoryActualites->contains($webfactoryActualite)) {
  133.             $this->webfactoryActualites->add($webfactoryActualite);
  134.             $webfactoryActualite->setActualiteCategory($this);
  135.         }
  137.         return $this;
  138.     }
  140.     public function removeWebfactoryActualite(WebfactoryActualite $webfactoryActualite): static
  141.     {
  142.         if ($this->webfactoryActualites->removeElement($webfactoryActualite)) {
  143.             // set the owning side to null (unless already changed)
  144.             if ($webfactoryActualite->getActualiteCategory() === $this) {
  145.                 $webfactoryActualite->setActualiteCategory(null);
  146.             }
  147.         }
  149.         return $this;
  150.     }
  152.     /**
  153.      * @return Collection<int, WebfactoryActualiteBibliotheque>
  154.      */
  155.     public function getWebfactoryActualiteBibliotheques(): Collection
  156.     {
  157.         return $this->webfactoryActualiteBibliotheques;
  158.     }
  160.     public function addWebfactoryActualiteBibliotheque(WebfactoryActualiteBibliotheque $webfactoryActualiteBibliotheque): static
  161.     {
  162.         if (!$this->webfactoryActualiteBibliotheques->contains($webfactoryActualiteBibliotheque)) {
  163.             $this->webfactoryActualiteBibliotheques->add($webfactoryActualiteBibliotheque);
  164.             $webfactoryActualiteBibliotheque->setWebfactoryCategory($this);
  165.         }
  167.         return $this;
  168.     }
  170.     public function removeWebfactoryActualiteBibliotheque(WebfactoryActualiteBibliotheque $webfactoryActualiteBibliotheque): static
  171.     {
  172.         if ($this->webfactoryActualiteBibliotheques->removeElement($webfactoryActualiteBibliotheque)) {
  173.             // set the owning side to null (unless already changed)
  174.             if ($webfactoryActualiteBibliotheque->getWebfactoryCategory() === $this) {
  175.                 $webfactoryActualiteBibliotheque->setWebfactoryCategory(null);
  176.             }
  177.         }
  179.         return $this;
  180.     }
  182.     public function getContenuByLang($lang)
  183.     {
  184.         foreach ($this->webfactoryActualiteCategoryContenus as $categContenu) {
  185.             if (strtolower($categContenu->getLang()) === strtolower($lang)) {
  186.                 return $categContenu;
  187.             }
  188.         }
  189.     }
  191.     public function __toString(): string
  192.     {
  193.         $return = "";
  194.         foreach ($this->webfactoryActualiteCategoryContenus as $key => $contenu) {
  195.             $return .= $contenu->getName();
  196.             if ($key < count($this->webfactoryActualiteCategoryContenus) - 1) {
  197.                 $return .= ' / ';
  198.             }
  199.         }
  200.         return $return;
  201.     }
  203. }