src/Entity/AbstractAuthors.php line 12

  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\AbstractAuthorsRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\DBAL\Types\Types;
  9. use Doctrine\ORM\Mapping as ORM;
  11. #[ORM\Entity(repositoryClass: AbstractAuthorsRepository::class)]
  12. class AbstractAuthors
  13. {
  14.     const RESIDENT = 0;
  15.     const SPECIALISTE = 1;
  16.     const ASSISTANT = 2;
  17.     const PROF = 3;
  18.     const PROFAGREGE = 4;
  20.     #[ORM\Id]
  21.     #[ORM\GeneratedValue]
  22.     #[ORM\Column]
  23.     private ?int $id = null;
  25.     #[ORM\Column(length: 255, nullable: true)]
  26.     private ?string $firstName = null;
  28.     #[ORM\Column(length: 255, nullable: true)]
  29.     private ?string $lastName = null;
  31.     #[ORM\Column(length: 255, nullable: true)]
  32.     private ?string $service = null;
  34.     #[ORM\Column(type: Types::SMALLINT, nullable: true)]
  35.     private ?int $title = null;
  37.     #[ORM\Column(type: Types::SMALLINT, nullable: true)]
  38.     private ?int $isResponsible = null;
  40.     #[ORM\Column(type: Types::SMALLINT, nullable: true)]
  41.     private ?int $isPresenter = null;
  43.     #[ORM\OneToMany(targetEntity: EventAbstract::class, mappedBy: 'responsable')]
  44.     private Collection $eventAbstractAsResponsable;
  46.     #[ORM\ManyToMany(targetEntity: EventAbstract::class, mappedBy: 'presenters')]
  47.     private Collection $eventAbstractsAsPresenter;
  49.     # [ORM\ManyToMany(targetEntity: EventAbstract::class, mappedBy: 'authors')]
  50.     private Collection $eventAbstractsAsAuthors;
  52.     #[ORM\ManyToOne]
  53.     private ?EventAbstract $abstract = null;
  55.     public function __construct()
  56.     {
  57.         $this->eventAbstractAsResponsable = new ArrayCollection();
  58.         $this->eventAbstractsAsPresenter = new ArrayCollection();
  60.         $this->eventAbstractsAsAuthors = new ArrayCollection();
  61.     }
  63.     public function getId(): ?int
  64.     {
  65.         return $this->id;
  66.     }
  68.     public function getFirstName(): ?string
  69.     {
  70.         return $this->firstName;
  71.     }
  73.     public function setFirstName(?string $firstName): static
  74.     {
  75.         $this->firstName = $firstName;
  77.         return $this;
  78.     }
  80.     public function getService(): ?string
  81.     {
  82.         return $this->service;
  83.     }
  85.     public function setService(?string $service): static
  86.     {
  87.         $this->service = $service;
  89.         return $this;
  90.     }
  92.     public function getTitle(): ?int
  93.     {
  94.         return $this->title;
  95.     }
  97.     public function setTitle(?int $title): static
  98.     {
  99.         $this->title = $title;
  101.         return $this;
  102.     }
  104.     public function getIsResponsible(): ?int
  105.     {
  106.         return $this->isResponsible;
  107.     }
  109.     public function setIsResponsible(?int $isResponsible): static
  110.     {
  111.         $this->isResponsible = $isResponsible;
  113.         return $this;
  114.     }
  116.     public function getIsPresenter(): ?int
  117.     {
  118.         return $this->isPresenter;
  119.     }
  121.     public function setIsPresenter(?int $isPresenter): static
  122.     {
  123.         $this->isPresenter = $isPresenter;
  125.         return $this;
  126.     }
  128.     /**
  129.      * cette fonction retourne les abstratcs où l'auteur est responsable d'abstract
  130.      * @return Collection<int, EventAbstract>
  131.      */
  132.     public function getEventAbstractAsResponsable(): Collection
  133.     {
  134.         return $this->eventAbstractAsResponsable;
  135.     }
  137.     /**
  138.      * cette fonction ajoute un abstract à la liste des abstracts où l'auteur est responsable
  139.      * @param EventAbstract $eventAbstract
  140.      * @return self
  141.      */
  142.     public function addEventAbstractAsResponsable(EventAbstract $eventAbstract): static
  143.     {
  144.         if (!$this->eventAbstractAsResponsable->contains($eventAbstract)) {
  145.             $this->eventAbstractAsResponsable->add($eventAbstract);
  146.             $eventAbstract->setResponsable($this);
  147.         }
  149.         return $this;
  150.     }
  152.     /**
  153.      * cette fonction enlève un abstract de la liste des abstracts où l'auteur est responsable
  154.      * @param EventAbstract $eventAbstract
  155.      * @return self
  156.      */
  157.     public function removeEventAbstractAsResponsable(EventAbstract $eventAbstract): static
  158.     {
  159.         if ($this->eventAbstractAsResponsable->removeElement($eventAbstract)) {
  160.             // set the owning side to null (unless already changed)
  161.             if ($eventAbstract->getResponsable() === $this) {
  162.                 $eventAbstract->setResponsable(null);
  163.             }
  164.         }
  166.         return $this;
  167.     }
  169.     /**
  170.      * Cette fonction retourne les abstracts où l'auteur a été présentateur
  171.      * @return Collection<int, EventAbstract>
  172.      */
  173.     public function getEventAbstractsAsPresenter(): Collection
  174.     {
  175.         return $this->eventAbstractsAsPresenter;
  176.     }
  178.     /**
  179.      * cette fonction ajoute un abstract à la liste des abstracts où l'auteur est présnateur
  180.      * @param EventAbstract $eventAbstract
  181.      * @return self
  182.      */
  183.     public function addEventAbstractAsPresenter(EventAbstract $eventAbstract): static
  184.     {
  185.         if (!$this->eventAbstractsAsPresenter->contains($eventAbstract)) {
  186.             $this->eventAbstractsAsPresenter->add($eventAbstract);
  187.             $eventAbstract->addPresenter($this);
  188.         }
  190.         return $this;
  191.     }
  192.     /**
  193.      * cette fonction ajoute un abstract à la liste des abstracts où l'auteur est présentateur
  194.      * @param EventAbstract $eventAbstract
  195.      * @return self
  196.      */
  197.     public function removeEventAbstractAsPresenter(EventAbstract $eventAbstract): static
  198.     {
  199.         if ($this->eventAbstractsAsPresenter->removeElement($eventAbstract)) {
  200.             if ($eventAbstract->getPresenters()->contains($this)) {
  201.                 $eventAbstract->removePresenter($this);
  202.             }
  203.         }
  205.         return $this;
  206.     }
  208.     public function getLastName(): ?string
  209.     {
  210.         return $this->lastName;
  211.     }
  213.     public function setLastName(?string $lastName): static
  214.     {
  215.         $this->lastName = $lastName;
  217.         return $this;
  218.     }
  220.     public function getAbstract(): ?EventAbstract
  221.     {
  222.         return $this->abstract;
  223.     }
  225.     public function setAbstract(?EventAbstract $abstract): static
  226.     {
  227.         $this->abstract = $abstract;
  229.         return $this;
  230.     }
  232.     /**
  233.      * Get the value of eventAbstractsAuthors
  234.      */
  235.     public function getEventAbstractsAsAuthors()
  236.     {
  237.         return $this->eventAbstractsAsAuthors;
  238.     }
  240.     /**
  241.      * Set the value of eventAbstractsAuthors
  242.      *
  243.      * @return  self
  244.      */
  245.     public function setEventAbstractsAsAuthors($eventAbstractsAsAuthors)
  246.     {
  247.         $this->eventAbstractsAsAuthors = $eventAbstractsAsAuthors;
  249.         return $this;
  250.     }
  252.     /**
  253.      * cette fonction ajoute un abstract à la liste des abstracts où l'auteur est présnateur
  254.      * @param EventAbstract $eventAbstract
  255.      * @return self
  256.      */
  257.     public function addEventAbstractsAuthor(EventAbstract $eventAbstract): static
  258.     {
  259.         if (!$this->eventAbstractsAsAuthors->contains($eventAbstract)) {
  260.             $this->eventAbstractsAsAuthors->add($eventAbstract);
  261.             $eventAbstract->addAuthor($this);
  262.         }
  264.         return $this;
  265.     }
  266.     /**
  267.      * cette fonction ajoute un abstract à la liste des abstracts où l'auteur est présentateur
  268.      * @param EventAbstract $eventAbstract
  269.      * @return self
  270.      */
  271.     public function removeEventAbstractsAuthor(EventAbstract $eventAbstract): static
  272.     {
  273.         if ($this->eventAbstractsAsAuthors->removeElement($eventAbstract)) {
  274.             if ($eventAbstract->getAuthors()->contains($this)) {
  275.                 $eventAbstract->removeAuthor($this);
  276.             }
  277.         }
  279.         return $this;
  280.     }
  281. }