src/Entity/Exam.php line 565

Open in your IDE?
  1. <?php
  2. namespace EADPlataforma\Entity;
  3. use Doctrine\ORM\Mapping as ORM;
  4. use Doctrine\Common\Collections\Collection;
  5. use Symfony\Component\Validator\Constraints as Assert;
  6. use EADPlataforma\Validator\Constraints as EADAssert;
  7. use EADPlataforma\Enum\ExamEnum;
  8. use EADPlataforma\Enum\QuestionEnum;
  9. use EADPlataforma\Util\StringUtil;
  10. use \DateTime;
  11. /**
  12.  * Exam
  13.  *
  14.  * @ORM\Table(name="exam", indexes={
  15.  *      @ORM\Index(name="fk_exam_lesson_id", columns={"lesson_id"}), 
  16.  *      @ORM\Index(name="fk_exam_lesson_module_id", columns={"lesson_module_id"}), 
  17.  *      @ORM\Index(name="fk_exam_course_id", columns={"course_id"}),
  18.  *      @ORM\Index(name="fk_exam_user_delete_id", columns={"user_delete_id"})
  19.  * })
  20.  *
  21.  * @ORM\Entity(repositoryClass="EADPlataforma\Repository\ExamRepository")
  22.  */
  23. class Exam
  24. {
  25.     /**
  26.      * @var int
  27.      *
  28.      * @ORM\Column(name="id", type="integer", nullable=false)
  29.      * @ORM\Id
  30.      * @ORM\GeneratedValue(strategy="IDENTITY")
  31.      */
  32.     private $id;
  33.     /**
  34.      * @Assert\NotBlank(
  35.      *      message = "Deleted not informed"
  36.      * )
  37.      *
  38.      * @Assert\Choice(
  39.      *      choices = { 
  40.      *                      ExamEnum::ITEM_NO_DELETED, 
  41.      *                      ExamEnum::ITEM_ON_TRASH,
  42.      *                      ExamEnum::ITEM_DELETED
  43.      *                },
  44.      *      message = "Delete Option Invalid"
  45.      * )
  46.      *
  47.      * @var int
  48.      *
  49.      * @ORM\Column(name="deleted", type="integer", nullable=false, options={"default"="0"})
  50.      */
  51.     private $deleted ExamEnum::ITEM_NO_DELETED;
  52.     /**
  53.      * @Assert\Length(
  54.      *      min = 0,
  55.      *      max = 120
  56.      * )
  57.      *
  58.      * @var string|null
  59.      *
  60.      * @ORM\Column(name="title", type="string", length=125, nullable=true)
  61.      */
  62.     private $title;
  63.     /**
  64.      * @Assert\NotBlank(
  65.      *    message = "Type not informed"
  66.      * )
  67.      *
  68.      * @Assert\Choice(
  69.      *      choices = { ExamEnum::COURSE, ExamEnum::MODULE, ExamEnum::LESSON, ExamEnum::QUIZ },
  70.      *      message = "Type Invalid"
  71.      * )
  72.      *
  73.      * @var int
  74.      *
  75.      * @ORM\Column(name="type", type="integer", nullable=false, options={"default"="1"})
  76.      */
  77.     private $type ExamEnum::COURSE;
  78.     /**
  79.      * @Assert\NotBlank(
  80.      *    message = "Status not informed"
  81.      * )
  82.      *
  83.      * @Assert\Choice(
  84.      *      choices = { ExamEnum::DRAFT, ExamEnum::PUBLISHED },
  85.      *      message = "Status Invalid"
  86.      * )
  87.      *
  88.      * @var int
  89.      *
  90.      * @ORM\Column(name="status", type="integer", nullable=false, options={"default"="0"})
  91.      */
  92.     private $status ExamEnum::DRAFT;
  93.     /**
  94.      * @Assert\NotBlank(
  95.      *    message = "Requirement not informed"
  96.      * )
  97.      *
  98.      * @Assert\Choice(
  99.      *      choices = { ExamEnum::NO, ExamEnum::YES },
  100.      *      message = "Requirement Invalid"
  101.      * )
  102.      *
  103.      * @var int
  104.      *
  105.      * @ORM\Column(name="requirement", type="integer", nullable=false, options={"default"="0"})
  106.      */
  107.     private $requirement ExamEnum::NO;
  108.     /**
  109.      * @Assert\NotBlank(
  110.      *    message = "Question order not informed"
  111.      * )
  112.      *
  113.      * @Assert\Choice(
  114.      *      choices = { ExamEnum::SEQUENTIAL, ExamEnum::RANDOM },
  115.      *      message = "Question order Invalid"
  116.      * )
  117.      *
  118.      * @var int
  119.      *
  120.      * @ORM\Column(name="question_order", type="integer", nullable=false, options={"default"="0"})
  121.      */
  122.     private $questionOrder ExamEnum::SEQUENTIAL;
  123.     /**
  124.      * @Assert\NotBlank(
  125.      *    message = "Question number not informed"
  126.      * )
  127.      *
  128.      * @Assert\GreaterThan(
  129.      *      value   = 0,
  130.      *      message = "Question number not informed"
  131.      * )
  132.      *
  133.      * @Assert\EqualTo(
  134.      *      value   = 1,
  135.      *      groups  = "lessQuestion",
  136.      *      message = "The number of questions is less than the number informed!"
  137.      * )
  138.      *
  139.      * @var int
  140.      *
  141.      * @ORM\Column(name="question_number", type="integer", nullable=false)
  142.      */
  143.     private $questionNumber;
  144.     /**
  145.      * @Assert\NotBlank(
  146.      *    message = "Exame average not informed"
  147.      * )
  148.      *
  149.      * @Assert\GreaterThan(
  150.      *      value   = 0,
  151.      *      message = "Exame average Invalid"
  152.      * )
  153.      *
  154.      * @Assert\LessThanOrEqual(
  155.      *      value   = 10,
  156.      *      message = "Exame average Invalid"
  157.      * )
  158.      *
  159.      * @var int
  160.      *
  161.      * @ORM\Column(name="exam_average", type="decimal", precision=10, scale=2, nullable=false, options={"default"="7"})
  162.      */
  163.     private $examAverage '7';
  164.     /**
  165.      * @Assert\NotBlank(
  166.      *    message = "Exame weight not informed"
  167.      * )
  168.      *
  169.      * @Assert\GreaterThanOrEqual(
  170.      *      value   = 0,
  171.      *      message = "Exame weight Invalid"
  172.      * )
  173.      *
  174.      * @Assert\LessThanOrEqual(
  175.      *      value   = 10,
  176.      *      message = "Exame weight Invalid"
  177.      * )
  178.      *
  179.      * @var int
  180.      *
  181.      * @ORM\Column(name="exam_weight", type="integer", nullable=false, options={"default"="0"})
  182.      */
  183.     private $examWeight '0';
  184.     /**
  185.      * @Assert\NotBlank(
  186.      *    message = "Type Release not informed"
  187.      * )
  188.      *
  189.      * @Assert\Choice(
  190.      *      choices = { ExamEnum::RELEASED, ExamEnum::FIXED_DATE, ExamEnum::FLEXIBLE_PERIOD },
  191.      *      message = "Type Release Invalid"
  192.      * )
  193.      *
  194.      * @var int
  195.      *
  196.      * @ORM\Column(name="type_release", type="integer", nullable=false, options={"default"="1"})
  197.      */
  198.     private $typeRelease ExamEnum::RELEASED;
  199.     /**
  200.      * @Assert\NotBlank(
  201.      *    message = "Period start not informed"
  202.      * )
  203.      *
  204.      * @Assert\GreaterThan(
  205.      *      value   = 0,
  206.      *      groups  = "typeReleaseFlexible",
  207.      *      message = "Period start Invalid"
  208.      * )
  209.      *
  210.      * @var int
  211.      *
  212.      * @ORM\Column(name="period_start", type="integer", nullable=false, options={"default"="0"})
  213.      */
  214.     private $periodStart '0';
  215.     /**
  216.      * @Assert\NotBlank(
  217.      *    message = "Period end not informed"
  218.      * )
  219.      *
  220.      * @var int
  221.      *
  222.      * @ORM\Column(name="period_end", type="integer", nullable=false, options={"default"="0"})
  223.      */
  224.     private $periodEnd '0';
  225.     /**
  226.      * @Assert\NotBlank(
  227.      *    groups  = "typeReleaseFixedDate",
  228.      *    message = "Date Start not informed"
  229.      * )
  230.      *
  231.      * @EADAssert\DateTimeEAD(
  232.      *      message = "Date Start Invalid"
  233.      * )
  234.      *
  235.      * @var \DateTime|null
  236.      *
  237.      * @ORM\Column(name="date_start", type="datetime", nullable=true)
  238.      */
  239.     private $dateStart;
  240.     /**
  241.      * @Assert\NotBlank(
  242.      *    groups  = "notQuiz",
  243.      *    message = "Exam Time not informed"
  244.      * )
  245.      *
  246.      * @Assert\NotEqualTo(
  247.      *    value   = "00:00:00",
  248.      *    groups  = "notQuiz",
  249.      *    message = "Exam Time not informed"
  250.      * )
  251.      *
  252.      * @EADAssert\TimeEAD(
  253.      *    message = "Exam Time Invalid"
  254.      * )
  255.      *
  256.      * @var Time|null
  257.      *
  258.      * @ORM\Column(name="exam_time", type="string", length=10, nullable=true)
  259.      */
  260.     private $examTime;
  261.     /**
  262.      * @Assert\NotBlank(
  263.      *    message = "Attempts not informed"
  264.      * )
  265.      *
  266.      * @Assert\Choice(
  267.      *      choices = { ExamEnum::NO, ExamEnum::YES },
  268.      *      message = "Attempts Invalid"
  269.      * )
  270.      *
  271.      * @var int
  272.      *
  273.      * @ORM\Column(name="attempts", type="integer", nullable=false, options={"default"="0"})
  274.      */
  275.     private $attempts ExamEnum::NO;
  276.     /**
  277.      * @Assert\NotBlank(
  278.      *    message = "Attempts number not informed"
  279.      * )
  280.      *
  281.      * @Assert\GreaterThan(
  282.      *      value   = 0,
  283.      *      message = "Attempts number Invalid"
  284.      * )
  285.      *
  286.      * @var int
  287.      *
  288.      * @ORM\Column(name="attempts_number", type="integer", nullable=false, options={"default"="1"})
  289.      */
  290.     private $attemptsNumber '1';
  291.     /**
  292.      * @Assert\NotBlank(
  293.      *    message = "Attempts auto release not informed"
  294.      * )
  295.      *
  296.      * @Assert\Choice(
  297.      *      choices = { ExamEnum::NO, ExamEnum::YES },
  298.      *      message = "Attempts Auto Release Invalid"
  299.      * )
  300.      *
  301.      * @var int
  302.      *
  303.      * @ORM\Column(name="attempts_auto_release", type="integer", nullable=false, options={"default"="1"})
  304.      */
  305.     private $attemptsAutoRelease ExamEnum::YES;
  306.     /**
  307.      * @Assert\NotBlank(
  308.      *    message = "Attempts type release not informed"
  309.      * )
  310.      *
  311.      * @Assert\Choice(
  312.      *      choices = { ExamEnum::DAYS, ExamEnum::HOURS },
  313.      *      message = "Attempts type Release Invalid"
  314.      * )
  315.      *
  316.      * @var int
  317.      *
  318.      * @ORM\Column(name="attempts_type_release", type="integer", nullable=false, options={"default"="1"})
  319.      */
  320.     private $attemptsTypeRelease ExamEnum::DAYS;
  321.     /**
  322.      * @Assert\NotBlank(
  323.      *    groups  = "attemptsTypeReleaseHours",
  324.      *    message = "Attempts Time not informed"
  325.      * )
  326.      *
  327.      * @Assert\NotEqualTo(
  328.      *    value   = "00:00:00",
  329.      *    groups  = "attemptsTypeReleaseHours",
  330.      *    message = "Attempts Time not informed"
  331.      * )
  332.      *
  333.      * @EADAssert\TimeEAD(
  334.      *    message = "Attempts Time Invalid"
  335.      * )
  336.      *
  337.      * @var Time|null
  338.      *
  339.      * @ORM\Column(name="attempts_time", type="string", length=10, nullable=true)
  340.      */
  341.     private $attemptsTime;
  342.     /**
  343.      * @Assert\NotBlank(
  344.      *    groups  = "attemptsTypeReleaseDays",
  345.      *    message = "Attempts Period not informed"
  346.      * )
  347.      *
  348.      * @Assert\GreaterThan(
  349.      *      value   = 0,
  350.      *      groups  = "attemptsTypeReleaseDays",
  351.      *      message = "Attempts Period Invalid"
  352.      * )
  353.      *
  354.      * @var int|null
  355.      *
  356.      * @ORM\Column(name="attempts_period", type="integer", nullable=true)
  357.      */
  358.     private $attemptsPeriod;
  359.     /**
  360.      * @Assert\NotBlank(
  361.      *    message = "Show template not informed"
  362.      * )
  363.      *
  364.      * @Assert\Choice(
  365.      *      choices = { ExamEnum::NO, ExamEnum::YES },
  366.      *      message = "Show Template Invalid"
  367.      * )
  368.      *
  369.      * @var int
  370.      *
  371.      * @ORM\Column(name="show_template", type="integer", nullable=false, options={"default"="0"})
  372.      */
  373.     private $showTemplate ExamEnum::NO;
  374.     /**
  375.      * @Assert\NotBlank(
  376.      *    message = "Auto Correct not informed"
  377.      * )
  378.      *
  379.      * @Assert\Choice(
  380.      *      choices = { ExamEnum::NO, ExamEnum::YES },
  381.      *      message = "Auto Correct Invalid"
  382.      * )
  383.      *
  384.      * @var int
  385.      *
  386.      * @ORM\Column(name="auto_correct_text_question", type="integer", nullable=false, options={"default"="0"})
  387.      */
  388.     private $autoCorrectTextQuestion ExamEnum::NO;
  389.     /**
  390.      * @var string|null
  391.      *
  392.      * @ORM\Column(name="note", type="text", length=0, nullable=true)
  393.      */
  394.     private $note;
  395.     /**
  396.      * @EADAssert\DateTimeEAD(
  397.      *      message = "Date Last Notify Invalid"
  398.      * )
  399.      *
  400.      * @var \DateTime|null
  401.      *
  402.      * @ORM\Column(name="date_last_notify", type="datetime", nullable=true)
  403.      */
  404.     private $dateLastNotify;
  405.     /**
  406.      * @Assert\NotBlank(
  407.      *    message = "Course not informed"
  408.      * )
  409.      *
  410.      * @Assert\Valid
  411.      *
  412.      * @var \Course
  413.      *
  414.      * @ORM\ManyToOne(targetEntity="Course")
  415.      * @ORM\JoinColumns({
  416.      *   @ORM\JoinColumn(name="course_id", referencedColumnName="id", nullable=false)
  417.      * })
  418.      */
  419.     private $course;
  420.     /**
  421.      * @Assert\NotBlank(
  422.      *    groups  = "lessonModule",
  423.      *    message = "Lesson Module not informed"
  424.      * )
  425.      *
  426.      * @Assert\Valid
  427.      *
  428.      * @var \LessonModule
  429.      *
  430.      * @ORM\ManyToOne(targetEntity="LessonModule")
  431.      * @ORM\JoinColumns({
  432.      *   @ORM\JoinColumn(name="lesson_module_id", referencedColumnName="id")
  433.      * })
  434.      */
  435.     private $lessonModule;
  436.     /**
  437.      * @Assert\NotBlank(
  438.      *    groups  = "lesson",
  439.      *    message = "Lesson not informed"
  440.      * )
  441.      *
  442.      * @Assert\Valid
  443.      *
  444.      * @var \Lesson
  445.      *
  446.      * @ORM\ManyToOne(targetEntity="Lesson")
  447.      * @ORM\JoinColumns({
  448.      *   @ORM\JoinColumn(name="lesson_id", referencedColumnName="id")
  449.      * })
  450.      */
  451.     private $lesson;
  452.     /**
  453.      * @Assert\Count(
  454.      *      min = 0,
  455.      *      groups  = "examPublished",
  456.      *      minMessage = "You must specify at least one question",
  457.      * )
  458.      *
  459.      * @var \Doctrine\Common\Collections\Collection
  460.      *
  461.      * @ORM\ManyToMany(targetEntity="Question", inversedBy="exam")
  462.      * @ORM\JoinTable(name="exam_x_question",
  463.      *   joinColumns={
  464.      *     @ORM\JoinColumn(name="exam_id", referencedColumnName="id")
  465.      *   },
  466.      *   inverseJoinColumns={
  467.      *     @ORM\JoinColumn(name="question_id", referencedColumnName="id")
  468.      *   }
  469.      * )
  470.      */
  471.     private $question;
  472.     /**
  473.      * @Assert\Valid
  474.      *
  475.      * @var \EADPlataforma\Entity\User
  476.      *
  477.      * @ORM\ManyToOne(targetEntity="User")
  478.      * @ORM\JoinColumns({
  479.      *   @ORM\JoinColumn(name="user_delete_id", referencedColumnName="id", nullable=true)
  480.      * })
  481.      */
  482.     private $userDelete;
  483.     /**
  484.      * @Assert\Choice(
  485.      *      choices = { 
  486.      *                      ExamEnum::INDIVIDUAL, 
  487.      *                      ExamEnum::CASCADE
  488.      *                },
  489.      *      message = "Type Delete Invalid"
  490.      * )
  491.      *
  492.      * @var int
  493.      *
  494.      * @ORM\Column(name="type_delete", type="integer", nullable=true)
  495.      */
  496.     private $typeDelete;
  497.     /**
  498.      * @EADAssert\DateTimeEAD(
  499.      *      message = "Date Delete Invalid"
  500.      * )
  501.      *
  502.      * @var \DateTime|null
  503.      *
  504.      * @ORM\Column(name="date_delete", type="datetime", nullable=true)
  505.      */
  506.     private $dateDelete;
  507.     /**
  508.      *
  509.      * @var int
  510.      *
  511.      * @ORM\Column(name="control_time", type="integer", nullable=false, options={"default"="0"})
  512.      */
  513.     private $controlTime ExamEnum::NO;
  514.     /**
  515.      * Constructor
  516.      */
  517.     public function __construct()
  518.     {
  519.         $this->question = new \Doctrine\Common\Collections\ArrayCollection();
  520.     }
  521.     public function getId(): ?int
  522.     {
  523.         return $this->id;
  524.     }
  525.     public function getTitle(): ?string
  526.     {
  527.         return StringUtil::fromUnicode(StringUtil::encodeStringStatic($this->title));
  528.     }
  529.     public function setTitle(?string $title): self
  530.     {
  531.         $this->title StringUtil::toUnicode($title);
  532.         return $this;
  533.     }
  534.     public function getType($string false)
  535.     {
  536.         if($string){
  537.             return $this->stringType($this->type);
  538.         }
  539.         return $this->type;
  540.     }
  541.     public function setType(int $type): self
  542.     {
  543.         $this->type $type;
  544.         return $this;
  545.     }
  546.     public function getStatus(): ?int
  547.     {
  548.         return $this->status;
  549.     }
  550.     public function setStatus(int $status): self
  551.     {
  552.         $this->status $status;
  553.         return $this;
  554.     }
  555.     public function getRequirement(): ?int
  556.     {
  557.         return $this->requirement;
  558.     }
  559.     public function setRequirement(int $requirement): self
  560.     {
  561.         $this->requirement $requirement;
  562.         return $this;
  563.     }
  564.     public function getQuestionOrder(): ?int
  565.     {
  566.         return $this->questionOrder;
  567.     }
  568.     public function setQuestionOrder(int $questionOrder): self
  569.     {
  570.         $this->questionOrder $questionOrder;
  571.         return $this;
  572.     }
  573.     public function getQuestionNumber(): ?int
  574.     {
  575.         return $this->questionNumber;
  576.     }
  577.     public function setQuestionNumber(int $questionNumber): self
  578.     {
  579.         $this->questionNumber $questionNumber;
  580.         return $this;
  581.     }
  582.     public function getExamAverage()
  583.     {
  584.         return (float)$this->examAverage;
  585.     }
  586.     public function setExamAverage($examAverage): self
  587.     {
  588.         $this->examAverage = (float)$examAverage;
  589.         return $this;
  590.     }
  591.     public function getExamWeight(): ?int
  592.     {
  593.         return $this->examWeight;
  594.     }
  595.     public function setExamWeight(int $examWeight): self
  596.     {
  597.         $this->examWeight $examWeight;
  598.         return $this;
  599.     }
  600.     public function getTypeRelease(): ?int
  601.     {
  602.         return $this->typeRelease;
  603.     }
  604.     public function setTypeRelease(int $typeRelease): self
  605.     {
  606.         $this->typeRelease $typeRelease;
  607.         return $this;
  608.     }
  609.     public function getControlTime(): ?int
  610.     {
  611.         return $this->controlTime;
  612.     }
  613.     public function setControlTime(int $controlTime): self
  614.     {
  615.         $this->controlTime $controlTime;
  616.         return $this;
  617.     } 
  618.     public function getPeriodStart(): ?int
  619.     {
  620.         return $this->periodStart;
  621.     }
  622.     public function setPeriodStart(int $periodStart): self
  623.     {
  624.         $this->periodStart $periodStart;
  625.         return $this;
  626.     }
  627.     public function getPeriodEnd(): ?int
  628.     {
  629.         return $this->periodEnd;
  630.     }
  631.     public function setPeriodEnd(int $periodEnd): self
  632.     {
  633.         $this->periodEnd $periodEnd;
  634.         return $this;
  635.     }
  636.     public function getDateStart($dateFormat 'Y-m-d H:i:s')
  637.     {
  638.         if($this->dateStart){
  639.             return $this->dateStart->format($dateFormat);
  640.         }
  641.         return $this->dateStart;
  642.     }
  643.     public function setDateStart($dateStart): self
  644.     {
  645.         if(!empty($dateStart)){
  646.             $dateStart DateTime::createFromFormat('Y-m-d H:i:s'$dateStart);
  647.         }else{
  648.             $dateStart null;
  649.         }
  650.         $this->dateStart $dateStart;
  651.         return $this;
  652.     }
  653.     public function getExamTime(): ?string
  654.     {
  655.         return $this->examTime;
  656.     }
  657.     public function setExamTime(?string $examTime): self
  658.     {
  659.         $this->examTime $examTime;
  660.         return $this;
  661.     }
  662.     public function getAttempts(): ?int
  663.     {
  664.         return $this->attempts;
  665.     }
  666.     public function setAttempts(int $attempts): self
  667.     {
  668.         $this->attempts $attempts;
  669.         return $this;
  670.     }
  671.     public function getAttemptsNumber(): ?int
  672.     {
  673.         return $this->attemptsNumber;
  674.     }
  675.     public function setAttemptsNumber(int $attemptsNumber): self
  676.     {
  677.         $this->attemptsNumber $attemptsNumber;
  678.         return $this;
  679.     }
  680.     public function getAttemptsAutoRelease(): ?int
  681.     {
  682.         return $this->attemptsAutoRelease;
  683.     }
  684.     public function setAttemptsAutoRelease(int $attemptsAutoRelease): self
  685.     {
  686.         $this->attemptsAutoRelease $attemptsAutoRelease;
  687.         return $this;
  688.     }
  689.     public function getAttemptsTypeRelease(): ?int
  690.     {
  691.         return $this->attemptsTypeRelease;
  692.     }
  693.     public function setAttemptsTypeRelease(int $attemptsTypeRelease): self
  694.     {
  695.         $this->attemptsTypeRelease $attemptsTypeRelease;
  696.         return $this;
  697.     }
  698.     public function getAttemptsTime(): ?string
  699.     {
  700.         return $this->attemptsTime;
  701.     }
  702.     public function setAttemptsTime(?string $attemptsTime): self
  703.     {
  704.         $this->attemptsTime $attemptsTime;
  705.         return $this;
  706.     }
  707.     public function getAttemptsPeriod(): ?int
  708.     {
  709.         return $this->attemptsPeriod;
  710.     }
  711.     public function setAttemptsPeriod(?int $attemptsPeriod): self
  712.     {
  713.         $this->attemptsPeriod $attemptsPeriod;
  714.         return $this;
  715.     }
  716.     public function getShowTemplate(): ?int
  717.     {
  718.         return $this->showTemplate;
  719.     }
  720.     public function setShowTemplate(int $showTemplate): self
  721.     {
  722.         $this->showTemplate $showTemplate;
  723.         return $this;
  724.     }
  725.     public function getAutoCorrectTextQuestion(): ?int
  726.     {
  727.         return $this->autoCorrectTextQuestion;
  728.     }
  729.     public function setAutoCorrectTextQuestion(int $autoCorrectTextQuestion): self
  730.     {
  731.         $this->autoCorrectTextQuestion $autoCorrectTextQuestion;
  732.         return $this;
  733.     }
  734.     public function getNote(): ?string
  735.     {
  736.         return StringUtil::fromUnicode(StringUtil::encodeStringStatic($this->note));
  737.     }
  738.     public function setNote(?string $note): self
  739.     {
  740.         $this->note StringUtil::toUnicode($note);
  741.         return $this;
  742.     }
  743.     public function getDateLastNotify($dateFormat 'Y-m-d H:i:s')
  744.     {
  745.         if($this->dateLastNotify){
  746.             return $this->dateLastNotify->format($dateFormat);
  747.         }
  748.         return $this->dateLastNotify;
  749.     }
  750.     public function setDateLastNotify($dateLastNotify): self
  751.     {
  752.         if($dateLastNotify){
  753.             $dateLastNotify DateTime::createFromFormat('Y-m-d H:i:s'$dateLastNotify);
  754.         }
  755.         
  756.         $this->dateLastNotify $dateLastNotify;
  757.         return $this;
  758.     }
  759.     public function getCourse(): ?Course
  760.     {
  761.         return $this->course;
  762.     }
  763.     public function setCourse(?Course $course): self
  764.     {
  765.         $this->course $course;
  766.         return $this;
  767.     }
  768.     public function getLessonModule(): ?LessonModule
  769.     {
  770.         return $this->lessonModule;
  771.     }
  772.     public function setLessonModule(?LessonModule $lessonModule): self
  773.     {
  774.         $this->lessonModule $lessonModule;
  775.         return $this;
  776.     }
  777.     public function getLesson(): ?Lesson
  778.     {
  779.         return $this->lesson;
  780.     }
  781.     public function setLesson(?Lesson $lesson): self
  782.     {
  783.         $this->lesson $lesson;
  784.         return $this;
  785.     }
  786.     public function getUserDelete(): ?User
  787.     {
  788.         return $this->userDelete;
  789.     }
  790.     public function setUserDelete(?User $userDelete): self
  791.     {
  792.         $this->userDelete $userDelete;
  793.         return $this;
  794.     }
  795.     public function getDateDelete($dateFormat 'Y-m-d H:i:s')
  796.     {
  797.         if($this->dateDelete){
  798.             return $this->dateDelete->format($dateFormat);
  799.         }
  800.         return $this->dateDelete;
  801.     }
  802.     public function setDateDelete($dateDelete): self
  803.     {
  804.         if(!empty($dateDelete)){
  805.             $dateDelete DateTime::createFromFormat('Y-m-d H:i:s'$dateDelete);
  806.         }
  807.         
  808.         $this->dateDelete $dateDelete;
  809.         return $this;
  810.     }
  811.     /**
  812.      * @return Collection|Question[]
  813.      */
  814.     public function getQuestion(): Collection
  815.     {
  816.         return $this->question;
  817.     }
  818.     public function addQuestion(Question $question): self
  819.     {
  820.         if (!$this->question->contains($question)) {
  821.             $this->question[] = $question;
  822.         }
  823.         return $this;
  824.     }
  825.     public function getLiveQuestion(): array
  826.     {
  827.         $questions = [];
  828.         foreach ($this->question as $key => $question) {
  829.             if($question->isLive()){
  830.                 $questions[] = $question;
  831.             }
  832.         }
  833.         return $questions;
  834.     }
  835.     public function getQuestionNumberReal(): int
  836.     {
  837.         $questionNumber $this->getQuestionNumber();
  838.         $questionNumberReal count($this->getLiveQuestion());
  839.         if($questionNumber $questionNumberReal){
  840.             $questionNumber $questionNumberReal;
  841.         }
  842.         if($this->getQuestionOrder() == ExamEnum::SEQUENTIAL){
  843.             $questionNumber $questionNumberReal;
  844.         }
  845.         return $questionNumber;
  846.     }
  847.     public function removeAllQuestion(): self
  848.     {
  849.         foreach ($this->question as $key => $question) {
  850.             $this->question->removeElement($question);
  851.         }
  852.         return $this;
  853.     }
  854.     public function removeQuestion(Question $question): self
  855.     {
  856.         if ($this->question->contains($question)) {
  857.             $this->question->removeElement($question);
  858.         }
  859.         return $this;
  860.     }
  861.     public function individual(): self
  862.     {
  863.         $this->typeDelete ExamEnum::INDIVIDUAL;
  864.         return $this;
  865.     }
  866.     public function cascade(): self
  867.     {
  868.         $this->typeDelete ExamEnum::CASCADE;
  869.         return $this;
  870.     }
  871.     public function isOnTrash(): bool
  872.     {
  873.         return ($this->deleted == ExamEnum::ITEM_ON_TRASH);
  874.     }
  875.     public function isDeleted(): bool
  876.     {
  877.         return ($this->deleted == ExamEnum::ITEM_DELETED);
  878.     }
  879.     public function restore(): self
  880.     {
  881.         $this->deleted ExamEnum::ITEM_NO_DELETED;
  882.         return $this;
  883.     }
  884.     public function trash(): self
  885.     {
  886.         $this->deleted ExamEnum::ITEM_ON_TRASH;
  887.         return $this;
  888.     }
  889.     public function delete(): self
  890.     {
  891.         $this->deleted ExamEnum::ITEM_DELETED;
  892.         return $this;
  893.     }
  894.     public function stringType($type){
  895.         $string '';
  896.         switch ($type) {
  897.             case ExamEnum::COURSE:
  898.                 $string 'Course';
  899.             break;
  900.             case ExamEnum::MODULE:
  901.                 $string 'Module';
  902.             break;
  903.             case ExamEnum::LESSON:
  904.                 $string 'Lesson';
  905.             break;
  906.             case ExamEnum::QUIZ:
  907.                 $string 'Quiz';
  908.             break;
  909.         }
  910.         return $string;
  911.     }
  912.     public function getQuestionsArray(?bool $onlyQuestionLive false): ?array
  913.     {
  914.         $arrQuestion = [];
  915.         foreach ($this->question as $key => $question) {
  916.             if($question->isLive() || !$onlyQuestionLive){
  917.                 if(
  918.                     $this->type != ExamEnum::QUIZ || 
  919.                     $question->getType() == QuestionEnum::ALTERNATIVE
  920.                 ){
  921.                     $arrOption = [];
  922.                     foreach ($question->getOption() as $key => $option) {
  923.                         if($option->isLive() || !$onlyQuestionLive){
  924.                             $arrOption[] = (object)[
  925.                                 "id" => $option->getId(),
  926.                                 "option" => html_entity_decode($option->getOption()),
  927.                             ];
  928.                         }
  929.                     }
  930.                     $arrQuestion[] = (object)[
  931.                         "id" => $question->getId(),
  932.                         "order" => $question->getOrder(),
  933.                         "question" => $question->getQuestion(),
  934.                         "type" => $question->getType(),
  935.                         "note" => $question->getNote(),
  936.                         "libraryId" => (
  937.                             $question->getLibrary() ? 
  938.                             $question->getLibrary()->getId() : 
  939.                             null
  940.                         ),
  941.                         "options" => $arrOption,
  942.                     ];
  943.                 }
  944.             }
  945.         }
  946.         if(!empty($arrQuestion)){
  947.             usort($arrQuestion, function($a$b) {return $a->order $b->order;});
  948.         }
  949.         return $arrQuestion;
  950.     }
  951.     public function toReturn(bool $questions falsebool $onlyQuestionLive false){
  952.         $arrQuestion = [];
  953.         if($questions){
  954.             $arrQuestion $this->getQuestionsArray($onlyQuestionLive);
  955.         }
  956.         $data = [
  957.             "id" => $this->id,
  958.             "deleted" => $this->deleted,
  959.             "title" => $this->getTitle(),
  960.             "type" => $this->type,
  961.             "status" => $this->status,
  962.             "requirement" => $this->requirement,
  963.             "questionOrder" => $this->questionOrder,
  964.             "questionNumber" => $this->questionNumber,
  965.             "examAverage" => $this->examAverage,
  966.             "examWeight" => $this->examWeight,
  967.             "typeRelease" => $this->typeRelease,
  968.             "controlTime" => $this->controlTime,
  969.             "periodStart" => $this->periodStart,
  970.             "periodEnd" => $this->periodEnd,
  971.             "dateStart" => $this->getDateStart(),
  972.             "examTime" => $this->getExamTime(),
  973.             "attempts" => $this->attempts,
  974.             "attemptsNumber" => $this->attemptsNumber,
  975.             "attemptsAutoRelease" => $this->attemptsAutoRelease,
  976.             "attemptsTypeRelease" => $this->attemptsTypeRelease,
  977.             "attemptsTime" => $this->getAttemptsTime(),
  978.             "attemptsPeriod" => $this->attemptsPeriod,
  979.             "showTemplate" => $this->showTemplate,
  980.             "autoCorrectTextQuestion" => $this->autoCorrectTextQuestion,
  981.             "note" => $this->getNote(),
  982.             "dateLastNotify" => $this->getDateLastNotify(),
  983.             "course" => ( $this->course $this->course->getId() : null ),
  984.             "lessonModule" => ( $this->lessonModule $this->lessonModule->getId() : null ),
  985.             "lesson" => ( $this->lesson $this->lesson->getId() : null ),
  986.             "userDelete" => ( $this->userDelete $this->userDelete->getId() : null ),
  987.             "typeDelete" => $this->typeDelete,
  988.             "dateDelete" => $this->getDateDelete()
  989.         ];
  990.         if($questions){
  991.             $data["question"] = $arrQuestion;
  992.         }
  993.         return $data;
  994.     }
  995. }