src/Entity/TypeOfTypes.php line 15

  1. <?php
  3. declare(strict_types=1);
  5. namespace App\Entity;
  7. use App\Repository\TypeOfTypesRepository;
  8. use App\Utils\Traits\EntityId_TimestampTrait;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Symfony\Component\Uid\Ulid;
  11. use Doctrine\Common\Collections\ArrayCollection;
  12. use Doctrine\Common\Collections\Collection;
  14. #[ORM\Entity(repositoryClass: TypeOfTypesRepository::class)]
  15. class TypeOfTypes
  16. {
  17.     use EntityId_TimestampTrait;
  19.     #[ORM\Column(type: 'string', length: 200)]
  20.     private $libelle;
  22.     #[ORM\Column(type: 'string', length: 200, nullable: true)]
  23.     private $libelleFr;
  25.     #[ORM\ManyToOne(targetEntity: self::class)]
  26.     private $parent;
  28.     #[ORM\Column(type: 'string', length: 255, unique: true)]
  29.     private $codereference;
  31.     #[ORM\OneToMany(mappedBy: 'fonction', targetEntity: FonctionUser::class)]
  32.     private Collection $fonctionUsers;
  34.     #[ORM\OneToMany(mappedBy: 'fonction', targetEntity: FonctionAction::class)]
  35.     private Collection $fonctionActions;
  37.     #[ORM\OneToMany(mappedBy: 'category', targetEntity: LibraryAssets::class)]
  38.     private Collection $libraryAssets;
  39.     public function __construct()
  40.     {
  41.         $this->uuid = new Ulid();
  42.         $this->created = new \DateTimeImmutable('now');
  43.         $this->updated = new \DateTime('now');
  44.         $this->deleted = false;
  45.         $this->fonctionUsers = new ArrayCollection();
  46.         $this->fonctionActions = new ArrayCollection();
  47.         $this->libraryAssets = new ArrayCollection();
  49.     }
  50.     public function __toString()
  51.     {
  52.         return $this->libelle;
  53.     }
  55.     public function getLibelle(): ?string
  56.     {
  57.         return $this->libelle;
  58.     }
  60.     public function setLibelle(string $libelle): self
  61.     {
  62.         $this->libelle = $libelle;
  64.         return $this;
  65.     }
  67.     public function getParent(): ?self
  68.     {
  69.         return $this->parent;
  70.     }
  72.     public function setParent(?self $parent): self
  73.     {
  74.         $this->parent = $parent;
  76.         return $this;
  77.     }
  79.     public function getCodereference(): ?string
  80.     {
  81.         return $this->codereference;
  82.     }
  84.     public function setCodereference(string $codereference): self
  85.     {
  86.         $this->codereference = $codereference;
  88.         return $this;
  89.     }
  91.     public function getId()
  92.     {
  93.         return $this->id;
  94.     }
  96.     public function getLibelleFr(): ?string
  97.     {
  98.         return $this->libelleFr;
  99.     }
  101.     public function setLibelleFr(?string $libelleFr): self
  102.     {
  103.         $this->libelleFr = $libelleFr;
  105.         return $this;
  106.     }
  107.     /**
  108.      * @return Collection<int, FonctionUser>
  109.      */
  110.     public function getFonctionUsers(): Collection
  111.     {
  112.         return $this->fonctionUsers;
  113.     }
  115.     public function addFonctionUser(FonctionUser $fonctionUser): self
  116.     {
  117.         if (!$this->fonctionUsers->contains($fonctionUser)) {
  118.             $this->fonctionUsers->add($fonctionUser);
  119.             $fonctionUser->setFonction($this);
  120.         }
  122.         return $this;
  123.     }
  125.     public function removeFonctionUser(FonctionUser $fonctionUser): self
  126.     {
  127.         if ($this->fonctionUsers->removeElement($fonctionUser)) {
  128.             // set the owning side to null (unless already changed)
  129.             if ($fonctionUser->getFonction() === $this) {
  130.                 $fonctionUser->setFonction(null);
  131.             }
  132.         }
  134.         return $this;
  135.     }
  137.     /**
  138.      * @return Collection<int, FonctionAction>
  139.      */
  140.     public function getFonctionActions(): Collection
  141.     {
  142.         return $this->fonctionActions;
  143.     }
  145.     public function addFonctionAction(FonctionAction $fonctionAction): self
  146.     {
  147.         if (!$this->fonctionActions->contains($fonctionAction)) {
  148.             $this->fonctionActions->add($fonctionAction);
  149.             $fonctionAction->setFonction($this);
  150.         }
  152.         return $this;
  153.     }
  155.     public function removeFonctionAction(FonctionAction $fonctionAction): self
  156.     {
  157.         if ($this->fonctionActions->removeElement($fonctionAction)) {
  158.             // set the owning side to null (unless already changed)
  159.             if ($fonctionAction->getFonction() === $this) {
  160.                 $fonctionAction->setFonction(null);
  161.             }
  162.         }
  164.         return $this;
  165.     }
  167.     /**
  168.      * @return Collection<int, LibraryAssets>
  169.      */
  170.     public function getLibraryAssets(): Collection
  171.     {
  172.         return $this->libraryAssets;
  173.     }
  175.     public function addLibraryAsset(LibraryAssets $libraryAsset): self
  176.     {
  177.         if (!$this->libraryAssets->contains($libraryAsset)) {
  178.             $this->libraryAssets->add($libraryAsset);
  179.             $libraryAsset->setCategory($this);
  180.         }
  182.         return $this;
  183.     }
  185.     public function removeLibraryAsset(LibraryAssets $libraryAsset): self
  186.     {
  187.         if ($this->libraryAssets->removeElement($libraryAsset)) {
  188.             // set the owning side to null (unless already changed)
  189.             if ($libraryAsset->getCategory() === $this) {
  190.                 $libraryAsset->setCategory(null);
  191.             }
  192.         }
  194.         return $this;
  195.     }
  196. }