src/Entity/Module.php line 16

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\ModuleRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use Gedmo\Mapping\Annotation as Gedmo;
  10. use JMS\Serializer\Annotation as Serializer;
  12. /**
  13.  * @ORM\Entity(repositoryClass=ModuleRepository::class)
  14.  * @Serializer\ExclusionPolicy("ALL")
  15.  */
  16. class Module extends BaseEntity
  17. {
  18.     /**
  19.      * @ORM\Id
  20.      * @ORM\GeneratedValue
  21.      * @ORM\Column(type="integer")
  22.      * @Serializer\Expose
  23.      * @Serializer\Groups({"participation"})
  24.      */
  25.     private $id;
  27.     /**
  28.      * @ORM\Column(type="string", length=255)
  29.      * @Serializer\Expose
  30.      * @Serializer\Groups({"historic", "participation", "live_details"})
  31.      */
  32.     private $name;
  34.     /**
  35.      * @ORM\Column(type="text", nullable=true)
  36.      * @Serializer\Expose
  37.      */
  38.     private $description;
  40.     /**
  41.      * @ORM\ManyToMany(targetEntity=Taxonomy::class, inversedBy="modules", cascade={"remove"})
  42.      */
  43.     private $taxonomies;
  45.     /**
  46.      * @ORM\Column(type="text", nullable=true)
  47.      * @Serializer\Expose
  48.      */
  49.     private $objective;
  51.     /**
  52.      * @ORM\OneToMany(targetEntity=LearningProgress::class, mappedBy="module", cascade={"remove"})
  53.      */
  54.     private $learningProgress;
  56.     /**
  57.      * @ORM\Column(type="string", length=255, nullable=true)
  58.      * @Serializer\Expose
  59.      */
  60.     private $label;
  62.     /**
  63.      * @ORM\Column(type="datetime", nullable=true)
  64.      * @Serializer\Expose
  65.      */
  66.     private $startAt;
  68.     /**
  69.      * @ORM\Column(type="datetime", nullable=true)
  70.      * @Serializer\Expose
  71.      * @Serializer\Groups({"historic"})
  72.      */
  73.     private $endAt;
  75.     /**
  76.      * @ORM\OneToMany(targetEntity=ModuleView::class, mappedBy="module", cascade={"persist"})
  77.      */
  78.     private $moduleViews;
  80.     /**
  81.      * @ORM\OneToMany(targetEntity=ModuleLike::class, mappedBy="module", cascade={"persist"})
  82.      */
  83.     private $moduleLikes;
  85.     /**
  86.      * @ORM\Column(type="datetime", nullable=true)
  87.      */
  88.     private $publishedAt;
  90.     /**
  91.      * @ORM\ManyToOne(targetEntity=User::class, inversedBy="modulePublishers")
  92.      * @ORM\JoinColumn(name="module_id", referencedColumnName="id", nullable=true, onDelete="SET NULL")
  93.      */
  94.     private $publishedBy;
  96.     /**
  97.      * @ORM\Column(type="boolean", nullable=true)
  98.      */
  99.     private $isPublished = false;
  101.     /**
  102.      * @ORM\OneToMany(targetEntity=SubsidiaryCompany::class, mappedBy="module", cascade={"persist"})
  103.      */
  104.     private $subsidiaryCompanies;
  106.     /**
  107.      * @ORM\OneToMany(targetEntity=Office::class, mappedBy="module", cascade={"persist"})
  108.      */
  109.     private $offices;
  111.     /**
  112.      * @ORM\OneToMany(targetEntity=Contract::class, mappedBy="module",cascade={"persist"})
  113.      */
  114.     private $contracts;
  116.     /**
  117.      * @ORM\Column(type="boolean", nullable=true)
  118.      */
  119.     private $isAllJobs = true;
  121.     /**
  122.      * @ORM\Column(type="boolean", nullable=true)
  123.      */
  124.     private $isAllOffices = true;
  126.     /**
  127.      * @ORM\Column(type="boolean", nullable=true)
  128.      */
  129.     private $isAllContracts = true;
  131.     /**
  132.      * @ORM\Column(type="boolean", nullable=true)
  133.      */
  134.     private $isAllSubsidiaryCompanies = true;
  136.     /**
  137.      * @Gedmo\Slug(fields={"name"})
  138.      * @ORM\Column(length=191)
  139.      */
  140.     private $slug;
  142.     /**
  143.      * @ORM\OneToOne(targetEntity=ImageManager::class, cascade={"persist", "remove"})
  144.      * @Serializer\Expose
  145.      */
  146.     private $cover;
  148.     /**
  149.      * @ORM\OneToMany(targetEntity=ModuleItem::class, mappedBy="module", orphanRemoval="true", cascade={"persist"})
  150.      */
  151.     private $moduleItems;
  153.     /**
  154.      * @ORM\OneToMany(targetEntity=ModuleParticipation::class, mappedBy="module", cascade={"persist"})
  155.      */
  156.     private $moduleParticipations;
  158.     /**
  159.      * @ORM\Column(type="boolean", nullable=true)
  160.      */
  161.     private $isPublic;
  163.     /**
  164.      * @ORM\ManyToMany(targetEntity=User::class, inversedBy="modules")
  165.      * @ORM\JoinColumn(onDelete="CASCADE")
  166.      * @Serializer\Expose
  167.      */
  168.     private $coaches;
  170.     /**
  171.      * @ORM\OneToMany(targetEntity=ModuleComment::class, mappedBy="module")
  172.      */
  173.     private $moduleComments;
  175.     /**
  176.      * @ORM\OneToMany(targetEntity=ModuleNotice::class, mappedBy="module")
  177.      */
  178.     private $moduleNotices;
  180.     /**
  181.      * @ORM\OneToMany(targetEntity=Subject::class, mappedBy="module")
  182.      */
  183.     private $subjects;
  185.     /**
  186.      * @ORM\ManyToMany(targetEntity=Program::class, mappedBy="modules", cascade={"remove"})
  187.      */
  188.     private $programs;
  190.     /**
  191.      * @ORM\OneToMany(targetEntity=ModuleInscription::class, mappedBy="module")
  192.      */
  193.     private $moduleInscriptions;
  195.     /**
  196.      * @ORM\OneToMany(targetEntity=UserModuleParticipation::class, mappedBy="module")
  197.      */
  198.     private $userModuleParticipations;
  200.     /**
  201.      * @ORM\ManyToMany(targetEntity=Course::class, mappedBy="modules")
  202.      */
  203.     private $courses;
  205.     /**
  206.      * @ORM\ManyToMany(targetEntity=Live::class, mappedBy="modules")
  207.      */
  208.     private $lives;
  210.     /**
  211.      * @ORM\ManyToMany(targetEntity=Quiz::class, mappedBy="modules")
  212.      */
  213.     private $quiz;
  215.     /**
  216.      * @ORM\Column(type="boolean", nullable=true)
  217.      */
  218.     private $isMadeVisible;
  220.     /**
  221.      * @ORM\OneToMany(targetEntity=UserQuizQuestion::class, mappedBy="module")
  222.      */
  223.     private $userQuizQuestions;
  225.     /**
  226.      * @ORM\ManyToOne(targetEntity=Partenaire::class)
  227.      */
  228.     private $partenaire;
  230.     /**
  231.      * @ORM\Column(type="boolean", nullable=true)
  232.      */
  233.     private $isAuthoredByCofina;
  235.     /**
  236.      * @ORM\OneToMany(targetEntity=Notification::class, mappedBy="module")
  237.      */
  238.     private $notifications;
  240.     /**
  241.      * @ORM\ManyToMany(targetEntity=Job::class, inversedBy="modules")
  242.      */
  243.     private $jobs;
  245.     /**
  246.      * @ORM\OneToMany(targetEntity=ModuleObjective::class, mappedBy="module", cascade={"persist"})
  247.      */
  248.     private $moduleObjectives;
  250.     public function __construct()
  251.     {
  252.         $this->taxonomies = new ArrayCollection();
  253.         $this->learningProgress = new ArrayCollection();
  254.         $this->moduleViews = new ArrayCollection();
  255.         $this->moduleLikes = new ArrayCollection();
  256.         $this->subsidiaryCompanies = new ArrayCollection();
  257.         $this->offices = new ArrayCollection();
  258.         $this->contracts = new ArrayCollection();
  259.         $this->moduleItems = new ArrayCollection();
  260.         $this->moduleParticipations = new ArrayCollection();
  261.         $this->coaches = new ArrayCollection();
  262.         $this->moduleComments = new ArrayCollection();
  263.         $this->moduleNotices = new ArrayCollection();
  264.         $this->subjects = new ArrayCollection();
  265.         $this->programs = new ArrayCollection();
  266.         $this->moduleInscriptions = new ArrayCollection();
  267.         $this->userModuleParticipations = new ArrayCollection();
  268.         $this->courses = new ArrayCollection();
  269.         $this->lives = new ArrayCollection();
  270.         $this->quiz = new ArrayCollection();
  271.         $this->userQuizQuestions = new ArrayCollection();
  272.         $this->notifications = new ArrayCollection();
  273.         $this->jobs = new ArrayCollection();
  274.         $this->moduleObjectives = new ArrayCollection();
  275.     }
  277.     public function getId(): ?int
  278.     {
  279.         return $this->id;
  280.     }
  282.     public function getName(): ?string
  283.     {
  284.         return $this->name;
  285.     }
  287.     public function setName(string $name): self
  288.     {
  289.         $this->name = $name;
  291.         return $this;
  292.     }
  294.     public function getDescription(): ?string
  295.     {
  296.         return $this->description;
  297.     }
  299.     public function setDescription(?string $description): self
  300.     {
  301.         $this->description = $description;
  303.         return $this;
  304.     }
  306.     /**
  307.      * @return Collection<int, Taxonomy>
  308.      */
  309.     public function getTaxonomies(): Collection
  310.     {
  311.         return $this->taxonomies;
  312.     }
  314.     public function addTaxonomy(Taxonomy $taxonomy): self
  315.     {
  316.         if (!$this->taxonomies->contains($taxonomy)) {
  317.             $this->taxonomies[] = $taxonomy;
  318.         }
  320.         return $this;
  321.     }
  323.     public function removeTaxonomy(Taxonomy $taxonomy): self
  324.     {
  325.         $this->taxonomies->removeElement($taxonomy);
  327.         return $this;
  328.     }
  330.     public function getObjective(): ?string
  331.     {
  332.         return $this->objective;
  333.     }
  335.     public function setObjective(?string $objective): self
  336.     {
  337.         $this->objective = $objective;
  339.         return $this;
  340.     }
  342.     /**
  343.      * @return Collection<int, LearningProgress>
  344.      */
  345.     public function getLearningProgress(): Collection
  346.     {
  347.         return $this->learningProgress;
  348.     }
  350.     public function addLearningProgress(LearningProgress $learningProgress): self
  351.     {
  352.         if (!$this->learningProgress->contains($learningProgress)) {
  353.             $this->learningProgress[] = $learningProgress;
  354.             $learningProgress->setModule($this);
  355.         }
  357.         return $this;
  358.     }
  360.     public function removeLearningProgress(LearningProgress $learningProgress): self
  361.     {
  362.         if ($this->learningProgress->removeElement($learningProgress)) {
  363.             // set the owning side to null (unless already changed)
  364.             if ($learningProgress->getModule() === $this) {
  365.                 $learningProgress->setModule(null);
  366.             }
  367.         }
  369.         return $this;
  370.     }
  372.     public function getLabel(): ?string
  373.     {
  374.         return $this->label;
  375.     }
  377.     public function setLabel(?string $label): self
  378.     {
  379.         $this->label = $label;
  381.         return $this;
  382.     }
  384.     public function getStartAt(): ?\DateTimeInterface
  385.     {
  386.         return $this->startAt;
  387.     }
  389.     public function setStartAt(?\DateTimeInterface $startAt): self
  390.     {
  391.         $this->startAt = $startAt;
  393.         return $this;
  394.     }
  396.     public function getEndAt(): ?\DateTimeInterface
  397.     {
  398.         return $this->endAt;
  399.     }
  401.     public function setEndAt(?\DateTimeInterface $endAt): self
  402.     {
  403.         $this->endAt = $endAt;
  405.         return $this;
  406.     }
  408.     /**
  409.      * @return Collection<int, ModuleView>
  410.      */
  411.     public function getModuleViews(): Collection
  412.     {
  413.         return $this->moduleViews;
  414.     }
  416.     public function addModuleView(ModuleView $moduleView): self
  417.     {
  418.         if (!$this->moduleViews->contains($moduleView)) {
  419.             $this->moduleViews[] = $moduleView;
  420.             $moduleView->setModule($this);
  421.         }
  423.         return $this;
  424.     }
  426.     public function removeModuleView(ModuleView $moduleView): self
  427.     {
  428.         if ($this->moduleViews->removeElement($moduleView)) {
  429.             // set the owning side to null (unless already changed)
  430.             if ($moduleView->getModule() === $this) {
  431.                 $moduleView->setModule(null);
  432.             }
  433.         }
  435.         return $this;
  436.     }
  438.     /**
  439.      * @return Collection<int, ModuleLike>
  440.      */
  441.     public function getModuleLikes(): Collection
  442.     {
  443.         return $this->moduleLikes;
  444.     }
  446.     public function addModuleLike(ModuleLike $moduleLike): self
  447.     {
  448.         if (!$this->moduleLikes->contains($moduleLike)) {
  449.             $this->moduleLikes[] = $moduleLike;
  450.             $moduleLike->setModule($this);
  451.         }
  453.         return $this;
  454.     }
  456.     public function removeModuleLike(ModuleLike $moduleLike): self
  457.     {
  458.         if ($this->moduleLikes->removeElement($moduleLike)) {
  459.             // set the owning side to null (unless already changed)
  460.             if ($moduleLike->getModule() === $this) {
  461.                 $moduleLike->setModule(null);
  462.             }
  463.         }
  465.         return $this;
  466.     }
  468.     public function getPublishedAt(): ?\DateTimeInterface
  469.     {
  470.         return $this->publishedAt;
  471.     }
  473.     public function setPublishedAt(?\DateTimeInterface $publishedAt): self
  474.     {
  475.         $this->publishedAt = $publishedAt;
  477.         return $this;
  478.     }
  480.     public function getPublishedBy(): ?User
  481.     {
  482.         return $this->publishedBy;
  483.     }
  485.     public function setPublishedBy(?User $publishedBy): self
  486.     {
  487.         $this->publishedBy = $publishedBy;
  489.         return $this;
  490.     }
  492.     public function isIsPublished(): ?bool
  493.     {
  494.         return $this->isPublished;
  495.     }
  497.     public function setIsPublished(?bool $isPublished): self
  498.     {
  499.         $this->isPublished = $isPublished;
  501.         return $this;
  502.     }
  504.     /**
  505.      * @return Collection<int, SubsidiaryCompany>
  506.      */
  507.     public function getSubsidiaryCompanies(): Collection
  508.     {
  509.         return $this->subsidiaryCompanies;
  510.     }
  512.     public function addSubsidiaryCompany(SubsidiaryCompany $subsidiaryCompany): self
  513.     {
  514.         if (!$this->subsidiaryCompanies->contains($subsidiaryCompany)) {
  515.             $this->subsidiaryCompanies[] = $subsidiaryCompany;
  516.             $subsidiaryCompany->setModule($this);
  517.         }
  519.         return $this;
  520.     }
  522.     public function removeSubsidiaryCompany(SubsidiaryCompany $subsidiaryCompany): self
  523.     {
  524.         if ($this->subsidiaryCompanies->removeElement($subsidiaryCompany)) {
  525.             // set the owning side to null (unless already changed)
  526.             if ($subsidiaryCompany->getModule() === $this) {
  527.                 $subsidiaryCompany->setModule(null);
  528.             }
  529.         }
  531.         return $this;
  532.     }
  534.     /**
  535.      * @return Collection<int, Office>
  536.      */
  537.     public function getOffices(): Collection
  538.     {
  539.         return $this->offices;
  540.     }
  542.     public function addOffice(Office $office): self
  543.     {
  544.         if (!$this->offices->contains($office)) {
  545.             $this->offices[] = $office;
  546.             $office->setModule($this);
  547.         }
  549.         return $this;
  550.     }
  552.     public function removeOffice(Office $office): self
  553.     {
  554.         if ($this->offices->removeElement($office)) {
  555.             // set the owning side to null (unless already changed)
  556.             if ($office->getModule() === $this) {
  557.                 $office->setModule(null);
  558.             }
  559.         }
  561.         return $this;
  562.     }
  564.     /**
  565.      * @return Collection<int, Contract>
  566.      */
  567.     public function getContracts(): Collection
  568.     {
  569.         return $this->contracts;
  570.     }
  572.     public function addContract(Contract $contract): self
  573.     {
  574.         if (!$this->contracts->contains($contract)) {
  575.             $this->contracts[] = $contract;
  576.             $contract->setModule($this);
  577.         }
  579.         return $this;
  580.     }
  582.     public function removeContract(Contract $contract): self
  583.     {
  584.         if ($this->contracts->removeElement($contract)) {
  585.             // set the owning side to null (unless already changed)
  586.             if ($contract->getModule() === $this) {
  587.                 $contract->setModule(null);
  588.             }
  589.         }
  591.         return $this;
  592.     }
  594.     public function isIsAllJobs(): ?bool
  595.     {
  596.         return $this->isAllJobs;
  597.     }
  599.     public function setIsAllJobs(?bool $isAllJobs): self
  600.     {
  601.         $this->isAllJobs = $isAllJobs;
  603.         return $this;
  604.     }
  606.     public function isIsAllOffices(): ?bool
  607.     {
  608.         return $this->isAllOffices;
  609.     }
  611.     public function setIsAllOffices(?bool $isAllOffices): self
  612.     {
  613.         $this->isAllOffices = $isAllOffices;
  615.         return $this;
  616.     }
  618.     public function isIsAllContracts(): ?bool
  619.     {
  620.         return $this->isAllContracts;
  621.     }
  623.     public function setIsAllContracts(?bool $isAllContracts): self
  624.     {
  625.         $this->isAllContracts = $isAllContracts;
  627.         return $this;
  628.     }
  630.     public function isIsAllSubsidiaryCompanies(): ?bool
  631.     {
  632.         return $this->isAllSubsidiaryCompanies;
  633.     }
  635.     public function setIsAllSubsidiaryCompanies(?bool $isAllSubsidiaryCompanies): self
  636.     {
  637.         $this->isAllSubsidiaryCompanies = $isAllSubsidiaryCompanies;
  639.         return $this;
  640.     }
  642.     /**
  643.      * Get the value of slug
  644.      */ 
  645.     public function getSlug()
  646.     {
  647.         return $this->slug;
  648.     }
  650.     /**
  651.      * Set the value of slug
  652.      *
  653.      * @return  self
  654.      */ 
  655.     public function setSlug($slug)
  656.     {
  657.         $this->slug = $slug;
  659.         return $this;
  660.     }
  662.     public function getCover(): ?ImageManager
  663.     {
  664.         return $this->cover;
  665.     }
  667.     public function setCover(?ImageManager $cover): self
  668.     {
  669.         $this->cover = $cover;
  671.         return $this;
  672.     }
  674.     /**
  675.      * @return Collection<int, ModuleItem>
  676.      */
  677.     public function getModuleItems(): Collection
  678.     {
  679.         return $this->moduleItems;
  680.     }
  682.     public function addModuleItem(ModuleItem $moduleItem): self
  683.     {
  684.         if (!$this->moduleItems->contains($moduleItem)) {
  685.             $this->moduleItems[] = $moduleItem;
  686.             $moduleItem->setModule($this);
  687.         }
  689.         return $this;
  690.     }
  692.     public function removeModuleItem(ModuleItem $moduleItem): self
  693.     {
  694.         if ($this->moduleItems->removeElement($moduleItem)) {
  695.             // set the owning side to null (unless already changed)
  696.             if ($moduleItem->getModule() === $this) {
  697.                 $moduleItem->setModule(null);
  698.             }
  699.         }
  701.         return $this;
  702.     }
  704.     /**
  705.      * @return Collection<int, ModuleParticipation>
  706.      */
  707.     public function getModuleParticipations(): Collection
  708.     {
  709.         return $this->moduleParticipations;
  710.     }
  712.     public function addModuleParticipation(ModuleParticipation $moduleParticipation): self
  713.     {
  714.         if (!$this->moduleParticipations->contains($moduleParticipation)) {
  715.             $this->moduleParticipations[] = $moduleParticipation;
  716.             $moduleParticipation->setModule($this);
  717.         }
  719.         return $this;
  720.     }
  722.     public function removeModuleParticipation(ModuleParticipation $moduleParticipation): self
  723.     {
  724.         if ($this->moduleParticipations->removeElement($moduleParticipation)) {
  725.             // set the owning side to null (unless already changed)
  726.             if ($moduleParticipation->getModule() === $this) {
  727.                 $moduleParticipation->setModule(null);
  728.             }
  729.         }
  731.         return $this;
  732.     }
  734.     public function isIsPublic(): ?bool
  735.     {
  736.         return $this->isPublic;
  737.     }
  739.     public function setIsPublic(?bool $isPublic): self
  740.     {
  741.         $this->isPublic = $isPublic;
  743.         return $this;
  744.     }
  746.     /**
  747.      * @return Collection<int, User>
  748.      */
  749.     public function getCoaches(): Collection
  750.     {
  751.         return $this->coaches;
  752.     }
  754.     public function addCoach(User $coach): self
  755.     {
  756.         if (!$this->coaches->contains($coach)) {
  757.             $this->coaches[] = $coach;
  758.         }
  760.         return $this;
  761.     }
  763.     public function removeCoach(User $coach): self
  764.     {
  765.         $this->coaches->removeElement($coach);
  767.         return $this;
  768.     }
  770.     /**
  771.      * @return Collection<int, ModuleComment>
  772.      */
  773.     public function getModuleComments(): Collection
  774.     {
  775.         return $this->moduleComments;
  776.     }
  778.     public function addModuleComment(ModuleComment $moduleComment): self
  779.     {
  780.         if (!$this->moduleComments->contains($moduleComment)) {
  781.             $this->moduleComments[] = $moduleComment;
  782.             $moduleComment->setModule($this);
  783.         }
  785.         return $this;
  786.     }
  788.     public function removeModuleComment(ModuleComment $moduleComment): self
  789.     {
  790.         if ($this->moduleComments->removeElement($moduleComment)) {
  791.             // set the owning side to null (unless already changed)
  792.             if ($moduleComment->getModule() === $this) {
  793.                 $moduleComment->setModule(null);
  794.             }
  795.         }
  797.         return $this;
  798.     }
  800.     /**
  801.      * @return Collection<int, ModuleNotice>
  802.      */
  803.     public function getModuleNotices(): Collection
  804.     {
  805.         return $this->moduleNotices;
  806.     }
  808.     public function addModuleNotice(ModuleNotice $moduleNotice): self
  809.     {
  810.         if (!$this->moduleNotices->contains($moduleNotice)) {
  811.             $this->moduleNotices[] = $moduleNotice;
  812.             $moduleNotice->setModule($this);
  813.         }
  815.         return $this;
  816.     }
  818.     public function removeModuleNotice(ModuleNotice $moduleNotice): self
  819.     {
  820.         if ($this->moduleNotices->removeElement($moduleNotice)) {
  821.             // set the owning side to null (unless already changed)
  822.             if ($moduleNotice->getModule() === $this) {
  823.                 $moduleNotice->setModule(null);
  824.             }
  825.         }
  827.         return $this;
  828.     }
  830.     /**
  831.      * @return Collection<int, Subject>
  832.      */
  833.     public function getSubjects(): Collection
  834.     {
  835.         return $this->subjects;
  836.     }
  838.     public function addSubject(Subject $subject): self
  839.     {
  840.         if (!$this->subjects->contains($subject)) {
  841.             $this->subjects[] = $subject;
  842.             $subject->setModule($this);
  843.         }
  845.         return $this;
  846.     }
  848.     public function removeSubject(Subject $subject): self
  849.     {
  850.         if ($this->subjects->removeElement($subject)) {
  851.             // set the owning side to null (unless already changed)
  852.             if ($subject->getModule() === $this) {
  853.                 $subject->setModule(null);
  854.             }
  855.         }
  857.         return $this;
  858.     }
  860.     /**
  861.      * @return Collection<int, Program>
  862.      */
  863.     public function getPrograms(): Collection
  864.     {
  865.         return $this->programs;
  866.     }
  868.     public function addProgram(Program $program): self
  869.     {
  870.         if (!$this->programs->contains($program)) {
  871.             $this->programs[] = $program;
  872.             $program->addModule($this);
  873.         }
  875.         return $this;
  876.     }
  878.     public function removeProgram(Program $program): self
  879.     {
  880.         if ($this->programs->removeElement($program)) {
  881.             $program->removeModule($this);
  882.         }
  884.         return $this;
  885.     }
  887.     /**
  888.      * @return Collection<int, ModuleInscription>
  889.      */
  890.     public function getModuleInscriptions(): Collection
  891.     {
  892.         return $this->moduleInscriptions;
  893.     }
  895.     public function addModuleInscription(ModuleInscription $moduleInscription): self
  896.     {
  897.         if (!$this->moduleInscriptions->contains($moduleInscription)) {
  898.             $this->moduleInscriptions[] = $moduleInscription;
  899.             $moduleInscription->setModule($this);
  900.         }
  902.         return $this;
  903.     }
  905.     public function removeModuleInscription(ModuleInscription $moduleInscription): self
  906.     {
  907.         if ($this->moduleInscriptions->removeElement($moduleInscription)) {
  908.             // set the owning side to null (unless already changed)
  909.             if ($moduleInscription->getModule() === $this) {
  910.                 $moduleInscription->setModule(null);
  911.             }
  912.         }
  914.         return $this;
  915.     }
  917.     /**
  918.      * @return Collection<int, UserModuleParticipation>
  919.      */
  920.     public function getUserModuleParticipations(): Collection
  921.     {
  922.         return $this->userModuleParticipations;
  923.     }
  925.     public function addUserModuleParticipation(UserModuleParticipation $userModuleParticipation): self
  926.     {
  927.         if (!$this->userModuleParticipations->contains($userModuleParticipation)) {
  928.             $this->userModuleParticipations[] = $userModuleParticipation;
  929.             $userModuleParticipation->setModule($this);
  930.         }
  932.         return $this;
  933.     }
  935.     public function removeUserModuleParticipation(UserModuleParticipation $userModuleParticipation): self
  936.     {
  937.         if ($this->userModuleParticipations->removeElement($userModuleParticipation)) {
  938.             // set the owning side to null (unless already changed)
  939.             if ($userModuleParticipation->getModule() === $this) {
  940.                 $userModuleParticipation->setModule(null);
  941.             }
  942.         }
  944.         return $this;
  945.     }
  947.     /**
  948.      * @return Collection<int, Course>
  949.      */
  950.     public function getCourses(): Collection
  951.     {
  952.         return $this->courses;
  953.     }
  955.     public function addCourse(Course $course): self
  956.     {
  957.         if (!$this->courses->contains($course)) {
  958.             $this->courses[] = $course;
  959.             $course->addModule($this);
  960.         }
  962.         return $this;
  963.     }
  965.     public function removeCourse(Course $course): self
  966.     {
  967.         if ($this->courses->removeElement($course)) {
  968.             $course->removeModule($this);
  969.         }
  971.         return $this;
  972.     }
  974.     /**
  975.      * @return Collection<int, Live>
  976.      */
  977.     public function getLives(): Collection
  978.     {
  979.         return $this->lives;
  980.     }
  982.     public function addLife(Live $life): self
  983.     {
  984.         if (!$this->lives->contains($life)) {
  985.             $this->lives[] = $life;
  986.             $life->addModule($this);
  987.         }
  989.         return $this;
  990.     }
  992.     public function removeLife(Live $life): self
  993.     {
  994.         if ($this->lives->removeElement($life)) {
  995.             $life->removeModule($this);
  996.         }
  998.         return $this;
  999.     }
  1001.     /**
  1002.      * @return Collection<int, Quiz>
  1003.      */
  1004.     public function getQuiz(): Collection
  1005.     {
  1006.         return $this->quiz;
  1007.     }
  1009.     public function addQuiz(Quiz $quiz): self
  1010.     {
  1011.         if (!$this->quiz->contains($quiz)) {
  1012.             $this->quiz[] = $quiz;
  1013.             $quiz->addModule($this);
  1014.         }
  1016.         return $this;
  1017.     }
  1019.     public function removeQuiz(Quiz $quiz): self
  1020.     {
  1021.         if ($this->quiz->removeElement($quiz)) {
  1022.             $quiz->removeModule($this);
  1023.         }
  1025.         return $this;
  1026.     }
  1028.     public function isIsMadeVisible(): ?bool
  1029.     {
  1030.         return $this->isMadeVisible;
  1031.     }
  1033.     public function setIsMadeVisible(?bool $isMadeVisible): self
  1034.     {
  1035.         $this->isMadeVisible = $isMadeVisible;
  1037.         return $this;
  1038.     }
  1040.     /**
  1041.      * @return Collection<int, UserQuizQuestion>
  1042.      */
  1043.     public function getUserQuizQuestions(): Collection
  1044.     {
  1045.         return $this->userQuizQuestions;
  1046.     }
  1048.     public function addUserQuizQuestion(UserQuizQuestion $userQuizQuestion): self
  1049.     {
  1050.         if (!$this->userQuizQuestions->contains($userQuizQuestion)) {
  1051.             $this->userQuizQuestions[] = $userQuizQuestion;
  1052.             $userQuizQuestion->setModule($this);
  1053.         }
  1055.         return $this;
  1056.     }
  1058.     public function removeUserQuizQuestion(UserQuizQuestion $userQuizQuestion): self
  1059.     {
  1060.         if ($this->userQuizQuestions->removeElement($userQuizQuestion)) {
  1061.             // set the owning side to null (unless already changed)
  1062.             if ($userQuizQuestion->getModule() === $this) {
  1063.                 $userQuizQuestion->setModule(null);
  1064.             }
  1065.         }
  1067.         return $this;
  1068.     }
  1070.     public function getPartenaire(): ?Partenaire
  1071.     {
  1072.         return $this->partenaire;
  1073.     }
  1075.     public function setPartenaire(?Partenaire $partenaire): self
  1076.     {
  1077.         $this->partenaire = $partenaire;
  1079.         return $this;
  1080.     }
  1082.     public function isIsAuthoredByCofina(): ?bool
  1083.     {
  1084.         return $this->isAuthoredByCofina;
  1085.     }
  1087.     public function setIsAuthoredByCofina(?bool $isAuthoredByCofina): self
  1088.     {
  1089.         $this->isAuthoredByCofina = $isAuthoredByCofina;
  1091.         return $this;
  1092.     }
  1094.     /**
  1095.      * @return Collection<int, Notification>
  1096.      */
  1097.     public function getNotifications(): Collection
  1098.     {
  1099.         return $this->notifications;
  1100.     }
  1102.     public function addNotification(Notification $notification): self
  1103.     {
  1104.         if (!$this->notifications->contains($notification)) {
  1105.             $this->notifications[] = $notification;
  1106.             $notification->setModule($this);
  1107.         }
  1109.         return $this;
  1110.     }
  1112.     public function removeNotification(Notification $notification): self
  1113.     {
  1114.         if ($this->notifications->removeElement($notification)) {
  1115.             // set the owning side to null (unless already changed)
  1116.             if ($notification->getModule() === $this) {
  1117.                 $notification->setModule(null);
  1118.             }
  1119.         }
  1121.         return $this;
  1122.     }
  1124.     /**
  1125.      * @return Collection<int, Job>
  1126.      */
  1127.     public function getJobs(): Collection
  1128.     {
  1129.         return $this->jobs;
  1130.     }
  1132.     public function addJob(Job $job): self
  1133.     {
  1134.         if (!$this->jobs->contains($job)) {
  1135.             $this->jobs[] = $job;
  1136.         }
  1138.         return $this;
  1139.     }
  1141.     public function removeJob(Job $job): self
  1142.     {
  1143.         $this->jobs->removeElement($job);
  1145.         return $this;
  1146.     }
  1148.     /**
  1149.      * @return Collection<int, ModuleObjectives>
  1150.      */
  1151.     public function getModuleObjectives(): Collection
  1152.     {
  1153.         return $this->moduleObjectives;
  1154.     }
  1156.     public function addModuleObjective(ModuleObjective $moduleObjective): self
  1157.     {
  1158.         if (!$this->moduleObjectives->contains($moduleObjective)) {
  1159.             $this->moduleObjectives[] = $moduleObjective;
  1160.             $moduleObjective->setModule($this);
  1161.         }
  1163.         return $this;
  1164.     }
  1166.     public function removeModuleObjective(ModuleObjective $moduleObjective): self
  1167.     {
  1168.         if ($this->moduleObjectives->removeElement($moduleObjective)) {
  1169.             // set the owning side to null (unless already changed)
  1170.             if ($moduleObjective->getModule() === $this) {
  1171.                 $moduleObjective->setModule(null);
  1172.             }
  1173.         }
  1175.         return $this;
  1176.     }
  1177. }