src/Repository/ExamRepository.php line 1310

Open in your IDE?
  1. <?php
  3. namespace EADPlataforma\Repository;
  5. use EADPlataforma\Entity\Exam;
  6. use EADPlataforma\Entity\ExamUser;
  7. use EADPlataforma\Entity\ExamUserAnswer;
  8. use EADPlataforma\Entity\Course;
  9. use EADPlataforma\Entity\Product;
  10. use EADPlataforma\Entity\LessonModule;
  11. use EADPlataforma\Entity\Lesson;
  12. use EADPlataforma\Entity\LessonLog;
  13. use EADPlataforma\Entity\LessonLogOrigin;
  14. use EADPlataforma\Entity\Enrollment;
  15. use EADPlataforma\Entity\Question;
  16. use EADPlataforma\Entity\QuestionOption;
  17. use EADPlataforma\Entity\CourseCertificate;
  18. use EADPlataforma\Entity\User;
  19. use EADPlataforma\Entity\Trash;
  20. use EADPlataforma\Enum\ExamEnum;
  21. use EADPlataforma\Enum\ExamUserEnum;
  22. use EADPlataforma\Enum\LessonEnum;
  23. use EADPlataforma\Enum\LessonModuleEnum;
  24. use EADPlataforma\Enum\QuestionEnum;
  25. use EADPlataforma\Enum\TaskQueueEnum;
  26. use EADPlataforma\Enum\UserEnum;
  27. use EADPlataforma\Enum\EnrollmentEnum;
  28. use EADPlataforma\Enum\CourseEnum;
  30. /**
  31.  * @method Exam|null find($id, $lockMode = null, $lockVersion = null)
  32.  * @method Exam|null findOneBy(array $criteria, array $orderBy = null)
  33.  * @method Exam[]    findAll()
  34.  * @method Exam[]    findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null)
  35.  */
  36. class ExamRepository extends AbstractRepository
  37. {
  39.     public function getEntityClass(){
  40.         return Exam::class;
  41.     }
  43.     public function getConnectionName(){
  44.         return "school";
  45.     }
  47.     public function findItems()
  48.     {
  49.         return $this->createQueryBuilder('e')->getQuery()->getResult();
  50.     }
  52.     public function insertExam(
  53.         array $data, 
  54.         int $type, 
  55.         Course $course, 
  56.         ?LessonModule $lessonModule = null, 
  57.         ?Lesson $lesson = null
  58.     ): ?Exam
  59.     {
  60.         $exam = new Exam;
  61.         
  62.         $title = $data['title'] ?? null;
  63.         $status = $data['status'] ?? ExamEnum::DRAFT;
  64.         $requirement = $data['requirement'] ?? ExamEnum::NO;
  65.         $questionOrder = $data['questionOrder'] ?? ExamEnum::SEQUENTIAL;
  66.         $questionNumber = $data['questionNumber'] ?? null;
  67.         $examAverage = $data['examAverage'] ?? ExamEnum::DEFAULT_AVERAGE;
  68.         $examWeight = $data['examWeight'] ?? ExamEnum::NO;
  69.         $typeRelease = $data['typeRelease'] ?? ExamEnum::RELEASED;
  70.         $controlTime = $data['controlTime'] ?? ExamEnum::NO;
  71.         $periodStart = $data['periodStart'] ?? ExamEnum::NO;
  72.         $periodEnd = $data['periodEnd'] ?? ExamEnum::NO;
  73.         $dateStart = $data['dateStart'] ?? null;
  74.         $examTime = $data['examTime'] ?? null;
  75.         $attempts = $data['attempts'] ?? ExamEnum::NO;
  76.         $attemptsNumber = $data['attemptsNumber'] ?? ExamEnum::YES;
  77.         $attemptsAutoRelease = $data['attemptsAutoRelease'] ?? ExamEnum::YES;
  78.         $attemptsTypeRelease = $data['attemptsTypeRelease'] ?? ExamEnum::DAYS;
  79.         $attemptsTime = $data['attemptsTime'] ?? null;
  80.         $attemptsPeriod = $data['attemptsPeriod'] ?? null;
  81.         $showTemplate = $data['showTemplate'] ?? ExamEnum::NO;
  82.         $note = $data['note'] ?? null;
  83.         $questions = $data['question'] ?? null;
  84.         $notify = $data['notify'] ?? ExamEnum::NO;
  86.         if($questionOrder == ExamEnum::SEQUENTIAL){
  87.             $questionNumber = count($questions);
  88.         }
  90.         $exam->setTitle($title);
  91.         $exam->setStatus($status);
  92.         $exam->setRequirement($requirement);
  93.         $exam->setQuestionOrder($questionOrder);
  94.         $exam->setQuestionNumber($questionNumber);
  95.         $exam->setExamAverage($examAverage);
  96.         $exam->setExamWeight($examWeight);
  97.         $exam->setTypeRelease($typeRelease);
  98.         $exam->setControlTime($controlTime);
  99.         $exam->setPeriodStart($periodStart);
  100.         $exam->setPeriodEnd($periodEnd);
  101.         $exam->setDateStart($dateStart);
  102.         $exam->setExamTime($examTime);
  103.         $exam->setAttempts($attempts);
  104.         $exam->setAttemptsNumber($attemptsNumber);
  105.         $exam->setAttemptsAutoRelease($attemptsAutoRelease);
  106.         $exam->setAttemptsTypeRelease($attemptsTypeRelease);
  107.         $exam->setAttemptsTime($attemptsTime);
  108.         $exam->setAttemptsPeriod($attemptsPeriod);
  109.         $exam->setShowTemplate($showTemplate);
  110.         $exam->setNote($note);
  112.         if(!empty($questions) && is_array($questions)){
  113.             $questionRepository = $this->em->getRepository(Question::class);
  114.             foreach ($questions as $key => $questionId) {
  115.                 $question = $questionRepository->findOneBy([
  116.                     "id" => $questionId,
  117.                     "deleted" => ExamEnum::ITEM_NO_DELETED
  118.                 ]);
  120.                 if($question){
  121.                     $exam->addQuestion($question);
  122.                 }
  123.             }
  124.         }
  126.         $exam->setType($type);
  127.         $exam->setCourse($course);
  128.         $exam->setLessonModule($lessonModule);
  129.         $exam->setLesson($lesson);
  131.         $course->setDateUpdate(date('Y-m-d H:i:s'));
  133.         try {
  134.             $this->em->persist($exam);
  135.             $this->em->flush();
  136.         } catch (\Exception $e) {
  137.             return null;
  138.         }
  140.         if($notify == ExamEnum::YES){
  141.             $this->notifyStudentsExam($exam);
  142.         }
  144.         $data = $exam->toReturn();
  146.         $this->getLogService()->logInsert("exam", $exam->getId(), $data);
  148.         return $exam;
  149.     }
  151.     public function editExam(
  152.         Exam $exam,
  153.         array $data
  154.     ): ?Exam
  155.     {
  156.         $title = $data['title'] ?? null;
  157.         $status = $data['status'] ?? ExamEnum::DRAFT;
  158.         $requirement = $data['requirement'] ?? ExamEnum::NO;
  159.         $questionOrder = $data['questionOrder'] ?? ExamEnum::SEQUENTIAL;
  160.         $questionNumber = $data['questionNumber'] ?? null;
  161.         $examAverage = $data['examAverage'] ?? ExamEnum::DEFAULT_AVERAGE;
  162.         $examWeight = $data['examWeight'] ?? ExamEnum::NO;
  163.         $typeRelease = $data['typeRelease'] ?? ExamEnum::RELEASED;
  164.         $controlTime = $data['controlTime'] ?? ExamEnum::NO;
  165.         $periodStart = $data['periodStart'] ?? ExamEnum::NO;
  166.         $periodEnd = $data['periodEnd'] ?? ExamEnum::NO;
  167.         $dateStart = $data['dateStart'] ?? null;
  168.         $examTime = $data['examTime'] ?? null;
  169.         $attempts = $data['attempts'] ?? ExamEnum::NO;
  170.         $attemptsNumber = $data['attemptsNumber'] ?? ExamEnum::YES;
  171.         $attemptsAutoRelease = $data['attemptsAutoRelease'] ?? ExamEnum::YES;
  172.         $attemptsTypeRelease = $data['attemptsTypeRelease'] ?? ExamEnum::DAYS;
  173.         $attemptsTime = $data['attemptsTime'] ?? null;
  174.         $attemptsPeriod = $data['attemptsPeriod'] ?? null;
  175.         $showTemplate = $data['showTemplate'] ?? ExamEnum::NO;
  176.         $note = $data['note'] ?? null;
  177.         $questions = $data['question'] ?? null;
  178.         $notify = $data['notify'] ?? ExamEnum::NO;
  179.         
  180.         if($questionOrder == ExamEnum::SEQUENTIAL){
  181.             $questionNumber = count($questions);
  182.         }
  184.         $exam->setTitle($title);
  185.         $exam->setStatus($status);
  186.         $exam->setRequirement($requirement);
  187.         $exam->setQuestionOrder($questionOrder);
  188.         $exam->setQuestionNumber($questionNumber);
  189.         $exam->setExamAverage($examAverage);
  190.         $exam->setExamWeight($examWeight);
  191.         $exam->setTypeRelease($typeRelease);
  192.         $exam->setControlTime($controlTime);
  193.         $exam->setPeriodStart($periodStart);
  194.         $exam->setPeriodEnd($periodEnd);
  195.         $exam->setDateStart($dateStart);
  196.         $exam->setExamTime($examTime);
  197.         $exam->setAttempts($attempts);
  198.         $exam->setAttemptsNumber($attemptsNumber);
  199.         $exam->setAttemptsAutoRelease($attemptsAutoRelease);
  200.         $exam->setAttemptsTypeRelease($attemptsTypeRelease);
  201.         $exam->setAttemptsTime($attemptsTime);
  202.         $exam->setAttemptsPeriod($attemptsPeriod);
  203.         $exam->setShowTemplate($showTemplate);
  204.         $exam->setNote($note);
  206.         if(!empty($questions) && is_array($questions)){
  207.             $questionRepository = $this->em->getRepository(Question::class);
  208.             foreach ($questions as $key => $questionId) {
  209.                 $question = $questionRepository->findOneBy([
  210.                     "id" => $questionId,
  211.                     "deleted" => ExamEnum::ITEM_NO_DELETED
  212.                 ]);
  214.                 if($question){
  215.                     $exam->addQuestion($question);
  216.                 }
  217.             }
  218.         }
  220.         $course = $exam->getCourse();
  221.         $course->setDateUpdate(date('Y-m-d H:i:s'));
  223.         try {
  224.             $this->em->flush();
  225.         } catch (\Exception $e) {
  226.             return null;
  227.         }
  229.         if($notify == ExamEnum::YES){
  230.             $this->notifyStudentsExam($exam);
  231.         }
  233.         $data = $exam->toReturn();
  235.         $this->getLogService()->logUpdate("exam", $exam->getId(), $data);
  237.         return $exam;
  238.     }
  240.     public function getExamTypeText($type)
  241.     {
  242.         $examTypeText = '';
  243.         switch ($type) {
  244.             case ExamEnum::LESSON:
  245.                 $examTypeText = $this->configuration->getLanguage('lesson', 'export');
  246.                 break;
  247.             case ExamEnum::MODULE:
  248.                 $examTypeText = $this->configuration->getLanguage('module', 'export');
  249.                 break;
  250.             case ExamEnum::COURSE:
  251.                 $examTypeText = $this->configuration->getLanguage('course', 'export');
  252.                 break;
  253.         }
  255.         return $examTypeText;
  256.     }
  258.     public function notifyStudentsExam(Exam $exam)
  259.     {   
  260.         $today = date('Y-m-d');
  261.         $dateLastNotify = $exam->getDateLastNotify('Y-m-d');
  263.         if($today != $dateLastNotify){
  264.             $course = $exam->getCourse();
  265.             $lessonModule = $exam->getLessonModule();
  266.             $lesson = $exam->getLesson();
  268.             if(
  269.                 $course->getStatus() == CourseEnum::PUBLISHED && 
  270.                 $exam->getStatus() == ExamEnum::PUBLISHED
  271.             ){
  272.                 $taskQueueService = $this->generalService->getService('TaskQueueService');
  273.                 $enrollmentRepository = $this->em->getRepository(Enrollment::class);
  274.                 
  275.                 $users = $this->getUsersNotStartExam($exam);
  277.                 foreach ($users as $key => $user) {
  278.                     if($user->getAllowNotifyNewExam() == ExamEnum::YES){
  279.                         $taskQueueService->insert(TaskQueueEnum::EMAIL_NEW_EXAM, $user, $exam->getId());
  280.                     }
  281.                 }
  283.                 $exam->setDateLastNotify(date('Y-m-d H:i:s'));
  284.                 $this->em->flush();
  285.             }
  286.         }
  287.     }
  289.     public function getUsersNotStartExam(Exam $exam)
  290.     {
  291.         $userRepository = $this->em->getRepository(User::class);
  293.         $query = $userRepository->createQueryBuilder('u');
  295.         $query->innerJoin('EADPlataforma:Enrollment', 'e', 'WITH', 'e.user = u.id');
  296.         $query->andWhere('u.deleted = :deleted');
  297.         $query->andWhere('e.course = :course');
  298.         $query->andWhere('e.status = :enrollmentStatus');
  299.         $query->andWhere('e.deleted = :enrollmentDeleted');
  300.         $query->andWhere('e.datePeriod >= :now');
  302.         $subQuery = $userRepository->createQueryBuilder('examUser');
  303.         $subQuery->select('IDENTITY(eu.user)');
  304.         $subQuery->from('EADPlataforma:ExamUser', 'eu');
  305.         $subQuery->andWhere('eu.exam = :exam');
  306.         $subQuery->andWhere('eu.course = :course');
  307.         $subQuery = $subQuery->getDQL();
  309.         $query->andWhere($query->expr()->notIn('u.id', $subQuery));
  311.         $subQuery = $userRepository->createQueryBuilder('certificate');
  312.         $subQuery->select('IDENTITY(cc.user)');
  313.         $subQuery->from('EADPlataforma:CourseCertificate', 'cc');
  314.         $subQuery->andWhere('cc.course = :course');
  315.         $subQuery = $subQuery->getDQL();
  317.         $query->andWhere($query->expr()->notIn('u.id', $subQuery));
  319.         $query->setParameter('deleted', UserEnum::ITEM_NO_DELETED);
  320.         $query->setParameter('course', $exam->getCourse()->getId());
  321.         $query->setParameter('enrollmentStatus', EnrollmentEnum::STATUS_ACTIVE);
  322.         $query->setParameter('enrollmentDeleted', EnrollmentEnum::ITEM_NO_DELETED);
  323.         $query->setParameter('now', date('Y-m-d H:i:s'));
  324.         $query->setParameter('exam', $exam->getId());
  326.         return $query->getQuery()->execute();
  327.     }
  328.     
  329.     public function isExamTeacher(Exam $exam, User $user)
  330.     {
  331.         $lesson = $exam->getLesson();
  332.         $lessonModule = $exam->getLessonModule();
  333.         $course = $exam->getCourse();
  334.         
  335.         return $this->allowUserExam($course, $lessonModule, $lesson, $user);
  336.     }
  338.     public function allowUserExam(
  339.         ?Course $course = null, 
  340.         ?LessonModule $lessonModule = null, 
  341.         ?Lesson $lesson = null,
  342.         User $user
  343.     ): bool
  344.     {
  345.         if(!$course){
  346.             return false;
  347.         }
  349.         $uId = $user->getId();
  351.         if(($course->getUser()->getId() == $uId)){
  352.             return true;
  353.         }
  355.         if($lessonModule){
  356.             $lessonModuleTeahcerId = $lessonModule->getUser()->getId();
  358.             return ($lessonModuleTeahcerId == $uId);
  359.         }else if($lesson){
  360.             $lessonTeahcerId = $lesson->getUser()->getId();
  361.             $lessonModuleTeahcerId = $lesson->getLessonModule()->getUser()->getId();
  363.             return ($lessonTeahcerId == $uId || $lessonModuleTeahcerId == $uId);
  364.         } 
  366.         return false;
  367.     }
  369.     public function getExamToIndexNew(
  370.         ?bool $isStudent = true,
  371.         int $type, Course $course,
  372.         ?LessonModule $lessonModule = null, 
  373.         ?Lesson $lesson = null
  374.     )
  375.     {
  376.         $filter = [
  377.             "course" => $course->getId(),
  378.             "type" => $type,
  379.             "deleted" => ExamEnum::ITEM_NO_DELETED
  380.         ];
  382.         if($isStudent){
  383.             $filter["status"] = ExamEnum::PUBLISHED;
  384.         }
  386.         if(!empty($lessonModule)){
  387.             $filter["lessonModule"] = $lessonModule->getId();
  388.         }
  390.         if(!empty($lesson)){
  391.             $filter["lesson"] = $lesson->getId();
  392.         }
  394.         $e = $this->findOneBy($filter);
  395.         $examUser = null;
  397.         if($e && !empty($e->getQuestionNumber())){
  398.             $examUserData = null;
  399.             if($this->getUser()){
  401.                 $examUserRepository = $this->em->getRepository(ExamUser::class);
  402.                 $examUser = $examUserRepository->findOneBy([
  403.                     "user" => $this->getUser()->getId(),
  404.                     "exam" => $e->getId(),
  405.                     "inactive" => ExamUserEnum::NO,
  406.                     "deleted" => ExamUserEnum::ITEM_NO_DELETED
  407.                 ]);
  408.             }
  410.             $infoAccess = $this->checkExamIsAccessible($e, $examUser);
  412.             $data = [
  413.                 "id" => $e->getId(),
  414.                 "title" => $e->getTitle(),
  415.                 "type" => $e->getType(),
  416.                 "status" => (
  417.                     $examUser ? 
  418.                     $examUser->getStatus() : 
  419.                     ExamUserEnum::NOT_STARTED
  420.                 ),
  421.                 "examStatus" => $e->getStatus(),
  422.                 "examWeight" => $e->getExamWeight(),
  423.                 "examTime" => $e->getExamTime(),
  424.                 "questionNumber" => $e->getQuestionNumber(),
  425.                 "isAccessible" => $infoAccess->isAccessible,
  426.                 "acessMessage" => $infoAccess->message,
  427.                 "dateReleaseAccess" => $infoAccess->dateRelease,
  428.                 "dateCloseAccess" => $infoAccess->dateClose,
  429.             ];
  431.             return $data;
  432.         }
  434.         return;
  435.     }
  437.     public function getExamToIndex(
  438.         int $type, Course $course, 
  439.         ?LessonModule $lessonModule = null, 
  440.         ?Lesson $lesson = null
  441.     )
  442.     {
  443.         $filter = [
  444.             "course" => $course->getId(),
  445.             "type" => $type,
  446.             "status" => ExamEnum::PUBLISHED,
  447.             "deleted" => ExamEnum::ITEM_NO_DELETED
  448.         ];
  450.         if(!empty($lessonModule)){
  451.             $filter["lessonModule"] = $lessonModule->getId();
  452.         }
  454.         if(!empty($lesson)){
  455.             $filter["lesson"] = $lesson->getId();
  456.         }
  458.         $e = $this->findOneBy($filter);
  459.         $examUser = null;
  461.         if($e && !empty($e->getQuestionNumber())){
  463.             $examUserData = null;
  464.             if($this->getUser()){
  466.                 $examUserRepository = $this->em->getRepository(ExamUser::class);
  467.                 $examUser = $examUserRepository->findOneBy([
  468.                     "user" => $this->getUser()->getId(),
  469.                     "exam" => $e->getId(),
  470.                     "inactive" => ExamUserEnum::NO,
  471.                     "deleted" => ExamUserEnum::ITEM_NO_DELETED
  472.                 ]);
  474.                 if($examUser){
  475.                     $dateTimeUtil = $this->generalService->getUtil('DateTimeUtil');
  477.                     $todaySeconds = strtotime(date('Y-m-d H:i:s'));
  478.                     $dateStartSeconds = strtotime($examUser->getDateStart());
  479.                     $timeSeconds = $dateTimeUtil->timeToSec($e->getExamTime());
  481.                     $dateExamEndSecods = $dateStartSeconds + $timeSeconds;
  482.                     $timeRestToEndSeconds = $timeSeconds;
  483.                     if($examUser->getStatus() == ExamUserEnum::IN_PROGRESS){
  484.                         $timeRestToEndSeconds = $dateExamEndSecods - $todaySeconds;
  485.                         if($timeRestToEndSeconds < 0){
  486.                             $timeRestToEndSeconds = 0;
  487.                         }
  488.                     }
  490.                     $progress = 100;
  491.                     $qNumber = $e->getQuestionNumber();
  492.                     
  493.                     if(
  494.                         $examUser->getStatus() == ExamUserEnum::IN_PROGRESS || 
  495.                         $examUser->getStatus() == ExamUserEnum::TIMEOUT
  496.                     ){
  497.                         $euAnswerRepository = $this->em->getRepository(ExamUserAnswer::class);
  499.                         $qNumber = $euAnswerRepository->countAsnweredByExamUser(
  500.                             $examUser
  501.                         );
  503.                         $progress = round($qNumber * 100 / $e->getQuestionNumber());
  504.                     }
  506.                     $examUserData = (object)[
  507.                         "id" => $examUser->getId(),
  508.                         "status" => $examUser->getStatus(),
  509.                         "grade" => $examUser->getGrade(),
  510.                         "timeRestToEnd" => $dateTimeUtil->secToTime($timeRestToEndSeconds),
  511.                         "timeRestToEndSeconds" => $timeRestToEndSeconds,
  512.                         "dateStart" => $examUser->getDateStart('Y-m-d H:i:s'),
  513.                         "questionAnswerNumber" => $qNumber,
  514.                         "progress" => $progress
  515.                     ];
  516.                 }
  517.             }
  519.             $infoAccess = $this->checkExamIsAccessible($e, $examUser);
  521.             $data = [
  522.                 "id" => $e->getId(),
  523.                 "courseId" => $e->getCourse()->getId(),
  524.                 "lessonModuleId" => (
  525.                     $e->getLessonModule() ? $e->getLessonModule()->getId() : null
  526.                 ),
  527.                 "lessonId" => ($e->getLesson() ? $e->getLesson()->getId() : null),
  528.                 "title" => $e->getTitle(),
  529.                 "type" => $e->getType(),
  530.                 "examWeight" => $e->getExamWeight(),
  531.                 "examTime" => $e->getExamTime(),
  532.                 "questionNumber" => $e->getQuestionNumber(),
  533.                 "isAccessible" => $infoAccess->isAccessible,
  534.                 "dateReleaseAccess" => $infoAccess->dateRelease,
  535.                 "dateCloseAccess" => $infoAccess->dateClose,
  536.                 "examUser" => $examUserData,
  537.             ];
  539.             return $data;
  540.         }
  542.         return;
  543.     }
  545.     public function getExamByQuestions(Question $question)
  546.     {
  547.         $questionId = $question->getId();
  549.         $query = $this->createQueryBuilder('e');
  551.         $query->innerJoin(
  552.             'EADPlataforma:Question', 
  553.             'q', 
  554.             'WITH', 
  555.             'e MEMBER OF q.exam AND q.id = :questionId'
  556.         );
  558.         $query->setParameter('questionId', $questionId);
  559.         $query->andWhere('e.deleted = :deleted');
  560.         $query->setParameter('deleted', ExamEnum::ITEM_NO_DELETED);
  562.         return $query->getQuery()->execute();
  563.     }
  565.     public function counterExamAndQuiz(Question $question){
  566.         $quantityQuiz = 0;
  568.         $examIds = $question->toReturn()["exam"];
  569.         $quantityExam = count($question->toReturn()["exam"]);
  571.         $exams = $this->findBy([
  572.             "id" => $examIds
  573.         ]);
  574.         
  575.         foreach ($exams as $exam) {
  576.             if($exam->getType() == ExamEnum::QUIZ) {
  577.                 $quantityQuiz++;
  578.                 $quantityExam--;
  579.             }
  580.         }
  582.         $counters = [
  583.             "quantityQuiz" => $quantityQuiz,
  584.             "quantityExam" => $quantityExam
  585.         ];
  587.         return $counters;
  588.     }
  589.     public function checkExamIsAccessible(Exam $exam, ?ExamUser $examUser = null){
  591.         $info = (object)[
  592.             "isAccessible" => false,
  593.             "dateRelease" => null,
  594.             "dateClose" => null,
  595.             "message" => null,
  596.         ];
  598.         $typeRelease = $exam->getTypeRelease();
  599.         if($typeRelease == ExamEnum::FIXED_DATE){
  600.             $dateStart = $exam->getDateStart();
  601.             $info->dateRelease = $dateStart;
  602.         }
  604.         if(!$this->getUser()){
  605.             $info->message = $this->configuration->getLanguage('error_auth', 'lesson_view_error');
  607.             return $info;
  608.         }
  610.         $lessonRepository = $this->em->getRepository(Lesson::class);
  611.         $logRepository = $this->em->getRepository(LessonLogOrigin::class);
  612.         $lessonLogRepository = $this->emEadmin->getRepository(LessonLog::class);
  613.         $courseRepository = $this->em->getRepository(Course::class);
  614.         $examUserRepository = $this->em->getRepository(ExamUser::class);
  616.         if(empty($examUser)){
  617.             $examUser = $examUserRepository->findOneBy([
  618.                 "user" => $this->getUser()->getId(),
  619.                 "exam" => $exam->getId(),
  620.                 "inactive" => ExamUserEnum::NO,
  621.                 "deleted" => ExamUserEnum::ITEM_NO_DELETED
  622.             ]);
  623.         }
  625.         if(!empty($examUser)){
  626.             $info->isAccessible = true;
  627.             return $info;
  628.         }
  630.         $today = date('Y-m-d');
  631.         $todayDateTime = date('Y-m-d H:i:s');
  632.         $course = $exam->getCourse();
  633.         $isStudent = $courseRepository->isStudent($course);
  634.         if(!$isStudent){
  635.             $info->isAccessible = true;
  636.             return $info;
  637.         }
  639.         $lesson = null;
  640.         $hasLessonControl = $this->configuration->checkModuleIsAbleOnPlan(
  641.             'lessonControlFunction'
  642.         );
  644.         $lessonNumber = $lessonRepository->getLessonPublicNumber($course);
  645.         $lessonNumberModule = $lessonNumber;
  647.         if(empty($lessonNumber)){
  648.             $info->isAccessible = true;
  649.             return $info;
  650.         }
  652.         if(!$hasLessonControl && $exam->getType() != ExamEnum::QUIZ){
  653.             $lessonsNumberComplete = $logRepository->count([
  654.                 "complete" => LessonEnum::YES,
  655.                 "course" => $course->getId(),
  656.                 "user" => $this->getUser()->getId()
  657.             ]);
  659.             if($lessonsNumberComplete >= $lessonNumber){
  660.                 $info->isAccessible = true;
  661.                 return $info;
  662.             }
  663.         }else if($exam->getType() == ExamEnum::COURSE){
  664.             $lesson = $lessonRepository->getLastLesson($course);
  666.             $lessonNumberRequired = $lessonRepository->getLessonPublicNumber(
  667.                 $course, 
  668.                 null, 
  669.                 true
  670.             );
  672.             $lessonsNumberComplete = $logRepository->countLessonLogOriginCompleteRequired(
  673.                 $this->getUser(), 
  674.                 $course
  675.             );
  677.             if($lessonsNumberComplete < $lessonNumberRequired){
  679.                 $info->message = $this->configuration->getLanguage(
  680.                     'error_required_incomplete', 
  681.                     'lesson_view_error'
  682.                 );
  684.                 return $info;
  685.             }
  686.         }else if($exam->getType() == ExamEnum::MODULE){
  687.             $lesson = $lessonRepository->getLastLesson($course, $exam->getLessonModule());
  689.             $lessonNumberRequired = $lessonRepository->getLessonPublicNumber(
  690.                 $course, 
  691.                 $exam->getLessonModule(), 
  692.                 true
  693.             );
  695.             $lessonNumberModule = $lessonRepository->getLessonPublicNumber(
  696.                 $course, 
  697.                 $exam->getLessonModule(),
  698.                 false,
  699.                 true
  700.             );
  702.             $lessonsNumberComplete = $logRepository->countLessonLogOriginCompleteRequired(
  703.                 $this->getUser(), 
  704.                 $course,
  705.                 $exam->getLessonModule()
  706.             );
  708.             if($lessonsNumberComplete < $lessonNumberRequired){
  710.                 $info->message = $this->configuration->getLanguage(
  711.                     'error_required_incomplete', 
  712.                     'lesson_view_error'
  713.                 );
  715.                 return $info;
  716.             }
  718.         }else if($exam->getType() == ExamEnum::LESSON){
  719.             $lesson = $exam->getLesson();
  720.         }else if($exam->getType() == ExamEnum::QUIZ){
  721.             $lesson = $exam->getLesson();
  722.         }
  724.         if($lesson && $hasLessonControl){
  725.             $currentLesson = $lessonRepository->getCurrentLesson($lesson, $this->getUser());
  726.             
  727.             if(empty($currentLesson)){
  729.                 if(empty($examUser)){
  730.                     $currentExam = $examUserRepository->getCurrentExamOnCourseToUserByLesson(
  731.                         $lesson, 
  732.                         $this->getUser()
  733.                     );
  734.                     
  735.                     if($currentExam && $currentExam->getId() != $exam->getId()){
  736.                         if($exam->getType() != ExamEnum::QUIZ){
  738.                             $info->message = $this->configuration->getLanguage(
  739.                                 'error_required_incomplete', 
  740.                                 'lesson_view_error'
  741.                             );
  743.                             return $info;
  744.                         }
  745.                     }
  746.                 }
  747.                 
  748.                 $logId = "{$course->getId()}#{$this->getUser()->getId()}#{$lesson->getId()}";
  749.                 $log = $lessonLogRepository->find($logId);
  751.                 if($lesson->getControlRequirement() == LessonEnum::YES){
  752.                     if(!$log || ($log && empty($log->getDateConclusion()))){
  754.                         $info->message = $this->configuration->getLanguage(
  755.                             'error_required_incomplete', 
  756.                             'lesson_view_error'
  757.                         );
  759.                         return $info;
  760.                     }
  761.                 }
  762.                 
  763.                 $dateReference = ($log ? $log->getDateConclusion() : null);
  765.                 if($typeRelease == ExamEnum::FIXED_DATE){
  766.                     $dateStart = $exam->getDateStart();
  767.                     if($dateStart > $todayDateTime){
  768.                         $info->dateRelease = $dateStart;
  770.                         $info->message = "{$this->configuration->getLanguage(
  771.                             'error_date_release', 
  772.                             'lesson_view_error'
  773.                         )} {$exam->getDateStart('d/m/Y H:i:s')}";
  775.                         return $info;
  776.                     }
  777.                    
  778.                 }else if($typeRelease == ExamEnum::FLEXIBLE_PERIOD){
  779.                     if(empty($dateReference)){
  781.                         $info->message = $this->configuration->getLanguage(
  782.                             'error_required_incomplete', 
  783.                             'lesson_view_error'
  784.                         );
  786.                         return $info;
  787.                     }
  789.                     $textDate = "{$dateReference} + {$exam->getPeriodStart()} days";
  790.                     $dateStart = date('Y-m-d', strtotime($textDate));
  792.                     if($dateStart > $today){
  793.                         $info->dateRelease = $dateStart;
  795.                         $dateStartText = date('d/m/Y H:i:s', strtotime($textDate));
  796.                         $info->message = "{$this->configuration->getLanguage(
  797.                             'error_date_release', 
  798.                             'lesson_view_error'
  799.                         )} {$dateStartText}";
  801.                         return $info;
  802.                     }
  803.                 }
  805.                 $periodEnd = $exam->getPeriodEnd();
  806.                 if(!empty($periodEnd)){
  808.                     if($typeRelease == ExamEnum::FIXED_DATE){
  809.                         $dateReference = $exam->getDateStart();
  810.                     }
  811.                     
  812.                     if(empty($dateReference) && $typeRelease != ExamEnum::RELEASED){
  814.                         $info->message = $this->configuration->getLanguage(
  815.                             'error_required_incomplete', 
  816.                             'lesson_view_error'
  817.                         );
  819.                         return $info;
  820.                     }
  822.                     $textDate = "{$dateReference} + {$periodEnd} days";
  823.                     $dateEnd = date('Y-m-d', strtotime($textDate));
  825.                     if($dateEnd < $today){
  826.                         if(empty($examUser)){
  828.                             $dateEndText = date('d/m/Y H:i:s', strtotime($textDate));
  830.                             $info->dateClose = $dateEnd;
  832.                             $info->message = "{$this->configuration->getLanguage(
  833.                                 'error_date_end', 
  834.                                 'lesson_view_error'
  835.                             )} {$dateEndText}";
  837.                             return $info;
  838.                         }
  839.                     }
  840.                 }
  842.                 $info->isAccessible = true;
  843.                 return $info;
  844.             }
  846.         }else if(empty($lessonNumber) || empty($lessonNumberModule) || !$hasLessonControl){
  847.             if($typeRelease == ExamEnum::FIXED_DATE){
  848.                 $dateStart = $exam->getDateStart();
  849.                 if($dateStart > $todayDateTime){
  850.                     $info->dateRelease = $dateStart;
  852.                     $info->message = "{$this->configuration->getLanguage(
  853.                         'error_date_release', 
  854.                         'lesson_view_error'
  855.                     )} {$exam->getDateStart('d/m/Y H:i:s')}";
  857.                     return $info;
  858.                 }
  860.                 $info->isAccessible = true;
  861.                 return $info;
  862.             }
  863.             //else if($typeRelease == ExamEnum::FLEXIBLE_PERIOD){
  864.             //}
  866.             $periodEnd = $exam->getPeriodEnd();
  867.             if(!empty($periodEnd)){
  869.                 $dateReference = null;
  870.                 if($typeRelease == ExamEnum::FIXED_DATE){
  871.                     $dateReference = $exam->getDateStart();
  872.                 }
  873.                 
  874.                 if(empty($dateReference) && $typeRelease != ExamEnum::RELEASED){
  876.                     $info->message = $this->configuration->getLanguage(
  877.                         'error_required_incomplete', 
  878.                         'lesson_view_error'
  879.                     );
  881.                     return $info;
  882.                 }
  884.                 /*$textDate = "{$dateReference} + {$periodEnd} days";
  885.                 $dateEnd = date('Y-m-d', strtotime($textDate));
  887.                 if($dateEnd < $today){
  888.                     if(empty($examUser)){
  889.                         $info->dateClose = $dateEnd;
  890.                         return $info;
  891.                     }
  892.                 }*/
  893.             }
  895.             $info->isAccessible = true;
  896.             
  897.             return $info;
  898.         }
  899.         return $info;
  900.     }
  902.     public function getExamNumberByProduct(Product $product)
  903.     {
  904.         $query = $this->createQueryBuilder('e');
  905.         $query->select("COUNT(e.id) AS total");
  906.         $query->innerJoin('EADPlataforma:Product', 'p', 'WITH', 'e.course MEMBER OF p.course');
  907.         $query->andWhere('e.deleted = :deleted');
  908.         $query->andWhere('e.status = :examStatus');
  909.         $query->andWhere('p.id = :productId');
  911.         $query->setParameter('deleted', ExamEnum::ITEM_NO_DELETED);
  912.         $query->setParameter('examStatus', ExamEnum::PUBLISHED);
  913.         $query->setParameter('productId', $product->getId());
  914.               
  915.         $result = (object)$query->getQuery()->getOneOrNullResult();
  916.         return $result->total;
  917.     }
  919.     public function getNextExamIdByLesson(Lesson $lesson, bool $addTitle = false)
  920.     {
  921.         $lessonRepository = $this->em->getRepository(Lesson::class);
  922.         $course = $lesson->getCourse();
  923.         $lessonModule = $lesson->getLessonModule();
  925.         $addExams = false;
  926.         $addExamsLimited = false;
  928.         if(
  929.             $this->configuration->isModuleActive("exam_module") &&
  930.             $this->configuration->checkModuleIsAbleOnPlan("examFunction")
  931.             
  932.         ){
  933.             $addExams = true;
  934.             $addExamsLimited = $this->configuration->checkModuleIsAbleOnPlan(
  935.                 "unlimitedExamFunction"
  936.             );
  937.         }
  939.         $exam = $this->findOneBy([
  940.             "deleted" => ExamEnum::ITEM_NO_DELETED,
  941.             "course" => $course->getId(),
  942.             "lessonModule" => $lessonModule->getId(),
  943.             "lesson" => $lesson->getId(),
  944.             "status" => ExamEnum::PUBLISHED,
  945.             "type" => ExamEnum::QUIZ
  946.         ]);
  948.         if(!$exam){
  949.             if(!$addExams || !$addExamsLimited){
  950.                 return;
  951.             }
  953.             $exam = $this->findOneBy([
  954.                 "deleted" => ExamEnum::ITEM_NO_DELETED,
  955.                 "course" => $course->getId(),
  956.                 "lessonModule" => $lessonModule->getId(),
  957.                 "lesson" => $lesson->getId(),
  958.                 "status" => ExamEnum::PUBLISHED,
  959.                 "type" => ExamEnum::LESSON
  960.             ]);
  961.         }
  963.         if(!$exam && $lessonRepository->isLastModuleLesson($lesson)){
  964.             if(!$addExams || !$addExamsLimited){
  965.                 return;
  966.             }
  968.             $exam = $this->findOneBy([
  969.                 "deleted" => ExamEnum::ITEM_NO_DELETED,
  970.                 "course" => $course->getId(),
  971.                 "lessonModule" => $lessonModule->getId(),
  972.                 "status" => ExamEnum::PUBLISHED,
  973.                 "type" => ExamEnum::MODULE
  974.             ]);
  975.         }
  977.         if(!$exam && $lessonRepository->isLastCourseLesson($lesson)){
  979.             if(!$addExams){
  980.                 return;
  981.             }
  983.             $exam = $this->findOneBy([
  984.                 "deleted" => ExamEnum::ITEM_NO_DELETED,
  985.                 "course" => $course->getId(),
  986.                 "status" => ExamEnum::PUBLISHED,
  987.                 "type" => ExamEnum::COURSE
  988.             ]);
  989.         }
  991.         if($exam){
  992.             if($addTitle){
  993.                 return (object)[ 
  994.                     "id" => $exam->getId(), 
  995.                     "title" => $exam->getTitle(),
  996.                     "courseId" => $exam->getCourse()->getId(),
  997.                     "moduleId" => (
  998.                         $exam->getLessonModule() ?
  999.                         $exam->getLessonModule()->getId() :
  1000.                         null
  1001.                     ),
  1002.                     "moduleTitle" => (
  1003.                         $exam->getLessonModule() ?
  1004.                         $exam->getLessonModule()->getTitle() :
  1005.                         null
  1006.                     ),
  1007.                     "lessonId" => (
  1008.                         $exam->getLesson() ?
  1009.                         $exam->getLesson()->getId() :
  1010.                         null
  1011.                     ),
  1012.                     "type" => $exam->getType(),
  1013.                 ];
  1014.             }
  1016.             return $exam->getId();
  1017.         }
  1018.         return;
  1019.     }
  1021.     public function getCurrentNotStartedExamUser(Lesson $lessonBase, User $user){
  1023.         $query = $this->createQueryBuilder('e');
  1025.         $query->leftJoin(
  1026.             'EADPlataforma:LessonModule', 
  1027.             'lm', 
  1028.             'WITH', 
  1029.             'lm.id = e.lessonModule'
  1030.         );
  1032.         $query->leftJoin(
  1033.             'EADPlataforma:Lesson', 
  1034.             'l', 
  1035.             'WITH', 
  1036.             'l.id = e.lesson'
  1037.         );
  1039.         $query->andWhere('e.course = :course');
  1040.         $query->andWhere('e.requirement = :yes');
  1041.         $query->andWhere('e.status = :statusExam');
  1042.         $query->andWhere('(
  1043.             (
  1044.                 e.type = :typeLesson 
  1045.                 AND l.deleted = :lDeleted 
  1046.                 AND l.status = :lStatus
  1047.                 AND lm.status = :lmStatus
  1048.             ) OR 
  1049.             (
  1050.                 e.type = :typeModule 
  1051.                 AND lm.deleted = :lmDeleted 
  1052.                 AND lm.status = :lmStatus
  1053.             )
  1054.         )');
  1056.         $query->andWhere('(
  1057.             ( l.order <= :orderL AND lm.order = :orderLM ) OR 
  1058.             ( lm.order < :orderLM )
  1059.         )');
  1060.         $query->andWhere('e.deleted = :deleted');
  1062.         $course = $lessonBase->getCourse();
  1063.         $lessonModule = $lessonBase->getLessonModule();
  1065.         $subQuery = $this->createQueryBuilder('examUser');
  1066.         $subQuery->select('IDENTITY(eu.exam)');
  1067.         $subQuery->from('EADPlataforma:ExamUser', 'eu');
  1068.         $subQuery->andWhere('eu.course = :course');
  1069.         $subQuery->andWhere('eu.deleted = :deletedExamUser');
  1070.         $subQuery->andWhere('eu.status = :statusAproved OR eu.releaseAccess = :yes');
  1071.         $subQuery->andWhere('eu.user = :user');
  1072.         $subQuery = $subQuery->getDQL();
  1074.         $query->andWhere($query->expr()->notIn('e.id', $subQuery));
  1076.         $secondsDay = 24 * 60 * 60;
  1078.         $query->andWhere("
  1079.             (e.periodEnd IS NULL OR e.periodEnd = :no) OR
  1080.             (
  1081.                 ( e.typeRelease = :typeStartReleased )
  1082.                 OR
  1083.                 (
  1084.                     e.typeRelease = :typeStartFixedDate
  1085.                     AND TIME_TO_SEC(e.dateStart) <=  TIME_TO_SEC(:now)
  1086.                     AND (
  1087.                         TIME_TO_SEC(e.dateStart) + (e.periodEnd * {$secondsDay})
  1088.                     ) >= TIME_TO_SEC(:now)
  1089.                 )
  1090.                 OR
  1091.                 (
  1092.                     e.typeRelease = :typeStartFlexPeriod
  1093.                 )
  1094.             )
  1095.         ");
  1097.         /* !!!
  1099.             $caseDate = "CASE 
  1100.                         WHEN e.type = :typeLesson
  1101.                             AND (
  1102.                                     SELECT 
  1103.                                         lg.id
  1104.                                     FROM EADPlataforma:LessonLogOrigin AS lg
  1105.                                     WHERE lg.user = :user
  1106.                                     AND lg.lesson = e.lesson
  1107.                                     AND lg.complete = :completed
  1108.                                     LIMIT 1 
  1109.                                 ) > 0 
  1110.                         THEN
  1111.                             (   
  1112.                                 SELECT 
  1113.                                     lg.dateConclusion 
  1114.                                 FROM EADPlataforma:LessonLogOrigin AS lg
  1115.                                 WHERE lg.user = :user
  1116.                                 AND lg.lesson = e.lesson
  1117.                                 AND lg.complete = :completed
  1118.                                 LIMIT 1
  1119.                             )
  1120.                         WHEN e.type = :typeModule
  1121.                              AND (   
  1122.                                 SELECT 
  1123.                                     lg.id
  1124.                                 FROM EADPlataforma:LessonLogOrigin AS lg
  1125.                                 WHERE lg.user = :user
  1126.                                 AND lg.complete = :completed
  1127.                                 AND lg.lesson = (
  1128.                                     SELECT
  1129.                                         le.aula_id 
  1130.                                     FROM EADPlataforma:Lesson AS le
  1131.                                     WHERE le.lessonModule = e.lessonModule 
  1132.                                     AND le.status = :statusL
  1133.                                     AND le.deleted = 0
  1134.                                     ORDER BY le.order DESC LIMIT 1
  1135.                                 )
  1136.                                 LIMIT 1
  1137.                             ) > 0 
  1138.                         THEN
  1139.                             (   
  1140.                                 SELECT 
  1141.                                     lg.dateConclusion
  1142.                                 FROM EADPlataforma:LessonLogOrigin AS lg
  1143.                                 WHERE lg.user = :user
  1144.                                 AND lg.complete = :completed
  1145.                                 AND lg.lesson = (
  1146.                                     SELECT
  1147.                                         le.aula_id 
  1148.                                     FROM EADPlataforma:Lesson AS le
  1149.                                     WHERE le.lessonModule = e.lessonModule 
  1150.                                     AND le.status = :statusL
  1151.                                     AND le.deleted = 0
  1152.                                     ORDER BY le.order DESC LIMIT 1
  1153.                                 )
  1154.                                 LIMIT 1
  1155.                             )
  1156.                         ELSE
  1157.                             '0000-00-00 00:00:00'
  1158.                     END";
  1160.         $caseLogId = "CASE 
  1161.                         WHEN e.type = :typeLesson
  1162.                         THEN
  1163.                             (   
  1164.                                 SELECT 
  1165.                                     lg.id
  1166.                                 FROM EADPlataforma:LessonLogOrigin AS lg
  1167.                                 WHERE lg.user = :user
  1168.                                 AND lg.lesson = e.lesson
  1169.                                 AND lg.complete = :completed
  1170.                                 LIMIT 1 
  1171.                             )
  1172.                         WHEN e.type = :typeModule
  1173.                         THEN
  1174.                             (   
  1175.                                 SELECT 
  1176.                                     lg.id
  1177.                                 FROM EADPlataforma:LessonLogOrigin AS lg
  1178.                                 WHERE lg.user = :user
  1179.                                 AND lg.complete = :completed
  1180.                                 AND lg.lesson = (
  1181.                                     SELECT
  1182.                                         le.aula_id 
  1183.                                     FROM EADPlataforma:Lesson AS le
  1184.                                     WHERE le.lessonModule = e.lessonModule 
  1185.                                     AND le.status = :statusL
  1186.                                     AND le.deleted = 0
  1187.                                     ORDER BY le.order DESC LIMIT 1
  1188.                                 )
  1189.                                 LIMIT 1
  1190.                             )
  1191.                         ELSE 0
  1192.                     END";
  1193.                     
  1194.             AND (1) > 0
  1195.             AND (
  1196.                 TIME_TO_SEC({$caseDate}) + (e.periodStart * {$secondsDay})
  1197.             ) <= TIME_TO_SEC(:now)
  1198.             AND (
  1199.                 TIME_TO_SEC({$caseDate}) + (e.periodEnd * {$secondsDay})
  1200.             ) >= TIME_TO_SEC(:now)
  1201.         */
  1203.         $query->setParameter('lmDeleted', LessonModuleEnum::ITEM_NO_DELETED);
  1204.         $query->setParameter('lmStatus', LessonModuleEnum::PUBLISHED);
  1205.         $query->setParameter('lDeleted', LessonEnum::ITEM_NO_DELETED);
  1206.         $query->setParameter('lStatus', LessonEnum::PUBLISHED);
  1208.         $query->setParameter('now', date('Y-m-d H:i:s'));
  1209.         $query->setParameter('typeStartReleased', ExamEnum::RELEASED);
  1210.         $query->setParameter('typeStartFixedDate', ExamEnum::FIXED_DATE);
  1211.         $query->setParameter('typeStartFlexPeriod', ExamEnum::FLEXIBLE_PERIOD);
  1213.         $query->setParameter('course', $course->getId());
  1214.         $query->setParameter('user', $user->getId());
  1215.         $query->setParameter('yes', ExamEnum::YES);
  1216.         $query->setParameter('no', ExamEnum::NO);
  1217.         $query->setParameter('statusAproved', ExamUserEnum::APPROVED);
  1218.         $query->setParameter('statusExam', ExamEnum::PUBLISHED);
  1219.         $query->setParameter('typeModule', ExamEnum::MODULE);
  1220.         $query->setParameter('typeLesson', ExamEnum::LESSON);
  1221.         $query->setParameter('orderL', $lessonBase->getOrder());
  1222.         $query->setParameter('orderLM', $lessonModule->getOrder());
  1223.         $query->setParameter('deleted', ExamEnum::ITEM_NO_DELETED);
  1224.         $query->setParameter('deletedExamUser', ExamUserEnum::ITEM_NO_DELETED);
  1226.         $query->setMaxResults(1);
  1227.         
  1228.         return $query->getQuery()->getOneOrNullResult();
  1229.     }
  1231.     public function getLastExamIdByLesson(Lesson $lessonBase, bool $complete = false)
  1232.     {
  1234.         $addExams = false;
  1235.         $addExamsLimited = false;
  1237.         if(
  1238.             $this->configuration->isModuleActive("exam_module") &&
  1239.             $this->configuration->checkModuleIsAbleOnPlan("examFunction")
  1240.         ){
  1241.             $addExams = true;
  1242.             $addExamsLimited = $this->configuration->checkModuleIsAbleOnPlan(
  1243.                 "unlimitedExamFunction"
  1244.             );
  1245.         }
  1247.         $lessonRepository = $this->em->getRepository(Lesson::class);
  1248.         
  1249.         $lessonIdBefore = $lessonRepository->getLessonIdBeforeThat($lessonBase);
  1250.         $lesson = $lessonRepository->findOneBy([
  1251.             "id" => $lessonIdBefore,
  1252.             "deleted" => ExamEnum::ITEM_NO_DELETED,
  1253.         ]);
  1255.         if(!$lesson){
  1256.             return;
  1257.         }
  1259.         $course = $lesson->getCourse();
  1260.         $lessonModule = $lesson->getLessonModule();
  1261.         $exam = null;
  1263.         if(!$exam && $lessonRepository->isLastModuleLesson($lesson)){
  1266.             if(!$addExams || !$addExamsLimited){
  1267.                 return;
  1268.             }
  1270.             $exam = $this->findOneBy([
  1271.                 "deleted" => ExamEnum::ITEM_NO_DELETED,
  1272.                 "course" => $course->getId(),
  1273.                 "lessonModule" => $lessonModule->getId(),
  1274.                 "status" => ExamEnum::PUBLISHED,
  1275.                 "type" => ExamEnum::MODULE
  1276.             ]);
  1277.         }
  1279.         if(!$exam){
  1280.             if(!$addExams || !$addExamsLimited){
  1281.                 return;
  1282.             }
  1284.             $exam = $this->findOneBy([
  1285.                 "deleted" => ExamEnum::ITEM_NO_DELETED,
  1286.                 "course" => $course->getId(),
  1287.                 "lessonModule" => $lessonModule->getId(),
  1288.                 "lesson" => $lesson->getId(),
  1289.                 "status" => ExamEnum::PUBLISHED,
  1290.                 "type" => ExamEnum::LESSON
  1291.             ]);
  1292.         }
  1294.         if(!$exam){
  1295.             $exam = $this->findOneBy([
  1296.                 "deleted" => ExamEnum::ITEM_NO_DELETED,
  1297.                 "course" => $course->getId(),
  1298.                 "lessonModule" => $lessonModule->getId(),
  1299.                 "lesson" => $lesson->getId(),
  1300.                 "status" => ExamEnum::PUBLISHED,
  1301.                 "type" => ExamEnum::QUIZ
  1302.             ]);
  1303.         }
  1305.         if($exam){
  1307.             if($complete){
  1308.                 return (object)[ 
  1309.                     "id" => $exam->getId(),
  1310.                     "title" => $exam->getTitle(),
  1311.                     "courseId" => $exam->getCourse()->getId(),
  1312.                     "moduleId" => (
  1313.                         $exam->getLessonModule() ?
  1314.                         $exam->getLessonModule()->getId() :
  1315.                         null
  1316.                     ),
  1317.                     "moduleTitle" => (
  1318.                         $exam->getLessonModule() ?
  1319.                         $exam->getLessonModule()->getTitle() :
  1320.                         null
  1321.                     ),
  1322.                     "lessonId" => (
  1323.                         $exam->getLesson() ?
  1324.                         $exam->getLesson()->getId() :
  1325.                         null
  1326.                     ),
  1327.                     "type" => $exam->getType(),
  1328.                 ];
  1329.             }
  1330.             
  1331.             return $exam->getId();
  1332.         }
  1333.         return;
  1334.     }
  1336.     public function sumCourseWeight($courseId)
  1337.     {
  1338.         $query = $this->createQueryBuilder('e');
  1339.         $query->select('SUM(e.examWeight) AS examWeight');
  1340.         $query->andWhere('e.status = :yes');
  1341.         $query->andWhere('e.requirement = :yes');
  1342.         $query->andWhere('e.course = :course');
  1343.         $query->andWhere('e.deleted = :deleted');
  1344.         $query->setParameter('course', $courseId);
  1345.         $query->setParameter('yes', ExamEnum::YES);
  1346.         $query->setParameter('deleted', ExamEnum::ITEM_NO_DELETED);
  1347.         
  1348.         $result = (object)$query->getQuery()->getOneOrNullResult();
  1350.         return $result->examWeight;
  1351.     }
  1353.     public function countCourseWeight($courseId)
  1354.     {
  1355.         $query = $this->createQueryBuilder('e');
  1356.         $query->select('COUNT(e.id) AS total');
  1357.         $query->andWhere('e.status = 1');
  1358.         $query->andWhere('e.examWeight > 0');
  1359.         $query->andWhere('e.requirement = 1');
  1360.         $query->andWhere('e.course = :course');
  1361.         $query->setParameter('course', $courseId);
  1362.         
  1363.         $result = (object)$query->getQuery()->getOneOrNullResult();
  1365.         return $result->total;
  1366.     }
  1368.     public function countValidExamByCourse(int $courseId)
  1369.     {
  1370.         $query = $this->createQueryBuilder('e');
  1372.         $query->innerJoin('EADPlataforma:Course', 'c', 'WITH', 'c.id = e.course');
  1373.         $query->leftJoin('EADPlataforma:LessonModule', 'lm', 'WITH', 'lm.id = e.lessonModule');
  1374.         $query->leftJoin('EADPlataforma:Lesson', 'l', 'WITH', 'l.id = e.lesson');
  1376.         $query->select('COUNT(e.id) AS total');
  1378.         $query->andWhere('e.deleted = :examDeleted');
  1379.         $query->andWhere('e.status = :examStatus');
  1380.         $query->andWhere('e.examWeight > 0');
  1381.         //$query->andWhere('e.requirement = :yes');
  1382.         $query->andWhere('e.course = :course');
  1384.         $query->andWhere('
  1385.             (
  1386.                 (e.type = :typeCourse AND c.deleted = :courseDeleted)
  1387.                 OR (
  1388.                     e.type = :typeLessonModule
  1389.                     AND lm.status = :lessonModuleStatus 
  1390.                     AND lm.deleted = :lessonModuleDeleted
  1391.                 ) 
  1392.                 OR (
  1393.                     e.type = :typeLesson 
  1394.                     AND l.status = :lessonStatus 
  1395.                     AND l.deleted = :lessonDeleted
  1396.                 )
  1397.             )
  1398.         ');
  1400.         $query->setParameter('typeCourse', ExamEnum::COURSE);
  1401.         $query->setParameter('typeLessonModule', ExamEnum::MODULE);
  1402.         $query->setParameter('typeLesson', ExamEnum::LESSON);
  1404.         $query->setParameter('examDeleted', ExamEnum::ITEM_NO_DELETED);
  1405.         $query->setParameter('courseDeleted', CourseEnum::ITEM_NO_DELETED);
  1406.         $query->setParameter('lessonModuleDeleted', LessonModuleEnum::ITEM_NO_DELETED);
  1407.         $query->setParameter('lessonDeleted', LessonEnum::ITEM_NO_DELETED);
  1408.         
  1409.         $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  1410.         $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  1411.         $query->setParameter('examStatus', ExamEnum::PUBLISHED);
  1412.         //$query->setParameter('yes', ExamEnum::YES);
  1413.         $query->setParameter('course', $courseId);
  1414.         
  1415.         $result = (object)$query->getQuery()->getOneOrNullResult();
  1417.         return $result->total;
  1418.     }
  1420.     public function copyExamQuestion(Exam $oldExam, Exam $newExam)
  1421.     {   
  1422.         $questionRepository = $this->em->getRepository(Question::class);
  1423.         $questions = $oldExam->getQuestion();
  1424.         if($questions){
  1425.             foreach ($questions as $key => $question) {
  1426.                 if($question->isLive()){
  1427.                     if($oldExam->getCourse()->getId() != $newExam->getCourse()->getId()){
  1428.                         $newQuestion = $questionRepository->copyQuestionsByCourse(
  1429.                             $question, 
  1430.                             $newExam->getCourse()
  1431.                         );
  1432.                         
  1433.                         if($newQuestion){
  1434.                             $newExam->addQuestion($newQuestion);
  1435.                         }
  1436.                     }else{
  1437.                         $newExam->addQuestion($question); 
  1438.                     }
  1439.                 }
  1440.             }
  1441.         }
  1443.         return $newExam;
  1444.     }
  1446.     public function copyExamByCourse(Course $oldCourse, Course $newCourse)
  1447.     {
  1448.         $oldExam = $this->findOneBy([
  1449.             "course" => $oldCourse->getId(),
  1450.             "type" => ExamEnum::COURSE,
  1451.             "deleted" => ExamEnum::ITEM_NO_DELETED
  1452.         ]);
  1454.         if($oldExam){
  1455.             $newExam = new Exam();
  1456.             
  1457.             $newExam->setTitle($oldExam->getTitle());
  1458.             $newExam->setType($oldExam->getType());
  1459.             $newExam->setStatus($oldExam->getStatus());
  1460.             $newExam->setRequirement($oldExam->getRequirement());
  1461.             $newExam->setQuestionOrder($oldExam->getQuestionOrder());
  1462.             $newExam->setQuestionNumber($oldExam->getQuestionNumber());
  1463.             $newExam->setExamAverage($oldExam->getExamAverage());
  1464.             $newExam->setExamWeight($oldExam->getExamWeight());
  1465.             $newExam->setTypeRelease($oldExam->getTypeRelease());
  1466.             $newExam->setPeriodStart($oldExam->getPeriodStart());
  1467.             $newExam->setPeriodEnd($oldExam->getPeriodEnd());
  1468.             $newExam->setDateStart($oldExam->getDateStart());
  1469.             $newExam->setExamTime($oldExam->getExamTime());
  1470.             $newExam->setAttempts($oldExam->getAttempts());
  1471.             $newExam->setAttemptsNumber($oldExam->getAttemptsNumber());
  1472.             $newExam->setAttemptsAutoRelease($oldExam->getAttemptsAutoRelease());
  1473.             $newExam->setAttemptsTypeRelease($oldExam->getAttemptsTypeRelease());
  1474.             $newExam->setAttemptsTime($oldExam->getAttemptsTime());
  1475.             $newExam->setAttemptsPeriod($oldExam->getAttemptsPeriod());
  1476.             $newExam->setShowTemplate($oldExam->getShowTemplate());
  1477.             $newExam->setNote($oldExam->getNote());
  1478.             $newExam->setDateLastNotify($oldExam->getDateLastNotify());
  1479.             $newExam->setCourse($newCourse);
  1480.             
  1481.             $newExam = $this->copyExamQuestion($oldExam, $newExam);
  1483.             $this->em->persist($newExam);
  1484.             $this->em->flush();
  1485.         }
  1486.     }
  1488.     public function copyExamByModule(LessonModule $oldModule, LessonModule $newModule)
  1489.     {
  1490.         $oldExam = $this->findOneBy([
  1491.             "course" => $oldModule->getCourse()->getId(), 
  1492.             "lessonModule"=> $oldModule->getId(),
  1493.             "type" => ExamEnum::MODULE,
  1494.             "deleted" => ExamEnum::ITEM_NO_DELETED
  1495.         ]);
  1497.         if($oldExam){
  1498.             $newExam = new Exam();
  1499.             
  1500.             $newExam->setTitle($oldExam->getTitle());
  1501.             $newExam->setType($oldExam->getType());
  1502.             $newExam->setStatus($oldExam->getStatus());
  1503.             $newExam->setRequirement($oldExam->getRequirement());
  1504.             $newExam->setQuestionOrder($oldExam->getQuestionOrder());
  1505.             $newExam->setQuestionNumber($oldExam->getQuestionNumber());
  1506.             $newExam->setExamAverage($oldExam->getExamAverage());
  1507.             $newExam->setExamWeight($oldExam->getExamWeight());
  1508.             $newExam->setTypeRelease($oldExam->getTypeRelease());
  1509.             $newExam->setPeriodStart($oldExam->getPeriodStart());
  1510.             $newExam->setPeriodEnd($oldExam->getPeriodEnd());
  1511.             $newExam->setDateStart($oldExam->getDateStart());
  1512.             $newExam->setExamTime($oldExam->getExamTime());
  1513.             $newExam->setAttempts($oldExam->getAttempts());
  1514.             $newExam->setAttemptsNumber($oldExam->getAttemptsNumber());
  1515.             $newExam->setAttemptsAutoRelease($oldExam->getAttemptsAutoRelease());
  1516.             $newExam->setAttemptsTypeRelease($oldExam->getAttemptsTypeRelease());
  1517.             $newExam->setAttemptsTime($oldExam->getAttemptsTime());
  1518.             $newExam->setAttemptsPeriod($oldExam->getAttemptsPeriod());
  1519.             $newExam->setShowTemplate($oldExam->getShowTemplate());
  1520.             $newExam->setNote($oldExam->getNote());
  1521.             $newExam->setDateLastNotify($oldExam->getDateLastNotify());
  1522.             $newExam->setCourse($newModule->getCourse());
  1523.             $newExam->setLessonModule($newModule);
  1524.             
  1525.             $newExam = $this->copyExamQuestion($oldExam, $newExam);
  1527.             $this->em->persist($newExam);
  1528.             $this->em->flush();
  1529.         }
  1530.     }
  1532.     public function copyExamByLesson(Lesson $oldLesson, Lesson $newLesson)
  1533.     {
  1534.         $oldExam = $this->findOneBy([
  1535.             "course" => $oldLesson->getCourse()->getId(),
  1536.             "lessonModule" => $oldLesson->getLessonModule()->getId(),
  1537.             "lesson"=> $oldLesson->getId(),
  1538.             "type" => ExamEnum::LESSON,
  1539.             "deleted" => ExamEnum::ITEM_NO_DELETED
  1540.         ]);
  1542.         if($oldExam){
  1543.             $newExam = new Exam();
  1544.             
  1545.             $newExam->setTitle($oldExam->getTitle());
  1546.             $newExam->setType($oldExam->getType());
  1547.             $newExam->setStatus($oldExam->getStatus());
  1548.             $newExam->setRequirement($oldExam->getRequirement());
  1549.             $newExam->setQuestionOrder($oldExam->getQuestionOrder());
  1550.             $newExam->setQuestionNumber($oldExam->getQuestionNumber());
  1551.             $newExam->setExamAverage($oldExam->getExamAverage());
  1552.             $newExam->setExamWeight($oldExam->getExamWeight());
  1553.             $newExam->setTypeRelease($oldExam->getTypeRelease());
  1554.             $newExam->setPeriodStart($oldExam->getPeriodStart());
  1555.             $newExam->setPeriodEnd($oldExam->getPeriodEnd());
  1556.             $newExam->setDateStart($oldExam->getDateStart());
  1557.             $newExam->setExamTime($oldExam->getExamTime());
  1558.             $newExam->setAttempts($oldExam->getAttempts());
  1559.             $newExam->setAttemptsNumber($oldExam->getAttemptsNumber());
  1560.             $newExam->setAttemptsAutoRelease($oldExam->getAttemptsAutoRelease());
  1561.             $newExam->setAttemptsTypeRelease($oldExam->getAttemptsTypeRelease());
  1562.             $newExam->setAttemptsTime($oldExam->getAttemptsTime());
  1563.             $newExam->setAttemptsPeriod($oldExam->getAttemptsPeriod());
  1564.             $newExam->setShowTemplate($oldExam->getShowTemplate());
  1565.             $newExam->setNote($oldExam->getNote());
  1566.             $newExam->setDateLastNotify($oldExam->getDateLastNotify());
  1567.             $newExam->setCourse($newLesson->getCourse());
  1568.             $newExam->setLessonModule($newLesson->getLessonModule());
  1569.             $newExam->setLesson($newLesson);
  1570.             
  1571.             $newExam = $this->copyExamQuestion($oldExam, $newExam);
  1572.             
  1573.             $this->em->persist($newExam);
  1574.             $this->em->flush();
  1575.         }
  1576.     }
  1578.     public function copyQuizByLesson(Lesson $oldLesson, Lesson $newLesson)
  1579.     {
  1580.         $oldExam = $this->findOneBy([
  1581.             "course" => $oldLesson->getCourse()->getId(),
  1582.             "lessonModule" => $oldLesson->getLessonModule()->getId(),
  1583.             "lesson"=> $oldLesson->getId(),
  1584.             "type" => ExamEnum::QUIZ,
  1585.             "deleted" => ExamEnum::ITEM_NO_DELETED
  1586.         ]);
  1588.         if($oldExam){
  1589.             $newExam = new Exam();
  1590.             
  1591.             $newExam->setTitle($oldExam->getTitle());
  1592.             $newExam->setType($oldExam->getType());
  1593.             $newExam->setStatus($oldExam->getStatus());
  1594.             $newExam->setRequirement($oldExam->getRequirement());
  1595.             $newExam->setQuestionOrder($oldExam->getQuestionOrder());
  1596.             $newExam->setQuestionNumber($oldExam->getQuestionNumber());
  1597.             $newExam->setExamAverage($oldExam->getExamAverage());
  1598.             $newExam->setExamWeight($oldExam->getExamWeight());
  1599.             $newExam->setTypeRelease($oldExam->getTypeRelease());
  1600.             $newExam->setPeriodStart($oldExam->getPeriodStart());
  1601.             $newExam->setPeriodEnd($oldExam->getPeriodEnd());
  1602.             $newExam->setDateStart($oldExam->getDateStart());
  1603.             $newExam->setExamTime($oldExam->getExamTime());
  1604.             $newExam->setAttempts($oldExam->getAttempts());
  1605.             $newExam->setAttemptsNumber($oldExam->getAttemptsNumber());
  1606.             $newExam->setAttemptsAutoRelease($oldExam->getAttemptsAutoRelease());
  1607.             $newExam->setAttemptsTypeRelease($oldExam->getAttemptsTypeRelease());
  1608.             $newExam->setAttemptsTime($oldExam->getAttemptsTime());
  1609.             $newExam->setAttemptsPeriod($oldExam->getAttemptsPeriod());
  1610.             $newExam->setShowTemplate($oldExam->getShowTemplate());
  1611.             $newExam->setNote($oldExam->getNote());
  1612.             $newExam->setDateLastNotify($oldExam->getDateLastNotify());
  1613.             $newExam->setCourse($newLesson->getCourse());
  1614.             $newExam->setLessonModule($newLesson->getLessonModule());
  1615.             $newExam->setLesson($newLesson);
  1616.             
  1617.             $newExam = $this->copyExamQuestion($oldExam, $newExam);
  1618.             
  1619.             $this->em->persist($newExam);
  1620.             $this->em->flush();
  1621.         }
  1622.     }
  1624.     public function editManyStatus(Exam $exam, $permission, $status)
  1625.     {
  1626.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  1628.         $allTypes = $this->configuration->checkModuleIsAbleOnPlan('unlimitedExamFunction');
  1629.         if(!$allTypes){
  1630.             if($exam->getType() != ExamEnum::COURSE && $exam->getType() != ExamEnum::QUIZ){
  1631.                 return false;
  1632.             }
  1633.         }
  1635.         if($exam->getType() == ExamEnum::MODULE){
  1636.             $permission = $userPermissionUtil->getPermission(
  1637.                 "course", 
  1638.                 "lesson_module", 
  1639.                 "exam_configuration", 
  1640.                 "edit"
  1641.             );
  1642.         }else if($exam->getType() == ExamEnum::LESSON){
  1643.             $permission = $userPermissionUtil->getPermission(
  1644.                 "course", 
  1645.                 "lesson", 
  1646.                 "exam_configuration", 
  1647.                 "edit"
  1648.             );
  1649.         }else if($exam->getType() == ExamEnum::QUIZ){
  1650.             $permission = $userPermissionUtil->getPermission(
  1651.                 "course", 
  1652.                 "lesson", 
  1653.                 "quiz_configuration", 
  1654.                 "edit"
  1655.             );
  1656.         }
  1658.         $isExamTeacher = $this->isExamTeacher($exam, $this->getUser());
  1659.         if($isExamTeacher && $userPermissionUtil->isMiddle($permission) || 
  1660.             $userPermissionUtil->isHigh($permission)){
  1662.             $exam->setStatus($status);
  1663.         }
  1664.     }
  1666.     public function deleteExam(Exam $exam): void
  1667.     {
  1668.         $exam->removeAllQuestion();
  1669.         $exam->setTitle(null);
  1670.         $exam->setStatus(ExamEnum::DRAFT);
  1671.         $exam->setRequirement(ExamEnum::NO);
  1672.         $exam->setQuestionOrder(ExamEnum::SEQUENTIAL);
  1673.         $exam->setQuestionNumber(0);
  1674.         $exam->setExamAverage(ExamEnum::DEFAULT_AVERAGE);
  1675.         $exam->setExamWeight(0);
  1676.         $exam->setTypeRelease(ExamEnum::RELEASED);
  1677.         $exam->setControlTime(ExamEnum::NO);
  1678.         $exam->setPeriodStart(0);
  1679.         $exam->setPeriodEnd(0);
  1680.         $exam->setDateStart(null);
  1681.         $exam->setExamTime(null);
  1682.         $exam->setAttempts(ExamEnum::NO);
  1683.         $exam->setAttemptsNumber(1);
  1684.         $exam->setAttemptsAutoRelease(ExamEnum::YES);
  1685.         $exam->setAttemptsTypeRelease(ExamEnum::DAYS);
  1686.         $exam->setAttemptsTime(null);
  1687.         $exam->setAttemptsPeriod(null);
  1688.         $exam->setShowTemplate(ExamEnum::NO);
  1689.         $exam->setNote(null);
  1690.         $exam->setDateLastNotify(null);
  1692.         $this->em->flush();
  1693.     }
  1695.     public function delete(Exam $exam, $typeItem, $permission, $isTrash)
  1696.     {
  1697.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  1699.         $allTypes = $this->configuration->checkModuleIsAbleOnPlan('unlimitedExamFunction');
  1700.         if(!$allTypes){
  1701.             if($exam->getType() != ExamEnum::COURSE && $exam->getType() != ExamEnum::QUIZ){
  1702.                 return false;
  1703.             }
  1704.         }
  1706.         if($exam->getType() == ExamEnum::MODULE){
  1707.             $permission = $userPermissionUtil->getPermission(
  1708.                 "course", 
  1709.                 "lesson_module", 
  1710.                 "exam_configuration", 
  1711.                 "delete"
  1712.             );
  1713.         }else if($exam->getType() == ExamEnum::LESSON){
  1714.             $permission = $userPermissionUtil->getPermission(
  1715.                 "course", 
  1716.                 "lesson", 
  1717.                 "exam_configuration", 
  1718.                 "delete"
  1719.             );
  1720.         }else if($exam->getType() == ExamEnum::QUIZ){
  1721.             $permission = $userPermissionUtil->getPermission(
  1722.                 "course", 
  1723.                 "lesson", 
  1724.                 "quiz_configuration", 
  1725.                 "delete"
  1726.             );
  1727.         }
  1729.         $isExamTeacher = $this->isExamTeacher($exam, $this->getUser());
  1730.         if($isExamTeacher || $userPermissionUtil->isHigh($permission)){
  1731.             $questions = $exam->getQuestion();
  1732.             if(!empty($questions)){
  1733.                 foreach ($questions as $key => $question) {
  1734.                     $exam->removeQuestion($question);
  1735.                 }
  1736.             }
  1738.             $exam->setTitle(null);
  1739.             $exam->setStatus(ExamEnum::DRAFT);
  1740.             $exam->setRequirement(ExamEnum::NO);
  1741.             $exam->setQuestionOrder(ExamEnum::SEQUENTIAL);
  1742.             $exam->setQuestionNumber(0);
  1743.             $exam->setExamAverage(ExamEnum::DEFAULT_AVERAGE);
  1744.             $exam->setExamWeight(0);
  1745.             $exam->setTypeRelease(ExamEnum::RELEASED);
  1746.             $exam->setControlTime(ExamEnum::NO);
  1747.             $exam->setPeriodStart(0);
  1748.             $exam->setPeriodEnd(0);
  1749.             $exam->setDateStart(null);
  1750.             $exam->setExamTime(null);
  1751.             $exam->setAttempts(ExamEnum::NO);
  1752.             $exam->setAttemptsNumber(1);
  1753.             $exam->setAttemptsAutoRelease(ExamEnum::YES);
  1754.             $exam->setAttemptsTypeRelease(ExamEnum::DAYS);
  1755.             $exam->setAttemptsTime(null);
  1756.             $exam->setAttemptsPeriod(null);
  1757.             $exam->setShowTemplate(ExamEnum::NO);
  1758.             $exam->setNote(null);
  1759.             $exam->setDateLastNotify(null);
  1761.             $this->em->flush();
  1762.         }
  1763.     }
  1765.     public function restoreByCourse($courseId, $deleted, $typeDelete, $userDelete, $dateNow){
  1766.         $sql = "UPDATE EADPlataforma:Exam AS e 
  1767.                 SET e.deleted = :deleted, e.userDelete = :userDelete, 
  1768.                     e.dateDelete = :dateNow
  1769.                 WHERE e.deleted = (1 - :deleted)
  1770.                 AND e.typeDelete = :typeDelete
  1771.                 AND e.course = :courseId";
  1772.         $query = $this->em->createQuery($sql);
  1773.         $query->setParameter('courseId', $courseId);
  1774.         $query->setParameter('deleted', $deleted);
  1775.         $query->setParameter('typeDelete', $typeDelete);
  1776.         $query->setParameter('userDelete', $userDelete);
  1777.         $query->setParameter('dateNow', $dateNow);
  1778.         $query->execute();
  1779.         
  1780.         return true;
  1781.     }
  1783.     public function deleteByCourse($courseId, $deleted, $typeDelete, $userDelete, $dateNow){
  1784.         $sql = "UPDATE EADPlataforma:Exam AS e 
  1785.                 SET e.deleted = :deleted, e.typeDelete = :typeDelete,
  1786.                     e.userDelete = :userDelete, e.dateDelete = :dateNow
  1787.                 WHERE e.deleted = (:deleted - 1)
  1788.                 AND e.course = :courseId";
  1789.         $query = $this->em->createQuery($sql);
  1790.         $query->setParameter('courseId', $courseId);
  1791.         $query->setParameter('deleted', $deleted);
  1792.         $query->setParameter('typeDelete', $typeDelete);
  1793.         $query->setParameter('userDelete', $userDelete);
  1794.         $query->setParameter('dateNow', $dateNow);
  1795.         $query->execute();
  1796.         
  1797.         return true;
  1798.     }
  1800.     public function restoreByLessonModule($lessonModuleId, $deleted, $typeDelete, $userDelete, $dateNow){
  1801.         $sql = "UPDATE EADPlataforma:Exam AS e 
  1802.                 SET e.deleted = :deleted, e.userDelete = :userDelete, 
  1803.                     e.dateDelete = :dateNow
  1804.                 WHERE e.deleted = (1 - :deleted)
  1805.                 AND e.typeDelete = :typeDelete
  1806.                 AND e.lessonModule = :lessonModuleId";
  1807.         $query = $this->em->createQuery($sql);
  1808.         $query->setParameter('lessonModuleId', $lessonModuleId);
  1809.         $query->setParameter('deleted', $deleted);
  1810.         $query->setParameter('typeDelete', $typeDelete);
  1811.         $query->setParameter('userDelete', $userDelete);
  1812.         $query->setParameter('dateNow', $dateNow);
  1813.         $query->execute();
  1814.         
  1815.         return true;
  1816.     }
  1818.     public function deleteByLessonModule($lessonModuleId, $deleted, $typeDelete, $userDelete, $dateNow){
  1819.         $sql = "UPDATE EADPlataforma:Exam AS e 
  1820.                 SET e.deleted = :deleted, e.typeDelete = :typeDelete,
  1821.                     e.userDelete = :userDelete, e.dateDelete = :dateNow
  1822.                 WHERE e.deleted = (:deleted - 1)
  1823.                 AND e.lessonModule = :lessonModuleId";
  1824.         $query = $this->em->createQuery($sql);
  1825.         $query->setParameter('lessonModuleId', $lessonModuleId);
  1826.         $query->setParameter('deleted', $deleted);
  1827.         $query->setParameter('typeDelete', $typeDelete);
  1828.         $query->setParameter('userDelete', $userDelete);
  1829.         $query->setParameter('dateNow', $dateNow);
  1830.         $query->execute();
  1831.         
  1832.         return true;
  1833.     }
  1835.     public function restoreByLesson($lessonId, $deleted, $typeDelete, $userDelete, $dateNow){
  1836.         $sql = "UPDATE EADPlataforma:Exam AS e 
  1837.                 SET e.deleted = :deleted, e.userDelete = :userDelete, 
  1838.                     e.dateDelete = :dateNow
  1839.                 WHERE e.deleted = (1 - :deleted)
  1840.                 AND e.typeDelete = :typeDelete
  1841.                 AND e.lesson = :lessonId";
  1842.         $query = $this->em->createQuery($sql);
  1843.         $query->setParameter('lessonId', $lessonId);
  1844.         $query->setParameter('deleted', $deleted);
  1845.         $query->setParameter('typeDelete', $typeDelete);
  1846.         $query->setParameter('userDelete', $userDelete);
  1847.         $query->setParameter('dateNow', $dateNow);
  1848.         $query->execute();
  1849.         
  1850.         return true;
  1851.     }
  1853.     public function deleteByLesson($lessonId, $deleted, $typeDelete, $userDelete, $dateNow){
  1854.         $sql = "UPDATE EADPlataforma:Exam AS e 
  1855.                 SET e.deleted = :deleted, e.typeDelete = :typeDelete,
  1856.                     e.userDelete = :userDelete, e.dateDelete = :dateNow
  1857.                 WHERE e.deleted = (:deleted - 1)
  1858.                 AND e.lesson = :lessonId";
  1859.         $query = $this->em->createQuery($sql);
  1860.         $query->setParameter('lessonId', $lessonId);
  1861.         $query->setParameter('deleted', $deleted);
  1862.         $query->setParameter('typeDelete', $typeDelete);
  1863.         $query->setParameter('userDelete', $userDelete);
  1864.         $query->setParameter('dateNow', $dateNow);
  1865.         $query->execute();
  1866.         
  1867.         return true;
  1868.     }
  1870.     public function deleteTrashCron()
  1871.     {
  1872.         $sql = "UPDATE EADPlataforma:Exam AS e 
  1873.                 SET e.deleted = 2 WHERE e.dateDelete <= :date AND e.deleted = 1 ";
  1874.         $query = $this->em->createQuery($sql);
  1875.         $query->setParameter('date', date('Y-m-d H:i:s', strtotime('-90 days')));
  1876.         $query->execute();
  1877.     }
  1878. }