src/Entity/EventAbstract.php line 12

  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\EventAbstractRepository;
  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: EventAbstractRepository::class)]
  12. class EventAbstract
  13. {
  14.     //decisions
  15.     const COMMUNICATION_ORALE = 1;
  16.     const COMMUNICATION_ECRITE = 2;
  17.     const POSTER_COMMENTE = 3;
  18.     const POSTER_ELECTRONIQUE = 4;
  19.     //types
  20.     const COMMUNICATION = 1;
  21.     const POSTER = 2;
  22.     //statut
  23.     const ACCEPTED = 1;
  24.     const REFUSED = 2;
  25.     const PENDING = 3;
  26.     const DRAFT = 4;
  28.     #[ORM\Id]
  29.     #[ORM\GeneratedValue]
  30.     #[ORM\Column]
  31.     private ?int $id = null;
  33.     #[ORM\Column(type: Types::SMALLINT, nullable: true)]
  34.     private ?int $type = null;
  36.     #[ORM\Column(length: 255, nullable: true)]
  37.     private ?string $title = null;
  39.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  40.     private ?string $intro = null;
  42.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  43.     private ?string $objectifs = null;
  45.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  46.     private ?string $methodes = null;
  48.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  49.     private ?string $result = null;
  51.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  52.     private ?string $conclusion = null;
  54.     #[ORM\Column(type: Types::SMALLINT, nullable: true)]
  55.     private ?int $status = null;
  57.     #[ORM\Column(nullable: true)]
  58.     private ?int $updated_by = null;
  60.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  61.     private ?\DateTimeInterface $created_at = null;
  63.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  64.     private ?\DateTimeInterface $updated_at = null;
  66.     #[ORM\ManyToOne(inversedBy: 'eventAbstracts')]
  67.     #[ORM\JoinColumn(nullable: true)]
  68.     private ?Evenement $event = null;
  70.     # [ORM\ManyToOne(targetEntity: Theme::class, inversedBy: 'eventAbstract')]
  71.     private ?Theme $theme = null;
  73.     #[ORM\ManyToMany(targetEntity: Theme::class, inversedBy: 'eventAbstracts')]
  74.     #[ORM\JoinTable(name: "event_abstract_themes")]
  75.     private Collection $themes;
  77.     #[ORM\ManyToOne(targetEntity: AbstractAuthors::class, inversedBy: 'eventAbstract')]
  78.     # [ORM\JoinTable(name: "event_abstract_responsible")]
  79.     private ?AbstractAuthors $responsable = null;
  81.     #[ORM\ManyToMany(targetEntity: AbstractAuthors::class, inversedBy: 'eventAbstractsAsPresenter', cascade: ["persist", "remove"])]
  82.     #[ORM\JoinTable(name: "event_abstract_as_presenters")]
  83.     private Collection $presenters;
  85.     #[ORM\ManyToMany(targetEntity: AbstractAuthors::class, inversedBy: 'eventAbstractsAsAuthors', cascade: ["persist", "remove"])]
  86.     #[ORM\JoinTable(name: "event_abstract_as_authors")]
  87.     private Collection $authors;
  89.     #[ORM\Column(length: 255, nullable: true)]
  90.     private ?string $reference = null;
  92.     #[ORM\ManyToOne(targetEntity: User::class, inversedBy: 'eventAbstracts')]
  93.     #[ORM\JoinColumn(nullable: true)]
  94.     private ?User $user = null;
  96.     #[ORM\Column(length: 255, nullable: true)]
  97.     private ?int $decision = null;
  99.     public function __construct()
  100.     {
  101.         $this->themes = new ArrayCollection();
  102.         $this->presenters = new ArrayCollection();
  103.         $this->created_at = new \DateTime();
  104.         $this->status = self::DRAFT;
  105.         $this->authors = new ArrayCollection();
  106.     }
  108.     public function getId(): ?int
  109.     {
  110.         return $this->id;
  111.     }
  113.     public function getType(): ?int
  114.     {
  115.         return $this->type;
  116.     }
  118.     public function setType(?int $type): static
  119.     {
  120.         $this->type = $type;
  122.         return $this;
  123.     }
  125.     public function getTitle(): ?string
  126.     {
  127.         return $this->title;
  128.     }
  130.     public function setTitle(?string $title): static
  131.     {
  132.         $this->title = $title;
  134.         return $this;
  135.     }
  137.     public function getIntro(): ?string
  138.     {
  139.         return $this->intro;
  140.     }
  142.     public function setIntro(?string $intro): static
  143.     {
  144.         $this->intro = $intro;
  146.         return $this;
  147.     }
  149.     public function getObjectifs(): ?string
  150.     {
  151.         return $this->objectifs;
  152.     }
  154.     public function setObjectifs(?string $objectifs): static
  155.     {
  156.         $this->objectifs = $objectifs;
  158.         return $this;
  159.     }
  161.     public function getMethodes(): ?string
  162.     {
  163.         return $this->methodes;
  164.     }
  166.     public function setMethodes(?string $methodes): static
  167.     {
  168.         $this->methodes = $methodes;
  170.         return $this;
  171.     }
  173.     public function getResult(): ?string
  174.     {
  175.         return $this->result;
  176.     }
  178.     public function setResult(?string $result): static
  179.     {
  180.         $this->result = $result;
  182.         return $this;
  183.     }
  185.     public function getConclusion(): ?string
  186.     {
  187.         return $this->conclusion;
  188.     }
  190.     public function setConclusion(?string $conclusion): static
  191.     {
  192.         $this->conclusion = $conclusion;
  194.         return $this;
  195.     }
  197.     public function getStatus(): ?int
  198.     {
  199.         return $this->status;
  200.     }
  202.     public function setStatus(?int $status): static
  203.     {
  204.         $this->status = $status;
  206.         return $this;
  207.     }
  210.     public function getUpdatedBy(): ?int
  211.     {
  212.         return $this->updated_by;
  213.     }
  215.     public function setUpdatedBy(?int $updated_by): static
  216.     {
  217.         $this->updated_by = $updated_by;
  219.         return $this;
  220.     }
  222.     public function getCreatedAt(): ?\DateTimeInterface
  223.     {
  224.         return $this->created_at;
  225.     }
  227.     public function setCreatedAt(?\DateTimeInterface $created_at): static
  228.     {
  229.         $this->created_at = $created_at;
  231.         return $this;
  232.     }
  234.     public function getUpdatedAt(): ?\DateTimeInterface
  235.     {
  236.         return $this->updated_at;
  237.     }
  239.     public function setUpdatedAt(?\DateTimeInterface $updated_at): static
  240.     {
  241.         $this->updated_at = $updated_at;
  243.         return $this;
  244.     }
  246.     public function getEvenement(): ?Evenement
  247.     {
  248.         return $this->event;
  249.     }
  251.     public function setEvenement(?Evenement $event): static
  252.     {
  253.         $this->event = $event;
  255.         return $this;
  256.     }
  258.     /**
  259.      * @deprecated
  260.      */
  261.     public function getEvent(): ?Evenement
  262.     {
  263.         return $this->event;
  264.     }
  266.     /**
  267.      * @deprecated
  268.      */
  269.     public function setEvent(?Evenement $event): static
  270.     {
  271.         $this->event = $event;
  273.         return $this;
  274.     }
  276.     public function getTheme(): ?Theme
  277.     {
  278.         // if (empty($this->theme) && !$this->themes->isEmpty()) {
  279.         //     return $this->themes->first();
  280.         // }
  281.         return $this->theme;
  282.     }
  284.     public function setTheme(?Theme $theme): static
  285.     {
  286.         $this->theme = $theme;
  288.         return $this;
  289.     }
  291.     public function getThemes(): Collection
  292.     {
  293.         return $this->themes;
  294.     }
  296.     public function addTheme(?Theme $theme): static
  297.     {
  298.         if (!$this->themes->contains($theme)) {
  299.             $this->themes->add($theme);
  300.             $theme->addEventAbstract($this);
  301.         }
  303.         return $this;
  304.     }
  306.     public function removeTheme(?Theme $theme): static
  307.     {
  308.         if ($this->themes->removeElement($theme)) {
  309.             $theme->removeEventAbstract($this);
  310.         }
  312.         return $this;
  313.     }
  316.     public function getResponsable(): ?AbstractAuthors
  317.     {
  318.         return $this->responsable;
  319.     }
  321.     public function setResponsable(?AbstractAuthors $responsable): static
  322.     {
  323.         $this->responsable = $responsable;
  325.         return $this;
  326.     }
  328.     /**
  329.      * @return Collection<int, AbstractAuthors>
  330.      */
  331.     public function getPresenters(): Collection
  332.     {
  333.         return $this->presenters;
  334.     }
  336.     public function addPresenter(AbstractAuthors $presenter): static
  337.     {
  338.         if (!$this->presenters->contains($presenter)) {
  339.             $this->presenters->add($presenter);
  340.         }
  342.         return $this;
  343.     }
  345.     public function removePresenter(AbstractAuthors $presenter): static
  346.     {
  347.         $this->presenters->removeElement($presenter);
  349.         return $this;
  350.     }
  352.     public function getReference(): ?string
  353.     {
  354.         return $this->reference;
  355.     }
  357.     public function setReference(?string $reference): static
  358.     {
  359.         $this->reference = $reference;
  361.         return $this;
  362.     }
  364.     /**
  365.      * Cette fonction sert à générer une référence pour un abstract selon son type
  366.      * @return string
  367.      */
  368.     public function generateReference(): string
  369.     {
  370.         //get original occurrence
  371.         $compteurs = $this->getEvenement()->getCompteurs();
  372.         if (!isset($compteurs[$this->decision])) {
  373.             $compteurs[$this->decision] = 1;
  374.         }
  375.         $occ = $compteurs[$this->decision];
  377.         //update compteurs in event
  378.         $occ++;
  379.         $this->getEvenement()->modifyCompteurs($this->decision, $occ);
  381.         //generate the reference
  382.         return match ($this->decision) {
  383.             self::COMMUNICATION_ORALE => "CO" . $occ,
  384.             self::COMMUNICATION_ECRITE => "CE" . $occ,
  385.             self::POSTER_COMMENTE =>   "PC" . $occ,
  386.             self::POSTER_ELECTRONIQUE => "PE" . $occ,
  387.             default => "PO" . $occ, // self::POSTER
  388.         };
  389.     }
  391.     public function getUser(): ?User
  392.     {
  393.         return $this->user;
  394.     }
  396.     public function setUser(?User $user): static
  397.     {
  398.         $this->user = $user;
  400.         return $this;
  401.     }
  403.     /**
  404.      * @return Collection<int, AbstractAuthors>
  405.      */
  406.     public function getAuthors(): ?Collection
  407.     {
  408.         return $this->authors;
  409.     }
  411.     public function addAuthor(AbstractAuthors $author): void
  412.     {
  413.         if (!$this->authors->contains($author)) {
  414.             $this->authors->add($author);
  415.         }
  416.     }
  418.     public function removeAuthor(AbstractAuthors $author): void
  419.     {
  420.         if ($this->presenters->contains($author)) {
  421.             $this->removePresenter($author);
  422.         }
  423.         if ($this->responsable == $author) {
  424.             $this->setResponsable(null);
  425.         }
  426.         $this->authors->removeElement($author);
  427.     }
  429.     public function getDecision(): ?int
  430.     {
  431.         return $this->decision;
  432.     }
  434.     public function setDecision(?int $decision): static
  435.     {
  436.         $this->decision = $decision;
  438.         return $this;
  439.     }
  441.     public function getDecisionName(): string
  442.     {
  443.         switch ($this->decision) {
  444.             case self::COMMUNICATION_ORALE:
  445.                 $dec = "Communication Orale";
  446.                 break;
  447.             case self::COMMUNICATION_ECRITE:
  448.                 $dec = "Communication Ecrite";
  449.                 break;
  450.             case self::POSTER_COMMENTE:
  451.                 $dec = "Poster Commenté";
  452.                 break;
  453.             case self::POSTER_ELECTRONIQUE:
  454.                 $dec = "Poster Electronique";
  455.                 break;
  456.             default:
  457.                 $dec = "";
  458.                 break;
  459.         }
  460.         return $dec;
  461.     }
  462. }