src/Entity/Course.php line 12

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\CourseRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use Symfony\Component\Serializer\Annotation\Groups;
  11. #[ORM\Entity(repositoryClass: CourseRepository::class)]
  12. class Course
  13. {
  14.     #[ORM\Id]
  15.     #[ORM\GeneratedValue]
  16.     #[ORM\Column(type: 'integer')]
  17.     private $id;
  19.     #[ORM\Column(type: 'string', length: 255)]
  20.     #[Groups(['LogService'])]
  21.     private $title;
  23.     #[ORM\Column(type: 'text', nullable: true)]
  24.     private $description;
  26.     #[ORM\Column(type: 'text', nullable: true)]
  27.     private $excerpt; 
  29.     #[ORM\Column(type: 'integer', nullable: true)]
  30.     private $duration;
  32.     #[ORM\Column(type: 'integer', nullable: true)]
  33.     private $dueDay;
  35.     #[ORM\Column(type: 'integer', nullable: true)]
  36.     #[Groups(['LogService'])]
  37.     private $minScore;
  39.     #[ORM\Column(type: 'boolean', nullable: true)]
  40.     private $randomizeOrder = false;
  42.     #[ORM\Column(type: 'boolean', nullable: true)]
  43.     private $randomizeQuestion;
  45.     #[ORM\Column(type: 'boolean', nullable: true)]
  46.     private $isOnboarding;
  48.     #[ORM\Column(type: 'boolean', nullable: true)]
  49.     private $needApproval;
  51.     // #[ORM\Column(type: 'boolean')]
  52.     // private $bypass = 1;
  54.     #[ORM\Column(type: 'integer', nullable: true)]
  55.     private $retryInterval = 0;
  57.     #[ORM\ManyToMany(targetEntity: Department::class, inversedBy: 'courses')]
  58.     private $departments;
  60.     #[ORM\ManyToMany(targetEntity: Office::class, inversedBy: 'courses')]
  61.     private $offices;
  63.     #[ORM\Column(type: 'text', nullable: true)]
  64.     #[Groups(['LogService'])]
  65.     private $type;
  67.     #[ORM\Column(type: 'boolean', nullable: true)]
  68.     private $isRequired;
  70.     #[ORM\Column(type: 'array', nullable: true)]
  71.     private $roles = [];
  73.     #[ORM\Column(type: 'integer', nullable: true)]
  74.     private $quizTimer;
  76.     #[ORM\OneToMany(targetEntity: CourseContent::class, mappedBy: 'course')]
  77.     private $courseContents;
  79.      #[ORM\Column(type: 'string', length: 16, nullable: true)]
  80.     private $level;
  82.     #[ORM\OneToMany(targetEntity: CourseAutoEnrollment::class, mappedBy: 'course')]
  83.     private $courseAutoEnrollments;
  85.     #[ORM\Column(type: 'datetime_immutable')]
  86.     private $createdAt;
  88.     #[ORM\ManyToOne(targetEntity: User::class)]
  89.     private $createdBy;
  91.     #[ORM\Column(type: 'datetime_immutable', nullable: true)]
  92.     #[Groups(['LogService'])]
  93.     private $updatedAt;
  95.     #[ORM\Column(type: 'datetime_immutable', nullable: true)]
  96.     private $deletedAt;
  98.     #[ORM\OneToMany(targetEntity: CourseQuizQuestion::class, mappedBy: 'course')]
  99.     private $courseQuizQuestions;
  101.     #[ORM\OneToMany(targetEntity: CourseUserEnrollment::class, mappedBy: 'course')]
  102.     private $courseUserEnrollments;
  104.     #[ORM\Column(type: 'boolean', options: ['default' => false])]
  105.     private $isPublished;
  107.     public function __construct()
  108.     {
  109.         $this->departments = new ArrayCollection();
  110.         $this->offices = new ArrayCollection();
  111.         $this->courseContents = new ArrayCollection();
  112.         $this->courseAutoEnrollments = new ArrayCollection();
  113.         $this->courseQuizQuestions = new ArrayCollection();
  114.         $this->courseUserEnrollments = new ArrayCollection();
  115.     }
  117.     public function getId(): ?int
  118.     {
  119.         return $this->id;
  120.     }
  122.     public function getTitle(): ?string
  123.     {
  124.         return $this->title;
  125.     }
  127.     public function setTitle(string $title): self
  128.     {
  129.         $this->title = $title;
  131.         return $this;
  132.     }
  134.     public function getDescription(): ?string
  135.     {
  136.         return $this->description;
  137.     }
  139.     public function setDescription(?string $description): self
  140.     {
  141.         $this->description = $description;
  143.         return $this;
  144.     }
  146.     public function getExcerpt(): ?string
  147.     {
  148.         return $this->excerpt;
  149.     }
  151.     public function setExcerpt(?string $excerpt): self
  152.     {
  153.         $this->excerpt = $excerpt;
  155.         return $this;
  156.     }
  158.     public function getDuration(): ?int
  159.     {
  160.         return $this->duration;
  161.     }
  163.     public function setDuration(?int $duration): self
  164.     {
  165.         $this->duration = $duration;
  167.         return $this;
  168.     }
  170.     public function getDueDay(): ?int
  171.     {
  172.         return $this->dueDay;
  173.     }
  175.     public function setDueDay(?int $dueDay): self
  176.     {
  177.         $this->dueDay = $dueDay;
  179.         return $this;
  180.     }
  182.     public function getMinScore(): ?int
  183.     {
  184.         return $this->minScore;
  185.     }
  187.     public function setMinScore(?int $minScore): self
  188.     {
  189.         $this->minScore = $minScore;
  191.         return $this;
  192.     }
  194.     public function getRandomizeOrder(): ?int
  195.     {
  196.         return $this->randomizeOrder;
  197.     }
  199.     public function setRandomizeOrder(?int $randomizeOrder): self
  200.     {
  201.         $this->randomizeOrder = $randomizeOrder;
  203.         return $this;
  204.     }
  206.     public function getRandomizeQuestion(): ?int
  207.     {
  208.         return $this->randomizeQuestion;
  209.     }
  211.     public function setRandomizeQuestion(?int $randomizeQuestion): self
  212.     {
  213.         $this->randomizeQuestion = $randomizeQuestion;
  215.         return $this;
  216.     }
  218.     public function getNeedApproval(): ?int
  219.     {
  220.         return $this->needApproval;
  221.     }
  223.     public function setNeedApproval(?int $needApproval): self
  224.     {
  225.         $this->needApproval = $needApproval;
  227.         return $this;
  228.     }
  230.    /* 
  231.     public function getBypass(): ?int
  232.     {
  233.         return $this->bypass;
  234.     }
  236.     public function setBypass(?int $bypass): self
  237.     {
  238.         $this->bypass = $bypass;
  240.         return $this;
  241.     }
  242.     */
  243.     
  245.     public function getIsOnboarding(): ?int
  246.     {
  247.         return $this->isOnboarding;
  248.     }
  250.     public function setIsOnboarding(?int $isOnboarding): self
  251.     {
  252.         $this->isOnboarding = $isOnboarding;
  254.         return $this;
  255.     }
  257.     public function getRetryInterval(): ?int
  258.     {
  259.         return $this->retryInterval;
  260.     }
  262.     public function setRetryInterval(?int $retryInterval): self
  263.     {
  264.         $this->retryInterval = $retryInterval;
  266.         return $this;
  267.     }
  269.     /**
  270.      * @return Collection|Department[]
  271.      */
  272.     public function getDepartments(): Collection
  273.     {
  274.         return $this->departments;
  275.     }
  277.     public function addDepartment(Department $department): self
  278.     {
  279.         if (!$this->departments->contains($department)) {
  280.             $this->departments[] = $department;
  281.         }
  283.         return $this;
  284.     }
  286.     public function removeDepartment(Department $department): self
  287.     {
  288.         $this->departments->removeElement($department);
  290.         return $this;
  291.     }
  293.     /**
  294.      * @return Collection|Office[]
  295.      */
  296.     public function getOffices(): Collection
  297.     {
  298.         return $this->offices;
  299.     }
  301.     public function addOffice(Office $office): self
  302.     {
  303.         if (!$this->offices->contains($office)) {
  304.             $this->offices[] = $office;
  305.         }
  307.         return $this;
  308.     }
  310.     public function removeOffice(Office $office): self
  311.     {
  312.         $this->offices->removeElement($office);
  314.         return $this;
  315.     }
  317.     public function getType(): ?string
  318.     {
  319.         return $this->type;
  320.     }
  322.     public function setType(?string $type): self
  323.     {
  324.         $this->type = $type;
  326.         return $this;
  327.     }
  329.     public function getIsRequired(): ?bool
  330.     {
  331.         return $this->isRequired;
  332.     }
  334.     public function setIsRequired(?bool $isRequired): self
  335.     {
  336.         $this->isRequired = $isRequired;
  338.         return $this;
  339.     }
  341.     public function getRoles(): ?array
  342.     {
  343.         return $this->roles;
  344.     }
  346.     public function setRoles(?array $roles): self
  347.     {
  348.         $this->roles = $roles;
  350.         return $this;
  351.     }
  353.     public function getQuizTimer(): ?int
  354.     {
  355.         return $this->quizTimer;
  356.     }
  358.     public function setQuizTimer(?int $quizTimer): self
  359.     {
  360.         $this->quizTimer = $quizTimer;
  362.         return $this;
  363.     }
  365.     /**
  366.      * @return Collection|CourseContent[]
  367.      */
  368.     public function getCourseContent(): Collection
  369.     {
  370.         return $this->courseContents;
  371.     }
  373.     
  374.     public function getLevel(): ?string
  375.     {
  376.         return $this->level;
  377.     }
  379.     public function setLevel(?string $level): self
  380.     {
  381.         $this->level = $level;
  383.         return $this;
  384.     }
  386.     public function addCreatedAt(CourseContent $courseContent): self
  387.     {
  388.         if (!$this->courseContents->contains($courseContent)) {
  389.             $this->courseContents[] = $courseContent;
  390.             $courseContent->setCourse($this);
  391.         }
  393.         return $this;
  394.     }
  396.     public function removeCreatedAt(CourseContent $courseContent): self
  397.     {
  398.         if ($this->courseContents->removeElement($courseContent)) {
  399.             // set the owning side to null (unless already changed)
  400.             if ($courseContent->getCourse() === $this) {
  401.                 $courseContent->setCourse(null);
  402.             }
  403.         }
  405.         return $this;
  406.     }
  408.     /**
  409.      * @return Collection|CourseAutoEnrollment[]
  410.      */
  411.     public function getCourseAutoEnrollments(): Collection
  412.     {
  413.         return $this->courseAutoEnrollments;
  414.     }
  416.     public function addCourseAutoEnrollment(CourseAutoEnrollment $CourseAutoEnrollment): self
  417.     {
  418.         if (!$this->courseAutoEnrollments->contains($CourseAutoEnrollment)) {
  419.             $this->courseAutoEnrollments[] = $CourseAutoEnrollment;
  420.             $CourseAutoEnrollment->setCourse($this);
  421.         }
  423.         return $this;
  424.     }
  426.     public function removeCourseAutoEnrollment(CourseAutoEnrollment $CourseAutoEnrollment): self
  427.     {
  428.         if ($this->courseAutoEnrollments->removeElement($CourseAutoEnrollment)) {
  429.             // set the owning side to null (unless already changed)
  430.             if ($CourseAutoEnrollment->getCourse() === $this) {
  431.                 $CourseAutoEnrollment->setCourse(null);
  432.             }
  433.         }
  435.         return $this;
  436.     }
  438.     /**
  439.      * Get the latest CourseAutoEnrollment associated with this Course entity.
  440.      *
  441.      * @return CourseAutoEnrollment|null The latest CourseAutoEnrollment or null if none exists.
  442.      */
  443.     public function getLatestAutoEnrollment(): ?CourseAutoEnrollment
  444.     {
  445.         $latestAutoEnrollment = null;
  447.         // Sort the course auto enrollments by createdAt in descending order
  448.         $sortedEnrollments = $this->getCourseAutoEnrollments()->toArray();
  449.         usort($sortedEnrollments, function (CourseAutoEnrollment $a, CourseAutoEnrollment $b) {
  450.             return $b->getCreatedAt() <=> $a->getCreatedAt();
  451.         });
  453.         // Get the first element from the sorted array (latest enrollment)
  454.         if (!empty($sortedEnrollments)) {
  455.             $latestAutoEnrollment = reset($sortedEnrollments);
  456.         }
  458.         return $latestAutoEnrollment;
  459.     }
  461.     public function getCreatedAt(): ?\DateTimeImmutable
  462.     {
  463.         return $this->createdAt;
  464.     }
  466.     public function setCreatedAt(\DateTimeImmutable $createdAt): self
  467.     {
  468.         $this->createdAt = $createdAt;
  470.         return $this;
  471.     }
  473.     public function getCreatedBy(): ?User
  474.     {
  475.         return $this->createdBy;
  476.     }
  478.     public function setCreatedBy(?User $createdBy): self
  479.     {
  480.         $this->createdBy = $createdBy;
  482.         return $this;
  483.     }
  485.     public function getUpdatedAt(): ?\DateTimeImmutable
  486.     {
  487.         return $this->updatedAt;
  488.     }
  490.     public function setUpdatedAt(?\DateTimeImmutable $updatedAt): self
  491.     {
  492.         $this->updatedAt = $updatedAt;
  494.         return $this;
  495.     }
  497.     public function getDeletedAt(): ?\DateTimeImmutable
  498.     {
  499.         return $this->deletedAt;
  500.     }
  502.     public function setDeletedAt(?\DateTimeImmutable $deletedAt): self
  503.     {
  504.         $this->deletedAt = $deletedAt;
  506.         return $this;
  507.     }
  509.     /**
  510.      * @return Collection|CourseQuizQuestion[]
  511.      */
  512.     public function getCourseQuizQuestions(): Collection
  513.     {
  514.         return $this->courseQuizQuestions;
  515.     }
  517.     public function addCourseQuizQuestion(CourseQuizQuestion $courseQuizQuestion): self
  518.     {
  519.         if (!$this->courseQuizQuestions->contains($courseQuizQuestion)) {
  520.             $this->courseQuizQuestions[] = $courseQuizQuestion;
  521.             $courseQuizQuestion->setCourse($this);
  522.         }
  524.         return $this;
  525.     }
  527.     public function removeCourseQuizQuestion(CourseQuizQuestion $courseQuizQuestion): self
  528.     {
  529.         if ($this->courseQuizQuestions->removeElement($courseQuizQuestion)) {
  530.             // set the owning side to null (unless already changed)
  531.             if ($courseQuizQuestion->getCourse() === $this) {
  532.                 $courseQuizQuestion->setCourse(null);
  533.             }
  534.         }
  536.         return $this;
  537.     }
  539.     /**
  540.      * @return Collection|CourseUserEnrollment[]
  541.      */
  542.     public function getCourseUserEnrollments(): Collection
  543.     {
  544.         // return $this->courseUserEnrollments;
  545.         return $this->courseUserEnrollments->filter(function (CourseUserEnrollment $enrollment) {
  546.             return !$enrollment->isDeleted();
  547.         });
  548.     }
  550.     public function addCourseUserEnrollment(CourseUserEnrollment $courseUserEnrollment): self
  551.     {
  552.         if (!$this->courseUserEnrollments->contains($courseUserEnrollment)) {
  553.             $this->courseUserEnrollments[] = $courseUserEnrollment;
  554.             $courseUserEnrollment->setCourse($this);
  555.         }
  557.         return $this;
  558.     }
  560.     public function removeCourseUserEnrollment(CourseUserEnrollment $courseUserEnrollment): self
  561.     {
  562.         if ($this->courseUserEnrollments->removeElement($courseUserEnrollment)) {
  563.             // set the owning side to null (unless already changed)
  564.             if ($courseUserEnrollment->getCourse() === $this) {
  565.                 $courseUserEnrollment->setCourse(null);
  566.             }
  567.         }
  569.         return $this;
  570.     }
  572.     public function getCourseReady(): bool
  573.     {
  575.         if ($this->getCourseContent()->isEmpty()) {
  576.             return false;
  577.         }
  579.         if ($this->getCourseQuizQuestions()->isEmpty()) {
  580.             return false;
  581.         }
  583.         return true;
  584.     }
  586.     public function getIsPublished(): ?int
  587.     {
  588.         return $this->isPublished;
  589.     }
  591.     public function setIsPublished(?int $isPublished): self
  592.     {
  593.         $this->isPublished = $isPublished;
  595.         return $this;
  596.     }
  598. }