src/Repository/ExamRepository.php line 165

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 getExamTypeText($type)
  53.     {
  54.         $examTypeText = '';
  55.         switch ($type) {
  56.             case ExamEnum::LESSON:
  57.                 $examTypeText = $this->configuration->getLanguage('lesson', 'export');
  58.                 break;
  59.             case ExamEnum::MODULE:
  60.                 $examTypeText = $this->configuration->getLanguage('module', 'export');
  61.                 break;
  62.             case ExamEnum::COURSE:
  63.                 $examTypeText = $this->configuration->getLanguage('course', 'export');
  64.                 break;
  65.         }
  67.         return $examTypeText;
  68.     }
  70.     public function notifyStudentsExam(Exam $exam)
  71.     {   
  72.         $today = date('Y-m-d');
  73.         $dateLastNotify = $exam->getDateLastNotify('Y-m-d');
  75.         if($today != $dateLastNotify){
  76.             $course = $exam->getCourse();
  77.             $lessonModule = $exam->getLessonModule();
  78.             $lesson = $exam->getLesson();
  80.             if(
  81.                 $course->getStatus() == CourseEnum::PUBLISHED && 
  82.                 $exam->getStatus() == ExamEnum::PUBLISHED
  83.             ){
  84.                 $taskQueueService = $this->generalService->getService('TaskQueueService');
  85.                 $enrollmentRepository = $this->em->getRepository(Enrollment::class);
  86.                 
  87.                 $users = $this->getUsersNotStartExam($exam);
  89.                 foreach ($users as $key => $user) {
  90.                     $taskQueueService->insert(TaskQueueEnum::EMAIL_NEW_EXAM, $user, $exam->getId());
  91.                 }
  93.                 $exam->setDateLastNotify(date('Y-m-d H:i:s'));
  94.                 $this->em->flush();
  95.             }
  96.         }
  97.     }
  99.     public function getUsersNotStartExam(Exam $exam)
  100.     {
  101.         $userRepository = $this->em->getRepository(User::class);
  103.         $query = $userRepository->createQueryBuilder('u');
  105.         $query->innerJoin('EADPlataforma:Enrollment', 'e', 'WITH', 'e.user = u.id');
  106.         $query->andWhere('u.deleted = :deleted');
  107.         $query->andWhere('e.course = :course');
  108.         $query->andWhere('e.status = :enrollmentStatus');
  109.         $query->andWhere('e.deleted = :enrollmentDeleted');
  110.         $query->andWhere('e.datePeriod >= :now');
  112.         $subQuery = $userRepository->createQueryBuilder('examUser');
  113.         $subQuery->select('IDENTITY(eu.user)');
  114.         $subQuery->from('EADPlataforma:ExamUser', 'eu');
  115.         $subQuery->andWhere('eu.exam = :exam');
  116.         $subQuery->andWhere('eu.course = :course');
  117.         $subQuery = $subQuery->getDQL();
  119.         $query->andWhere($query->expr()->notIn('u.id', $subQuery));
  121.         $subQuery = $userRepository->createQueryBuilder('certificate');
  122.         $subQuery->select('IDENTITY(cc.user)');
  123.         $subQuery->from('EADPlataforma:CourseCertificate', 'cc');
  124.         $subQuery->andWhere('cc.course = :course');
  125.         $subQuery = $subQuery->getDQL();
  127.         $query->andWhere($query->expr()->notIn('u.id', $subQuery));
  129.         $query->setParameter('deleted', UserEnum::ITEM_NO_DELETED);
  130.         $query->setParameter('course', $exam->getCourse()->getId());
  131.         $query->setParameter('enrollmentStatus', EnrollmentEnum::STATUS_ACTIVE);
  132.         $query->setParameter('enrollmentDeleted', EnrollmentEnum::ITEM_NO_DELETED);
  133.         $query->setParameter('now', date('Y-m-d H:i:s'));
  134.         $query->setParameter('exam', $exam->getId());
  136.         return $query->getQuery()->execute();
  137.     }
  138.     
  139.     public function isExamTeacher(Exam $exam, User $user)
  140.     {
  141.         $lesson = $exam->getLesson();
  142.         $lessonModule = $exam->getLessonModule();
  143.         $course = $exam->getCourse();
  144.         $isTeacher = false;
  145.         $uId = $user->getId();
  147.         if($course){
  148.             $isTeacher = ($course->getUser()->getId() == $uId);
  150.             if($lesson && !$isTeacher){
  151.                 $lessonTeahcerId = $lesson->getUser()->getId();
  152.                 $lessonModuleTeahcerId = $lesson->getLessonModule()->getUser()->getId();
  154.                 $isTeacher = ($lessonTeahcerId == $uId || $lessonModuleTeahcerId == $uId);
  155.             }else if($lessonModule && !$isTeacher){
  156.                 $lessonModuleTeahcerId = $lessonModule->getUser()->getId();
  158.                 $isTeacher = ($lessonModuleTeahcerId == $uId);
  159.             }
  160.         }
  162.         return $isTeacher;
  163.     }
  165.     public function getExamToIndexNew(
  166.         int $type, 
  167.         Course $course,
  168.         ?LessonModule $lessonModule = null, 
  169.         ?Lesson $lesson = null
  170.     )
  171.     {
  172.         $filter = [
  173.             "course" => $course->getId(),
  174.             "type" => $type,
  175.             "status" => ExamEnum::PUBLISHED,
  176.             "deleted" => ExamEnum::ITEM_NO_DELETED
  177.         ];
  179.         if(!empty($lessonModule)){
  180.             $filter["lessonModule"] = $lessonModule->getId();
  181.         }
  183.         if(!empty($lesson)){
  184.             $filter["lesson"] = $lesson->getId();
  185.         }
  187.         $e = $this->findOneBy($filter);
  188.         $examUser = null;
  190.         if($e && !empty($e->getQuestionNumber())){
  191.             $examUserData = null;
  192.             if($this->getUser()){
  194.                 $examUserRepository = $this->em->getRepository(ExamUser::class);
  195.                 $examUser = $examUserRepository->findOneBy([
  196.                     "user" => $this->getUser()->getId(),
  197.                     "exam" => $e->getId(),
  198.                     "inactive" => ExamUserEnum::NO,
  199.                     "deleted" => ExamUserEnum::ITEM_NO_DELETED
  200.                 ]);
  201.             }
  203.             $infoAccess = $this->checkExamIsAccessible($e, $examUser);
  205.             $data = [
  206.                 "id" => $e->getId(),
  207.                 "title" => $e->getTitle(),
  208.                 "type" => $e->getType(),
  209.                 "status" => (
  210.                     $examUser ? 
  211.                     $examUser->getStatus() : 
  212.                     ExamUserEnum::NOT_STARTED
  213.                 ),
  214.                 "examWeight" => $e->getExamWeight(),
  215.                 "examTime" => $e->getExamTime(),
  216.                 "questionNumber" => $e->getQuestionNumber(),
  217.                 "isAccessible" => $infoAccess->isAccessible,
  218.                 "acessMessage" => $infoAccess->message,
  219.                 "dateReleaseAccess" => $infoAccess->dateRelease,
  220.                 "dateCloseAccess" => $infoAccess->dateClose,
  221.             ];
  223.             return $data;
  224.         }
  226.         return;
  227.     }
  229.     public function getExamToIndex(int $type, Course $course, 
  230.                                    ?LessonModule $lessonModule = null, 
  231.                                    ?Lesson $lesson = null)
  232.     {
  233.         $filter = [
  234.             "course" => $course->getId(),
  235.             "type" => $type,
  236.             "status" => ExamEnum::PUBLISHED,
  237.             "deleted" => ExamEnum::ITEM_NO_DELETED
  238.         ];
  240.         if(!empty($lessonModule)){
  241.             $filter["lessonModule"] = $lessonModule->getId();
  242.         }
  244.         if(!empty($lesson)){
  245.             $filter["lesson"] = $lesson->getId();
  246.         }
  248.         $e = $this->findOneBy($filter);
  249.         $examUser = null;
  251.         if($e && !empty($e->getQuestionNumber())){
  253.             $examUserData = null;
  254.             if($this->getUser()){
  256.                 $examUserRepository = $this->em->getRepository(ExamUser::class);
  257.                 $examUser = $examUserRepository->findOneBy([
  258.                     "user" => $this->getUser()->getId(),
  259.                     "exam" => $e->getId(),
  260.                     "inactive" => ExamUserEnum::NO,
  261.                     "deleted" => ExamUserEnum::ITEM_NO_DELETED
  262.                 ]);
  264.                 if($examUser){
  265.                     $dateTimeUtil = $this->generalService->getUtil('DateTimeUtil');
  267.                     $todaySeconds = strtotime(date('Y-m-d H:i:s'));
  268.                     $dateStartSeconds = strtotime($examUser->getDateStart());
  269.                     $timeSeconds = $dateTimeUtil->timeToSec($e->getExamTime());
  271.                     $dateExamEndSecods = $dateStartSeconds + $timeSeconds;
  272.                     $timeRestToEndSeconds = $timeSeconds;
  273.                     if($examUser->getStatus() == ExamUserEnum::IN_PROGRESS){
  274.                         $timeRestToEndSeconds = $dateExamEndSecods - $todaySeconds;
  275.                         if($timeRestToEndSeconds < 0){
  276.                             $timeRestToEndSeconds = 0;
  277.                         }
  278.                     }
  280.                     $progress = 100;
  281.                     $qNumber = $e->getQuestionNumber();
  282.                     
  283.                     if(
  284.                         $examUser->getStatus() == ExamUserEnum::IN_PROGRESS || 
  285.                         $examUser->getStatus() == ExamUserEnum::TIMEOUT
  286.                     ){
  287.                         $euAnswerRepository = $this->em->getRepository(ExamUserAnswer::class);
  289.                         $qNumber = $euAnswerRepository->countAsnweredByExamUser(
  290.                             $examUser
  291.                         );
  293.                         $progress = round($qNumber * 100 / $e->getQuestionNumber());
  294.                     }
  296.                     $examUserData = (object)[
  297.                         "id" => $examUser->getId(),
  298.                         "status" => $examUser->getStatus(),
  299.                         "grade" => $examUser->getGrade(),
  300.                         "timeRestToEnd" => $dateTimeUtil->secToTime($timeRestToEndSeconds),
  301.                         "timeRestToEndSeconds" => $timeRestToEndSeconds,
  302.                         "dateStart" => $examUser->getDateStart('Y-m-d H:i:s'),
  303.                         "questionAnswerNumber" => $qNumber,
  304.                         "progress" => $progress
  305.                     ];
  306.                 }
  307.             }
  309.             $infoAccess = $this->checkExamIsAccessible($e, $examUser);
  311.             $data = [
  312.                 "id" => $e->getId(),
  313.                 "courseId" => $e->getCourse()->getId(),
  314.                 "lessonModuleId" => (
  315.                     $e->getLessonModule() ? $e->getLessonModule()->getId() : null
  316.                 ),
  317.                 "lessonId" => ($e->getLesson() ? $e->getLesson()->getId() : null),
  318.                 "title" => $e->getTitle(),
  319.                 "type" => $e->getType(),
  320.                 "examWeight" => $e->getExamWeight(),
  321.                 "examTime" => $e->getExamTime(),
  322.                 "questionNumber" => $e->getQuestionNumber(),
  323.                 "isAccessible" => $infoAccess->isAccessible,
  324.                 "dateReleaseAccess" => $infoAccess->dateRelease,
  325.                 "dateCloseAccess" => $infoAccess->dateClose,
  326.                 "examUser" => $examUserData,
  327.             ];
  329.             return $data;
  330.         }
  332.         return;
  333.     }
  335.     public function getExamByQuestions(Question $question)
  336.     {
  337.         $questionId = $question->getId();
  339.         $query = $this->createQueryBuilder('e');
  341.         $query->innerJoin(
  342.             'EADPlataforma:Question', 
  343.             'q', 
  344.             'WITH', 
  345.             'e MEMBER OF q.exam AND q.id = :questionId'
  346.         );
  348.         $query->setParameter('questionId', $questionId);
  349.         $query->andWhere('e.deleted = :deleted');
  350.         $query->setParameter('deleted', ExamEnum::ITEM_NO_DELETED);
  352.         return $query->getQuery()->execute();
  353.     }
  355.     public function counterExamAndQuiz(Question $question){
  356.         $quantityQuiz = 0;
  358.         $examIds = $question->toReturn()["exam"];
  359.         $quantityExam = count($question->toReturn()["exam"]);
  361.         $exams = $this->findBy([
  362.             "id" => $examIds
  363.         ]);
  364.         
  365.         foreach ($exams as $exam) {
  366.             if($exam->getType() == ExamEnum::QUIZ) {
  367.                 $quantityQuiz++;
  368.                 $quantityExam--;
  369.             }
  370.         }
  372.         $counters = [
  373.             "quantityQuiz" => $quantityQuiz,
  374.             "quantityExam" => $quantityExam
  375.         ];
  377.         return $counters;
  378.     }
  379.     public function checkExamIsAccessible(Exam $exam, ?ExamUser $examUser = null){
  381.         $info = (object)[
  382.             "isAccessible" => false,
  383.             "dateRelease" => null,
  384.             "dateClose" => null,
  385.             "message" => null,
  386.         ];
  388.         $typeRelease = $exam->getTypeRelease();
  389.         if($typeRelease == ExamEnum::FIXED_DATE){
  390.             $dateStart = $exam->getDateStart();
  391.             $info->dateRelease = $dateStart;
  392.         }
  394.         if(!$this->getUser()){
  395.             $info->message = $this->configuration->getLanguage('error_auth', 'lesson_view_error');
  397.             return $info;
  398.         }
  400.         $lessonRepository = $this->em->getRepository(Lesson::class);
  401.         $logRepository = $this->em->getRepository(LessonLogOrigin::class);
  402.         $lessonLogRepository = $this->emEadmin->getRepository(LessonLog::class);
  403.         $courseRepository = $this->em->getRepository(Course::class);
  404.         $examUserRepository = $this->em->getRepository(ExamUser::class);
  406.         if(empty($examUser)){
  407.             $examUser = $examUserRepository->findOneBy([
  408.                 "user" => $this->getUser()->getId(),
  409.                 "exam" => $exam->getId(),
  410.                 "inactive" => ExamUserEnum::NO,
  411.                 "deleted" => ExamUserEnum::ITEM_NO_DELETED
  412.             ]);
  413.         }
  415.         if(!empty($examUser)){
  416.             $info->isAccessible = true;
  417.             return $info;
  418.         }
  420.         $today = date('Y-m-d');
  421.         $todayDateTime = date('Y-m-d H:i:s');
  422.         $course = $exam->getCourse();
  423.         $isStudent = $courseRepository->isStudent($course);
  424.         if(!$isStudent){
  425.             $info->isAccessible = true;
  426.             return $info;
  427.         }
  429.         $lesson = null;
  430.         $hasLessonControl = $this->configuration->checkModuleIsAbleOnPlan(
  431.             'lessonControlFunction'
  432.         );
  434.         $lessonNumber = $lessonRepository->getLessonPublicNumber($course);
  435.         $lessonNumberModule = $lessonNumber;
  437.         if(empty($lessonNumber)){
  438.             $info->isAccessible = true;
  439.             return $info;
  440.         }
  442.         if(!$hasLessonControl && $exam->getType() != ExamEnum::QUIZ){
  443.             $lessonsNumberComplete = $logRepository->count([
  444.                 "complete" => LessonEnum::YES,
  445.                 "course" => $course->getId(),
  446.                 "user" => $this->getUser()->getId()
  447.             ]);
  449.             if($lessonsNumberComplete >= $lessonNumber){
  450.                 $info->isAccessible = true;
  451.                 return $info;
  452.             }
  453.         }else if($exam->getType() == ExamEnum::COURSE){
  454.             $lesson = $lessonRepository->getLastLesson($course);
  456.             $lessonNumberRequired = $lessonRepository->getLessonPublicNumber(
  457.                 $course, 
  458.                 null, 
  459.                 true
  460.             );
  462.             $lessonsNumberComplete = $logRepository->countLessonLogOriginCompleteRequired(
  463.                 $this->getUser(), 
  464.                 $course
  465.             );
  467.             if($lessonsNumberComplete < $lessonNumberRequired){
  469.                 $info->message = $this->configuration->getLanguage(
  470.                     'error_required_incomplete', 
  471.                     'lesson_view_error'
  472.                 );
  474.                 return $info;
  475.             }
  476.         }else if($exam->getType() == ExamEnum::MODULE){
  477.             $lesson = $lessonRepository->getLastLesson($course, $exam->getLessonModule());
  479.             $lessonNumberRequired = $lessonRepository->getLessonPublicNumber(
  480.                 $course, 
  481.                 $exam->getLessonModule(), 
  482.                 true
  483.             );
  485.             $lessonNumberModule = $lessonRepository->getLessonPublicNumber(
  486.                 $course, 
  487.                 $exam->getLessonModule(),
  488.                 false,
  489.                 true
  490.             );
  492.             $lessonsNumberComplete = $logRepository->countLessonLogOriginCompleteRequired(
  493.                 $this->getUser(), 
  494.                 $course,
  495.                 $exam->getLessonModule()
  496.             );
  498.             if($lessonsNumberComplete < $lessonNumberRequired){
  500.                 $info->message = $this->configuration->getLanguage(
  501.                     'error_required_incomplete', 
  502.                     'lesson_view_error'
  503.                 );
  505.                 return $info;
  506.             }
  508.         }else if($exam->getType() == ExamEnum::LESSON){
  509.             $lesson = $exam->getLesson();
  510.         }else if($exam->getType() == ExamEnum::QUIZ){
  511.             $lesson = $exam->getLesson();
  512.         }
  514.         if($lesson && $hasLessonControl){
  515.             $currentLesson = $lessonRepository->getCurrentLesson($lesson, $this->getUser());
  516.             
  517.             if(empty($currentLesson)){
  519.                 if(empty($examUser)){
  520.                     $currentExam = $examUserRepository->getCurrentExamOnCourseToUserByLesson(
  521.                         $lesson, 
  522.                         $this->getUser()
  523.                     );
  524.                     
  525.                     if($currentExam && $currentExam->getId() != $exam->getId()){
  526.                         if($exam->getType() != ExamEnum::QUIZ){
  528.                             $info->message = $this->configuration->getLanguage(
  529.                                 'error_required_incomplete', 
  530.                                 'lesson_view_error'
  531.                             );
  533.                             return $info;
  534.                         }
  535.                     }
  536.                 }
  537.                 
  538.                 $logId = "{$course->getId()}#{$this->getUser()->getId()}#{$lesson->getId()}";
  539.                 $log = $lessonLogRepository->find($logId);
  541.                 if($lesson->getControlRequirement() == LessonEnum::YES){
  542.                     if(!$log || ($log && empty($log->getDateConclusion()))){
  544.                         $info->message = $this->configuration->getLanguage(
  545.                             'error_required_incomplete', 
  546.                             'lesson_view_error'
  547.                         );
  549.                         return $info;
  550.                     }
  551.                 }
  552.                 
  553.                 $dateReference = ($log ? $log->getDateConclusion() : null);
  555.                 if($typeRelease == ExamEnum::FIXED_DATE){
  556.                     $dateStart = $exam->getDateStart();
  557.                     if($dateStart > $todayDateTime){
  558.                         $info->dateRelease = $dateStart;
  560.                         $info->message = "{$this->configuration->getLanguage(
  561.                             'error_date_release', 
  562.                             'lesson_view_error'
  563.                         )} {$exam->getDateStart('d/m/Y H:i:s')}";
  565.                         return $info;
  566.                     }
  567.                    
  568.                 }else if($typeRelease == ExamEnum::FLEXIBLE_PERIOD){
  569.                     if(empty($dateReference)){
  571.                         $info->message = $this->configuration->getLanguage(
  572.                             'error_required_incomplete', 
  573.                             'lesson_view_error'
  574.                         );
  576.                         return $info;
  577.                     }
  579.                     $textDate = "{$dateReference} + {$exam->getPeriodStart()} days";
  580.                     $dateStart = date('Y-m-d', strtotime($textDate));
  582.                     if($dateStart > $today){
  583.                         $info->dateRelease = $dateStart;
  585.                         $dateStartText = date('d/m/Y H:i:s', strtotime($textDate));
  586.                         $info->message = "{$this->configuration->getLanguage(
  587.                             'error_date_release', 
  588.                             'lesson_view_error'
  589.                         )} {$dateStartText}";
  591.                         return $info;
  592.                     }
  593.                 }
  595.                 $periodEnd = $exam->getPeriodEnd();
  596.                 if(!empty($periodEnd)){
  598.                     if($typeRelease == ExamEnum::FIXED_DATE){
  599.                         $dateReference = $exam->getDateStart();
  600.                     }
  601.                     
  602.                     if(empty($dateReference) && $typeRelease != ExamEnum::RELEASED){
  604.                         $info->message = $this->configuration->getLanguage(
  605.                             'error_required_incomplete', 
  606.                             'lesson_view_error'
  607.                         );
  609.                         return $info;
  610.                     }
  612.                     $textDate = "{$dateReference} + {$periodEnd} days";
  613.                     $dateEnd = date('Y-m-d', strtotime($textDate));
  615.                     if($dateEnd < $today){
  616.                         if(empty($examUser)){
  618.                             $dateEndText = date('d/m/Y H:i:s', strtotime($textDate));
  620.                             $info->dateClose = $dateEnd;
  622.                             $info->message = "{$this->configuration->getLanguage(
  623.                                 'error_date_end', 
  624.                                 'lesson_view_error'
  625.                             )} {$dateEndText}";
  627.                             return $info;
  628.                         }
  629.                     }
  630.                 }
  632.                 $info->isAccessible = true;
  633.                 return $info;
  634.             }
  636.         }else if(empty($lessonNumber) || empty($lessonNumberModule) || !$hasLessonControl){
  637.             if($typeRelease == ExamEnum::FIXED_DATE){
  638.                 $dateStart = $exam->getDateStart();
  639.                 if($dateStart > $todayDateTime){
  640.                     $info->dateRelease = $dateStart;
  642.                     $info->message = "{$this->configuration->getLanguage(
  643.                         'error_date_release', 
  644.                         'lesson_view_error'
  645.                     )} {$exam->getDateStart('d/m/Y H:i:s')}";
  647.                     return $info;
  648.                 }
  650.                 $info->isAccessible = true;
  651.                 return $info;
  652.             }
  653.             //else if($typeRelease == ExamEnum::FLEXIBLE_PERIOD){
  654.             //}
  656.             $periodEnd = $exam->getPeriodEnd();
  657.             if(!empty($periodEnd)){
  659.                 $dateReference = null;
  660.                 if($typeRelease == ExamEnum::FIXED_DATE){
  661.                     $dateReference = $exam->getDateStart();
  662.                 }
  663.                 
  664.                 if(empty($dateReference) && $typeRelease != ExamEnum::RELEASED){
  666.                     $info->message = $this->configuration->getLanguage(
  667.                         'error_required_incomplete', 
  668.                         'lesson_view_error'
  669.                     );
  671.                     return $info;
  672.                 }
  674.                 /*$textDate = "{$dateReference} + {$periodEnd} days";
  675.                 $dateEnd = date('Y-m-d', strtotime($textDate));
  677.                 if($dateEnd < $today){
  678.                     if(empty($examUser)){
  679.                         $info->dateClose = $dateEnd;
  680.                         return $info;
  681.                     }
  682.                 }*/
  683.             }
  685.             $info->isAccessible = true;
  686.             
  687.             return $info;
  688.         }
  689.         return $info;
  690.     }
  692.     public function getExamNumberByProduct(Product $product)
  693.     {
  694.         $query = $this->createQueryBuilder('e');
  695.         $query->select("COUNT(e.id) AS total");
  696.         $query->innerJoin('EADPlataforma:Product', 'p', 'WITH', 'e.course MEMBER OF p.course');
  697.         $query->andWhere('e.deleted = :deleted');
  698.         $query->andWhere('e.status = :examStatus');
  699.         $query->andWhere('p.id = :productId');
  701.         $query->setParameter('deleted', ExamEnum::ITEM_NO_DELETED);
  702.         $query->setParameter('examStatus', ExamEnum::PUBLISHED);
  703.         $query->setParameter('productId', $product->getId());
  704.               
  705.         $result = (object)$query->getQuery()->getOneOrNullResult();
  706.         return $result->total;
  707.     }
  709.     public function getNextExamIdByLesson(Lesson $lesson, bool $addTitle = false)
  710.     {
  711.         $lessonRepository = $this->em->getRepository(Lesson::class);
  712.         $course = $lesson->getCourse();
  713.         $lessonModule = $lesson->getLessonModule();
  715.         $addExams = false;
  716.         $addExamsLimited = false;
  718.         if(
  719.             $this->configuration->isModuleActive("exam_module") &&
  720.             $this->configuration->checkModuleIsAbleOnPlan("examFunction")
  721.             
  722.         ){
  723.             $addExams = true;
  724.             $addExamsLimited = $this->configuration->checkModuleIsAbleOnPlan(
  725.                 "unlimitedExamFunction"
  726.             );
  727.         }
  729.         $exam = $this->findOneBy([
  730.             "deleted" => ExamEnum::ITEM_NO_DELETED,
  731.             "course" => $course->getId(),
  732.             "lessonModule" => $lessonModule->getId(),
  733.             "lesson" => $lesson->getId(),
  734.             "status" => ExamEnum::PUBLISHED,
  735.             "type" => ExamEnum::QUIZ
  736.         ]);
  738.         if(!$exam){
  739.             if(!$addExams || !$addExamsLimited){
  740.                 return;
  741.             }
  743.             $exam = $this->findOneBy([
  744.                 "deleted" => ExamEnum::ITEM_NO_DELETED,
  745.                 "course" => $course->getId(),
  746.                 "lessonModule" => $lessonModule->getId(),
  747.                 "lesson" => $lesson->getId(),
  748.                 "status" => ExamEnum::PUBLISHED,
  749.                 "type" => ExamEnum::LESSON
  750.             ]);
  751.         }
  753.         if(!$exam && $lessonRepository->isLastModuleLesson($lesson)){
  754.             if(!$addExams || !$addExamsLimited){
  755.                 return;
  756.             }
  758.             $exam = $this->findOneBy([
  759.                 "deleted" => ExamEnum::ITEM_NO_DELETED,
  760.                 "course" => $course->getId(),
  761.                 "lessonModule" => $lessonModule->getId(),
  762.                 "status" => ExamEnum::PUBLISHED,
  763.                 "type" => ExamEnum::MODULE
  764.             ]);
  765.         }
  767.         if(!$exam && $lessonRepository->isLastCourseLesson($lesson)){
  769.             if(!$addExams){
  770.                 return;
  771.             }
  773.             $exam = $this->findOneBy([
  774.                 "deleted" => ExamEnum::ITEM_NO_DELETED,
  775.                 "course" => $course->getId(),
  776.                 "status" => ExamEnum::PUBLISHED,
  777.                 "type" => ExamEnum::COURSE
  778.             ]);
  779.         }
  781.         if($exam){
  782.             if($addTitle){
  783.                 return (object)[ 
  784.                     "id" => $exam->getId(), 
  785.                     "title" => $exam->getTitle(),
  786.                     "courseId" => $exam->getCourse()->getId(),
  787.                     "moduleId" => (
  788.                         $exam->getLessonModule() ?
  789.                         $exam->getLessonModule()->getId() :
  790.                         null
  791.                     ),
  792.                     "moduleTitle" => (
  793.                         $exam->getLessonModule() ?
  794.                         $exam->getLessonModule()->getTitle() :
  795.                         null
  796.                     ),
  797.                     "lessonId" => (
  798.                         $exam->getLesson() ?
  799.                         $exam->getLesson()->getId() :
  800.                         null
  801.                     ),
  802.                     "type" => $exam->getType(),
  803.                 ];
  804.             }
  806.             return $exam->getId();
  807.         }
  808.         return;
  809.     }
  811.     public function getCurrentNotStartedExamUser(Lesson $lessonBase, User $user){
  813.         $query = $this->createQueryBuilder('e');
  815.         $query->leftJoin(
  816.             'EADPlataforma:LessonModule', 
  817.             'lm', 
  818.             'WITH', 
  819.             'lm.id = e.lessonModule'
  820.         );
  822.         $query->leftJoin(
  823.             'EADPlataforma:Lesson', 
  824.             'l', 
  825.             'WITH', 
  826.             'l.id = e.lesson'
  827.         );
  829.         $query->andWhere('e.course = :course');
  830.         $query->andWhere('e.requirement = :yes');
  831.         $query->andWhere('e.status = :statusExam');
  832.         $query->andWhere('(
  833.             (
  834.                 e.type = :typeLesson 
  835.                 AND l.deleted = :lDeleted 
  836.                 AND l.status = :lStatus
  837.                 AND lm.status = :lmStatus
  838.             ) OR 
  839.             (
  840.                 e.type = :typeModule 
  841.                 AND lm.deleted = :lmDeleted 
  842.                 AND lm.status = :lmStatus
  843.             )
  844.         )');
  846.         $query->andWhere('(
  847.             ( l.order <= :orderL AND lm.order = :orderLM ) OR 
  848.             ( lm.order < :orderLM )
  849.         )');
  850.         $query->andWhere('e.deleted = :deleted');
  852.         $course = $lessonBase->getCourse();
  853.         $lessonModule = $lessonBase->getLessonModule();
  855.         $subQuery = $this->createQueryBuilder('examUser');
  856.         $subQuery->select('IDENTITY(eu.exam)');
  857.         $subQuery->from('EADPlataforma:ExamUser', 'eu');
  858.         $subQuery->andWhere('eu.course = :course');
  859.         $subQuery->andWhere('eu.deleted = :deletedExamUser');
  860.         $subQuery->andWhere('eu.status = :statusAproved OR eu.releaseAccess = :yes');
  861.         $subQuery->andWhere('eu.user = :user');
  862.         $subQuery = $subQuery->getDQL();
  864.         $query->andWhere($query->expr()->notIn('e.id', $subQuery));
  866.         $secondsDay = 24 * 60 * 60;
  868.         $query->andWhere("
  869.             (e.periodEnd IS NULL OR e.periodEnd = :no) OR
  870.             (
  871.                 ( e.typeRelease = :typeStartReleased )
  872.                 OR
  873.                 (
  874.                     e.typeRelease = :typeStartFixedDate
  875.                     AND TIME_TO_SEC(e.dateStart) <=  TIME_TO_SEC(:now)
  876.                     AND (
  877.                         TIME_TO_SEC(e.dateStart) + (e.periodEnd * {$secondsDay})
  878.                     ) >= TIME_TO_SEC(:now)
  879.                 )
  880.                 OR
  881.                 (
  882.                     e.typeRelease = :typeStartFlexPeriod
  883.                 )
  884.             )
  885.         ");
  887.         /* !!!
  889.             $caseDate = "CASE 
  890.                         WHEN e.type = :typeLesson
  891.                             AND (
  892.                                     SELECT 
  893.                                         lg.id
  894.                                     FROM EADPlataforma:LessonLogOrigin AS lg
  895.                                     WHERE lg.user = :user
  896.                                     AND lg.lesson = e.lesson
  897.                                     AND lg.complete = :completed
  898.                                     LIMIT 1 
  899.                                 ) > 0 
  900.                         THEN
  901.                             (   
  902.                                 SELECT 
  903.                                     lg.dateConclusion 
  904.                                 FROM EADPlataforma:LessonLogOrigin AS lg
  905.                                 WHERE lg.user = :user
  906.                                 AND lg.lesson = e.lesson
  907.                                 AND lg.complete = :completed
  908.                                 LIMIT 1
  909.                             )
  910.                         WHEN e.type = :typeModule
  911.                              AND (   
  912.                                 SELECT 
  913.                                     lg.id
  914.                                 FROM EADPlataforma:LessonLogOrigin AS lg
  915.                                 WHERE lg.user = :user
  916.                                 AND lg.complete = :completed
  917.                                 AND lg.lesson = (
  918.                                     SELECT
  919.                                         le.aula_id 
  920.                                     FROM EADPlataforma:Lesson AS le
  921.                                     WHERE le.lessonModule = e.lessonModule 
  922.                                     AND le.status = :statusL
  923.                                     AND le.deleted = 0
  924.                                     ORDER BY le.order DESC LIMIT 1
  925.                                 )
  926.                                 LIMIT 1
  927.                             ) > 0 
  928.                         THEN
  929.                             (   
  930.                                 SELECT 
  931.                                     lg.dateConclusion
  932.                                 FROM EADPlataforma:LessonLogOrigin AS lg
  933.                                 WHERE lg.user = :user
  934.                                 AND lg.complete = :completed
  935.                                 AND lg.lesson = (
  936.                                     SELECT
  937.                                         le.aula_id 
  938.                                     FROM EADPlataforma:Lesson AS le
  939.                                     WHERE le.lessonModule = e.lessonModule 
  940.                                     AND le.status = :statusL
  941.                                     AND le.deleted = 0
  942.                                     ORDER BY le.order DESC LIMIT 1
  943.                                 )
  944.                                 LIMIT 1
  945.                             )
  946.                         ELSE
  947.                             '0000-00-00 00:00:00'
  948.                     END";
  950.         $caseLogId = "CASE 
  951.                         WHEN e.type = :typeLesson
  952.                         THEN
  953.                             (   
  954.                                 SELECT 
  955.                                     lg.id
  956.                                 FROM EADPlataforma:LessonLogOrigin AS lg
  957.                                 WHERE lg.user = :user
  958.                                 AND lg.lesson = e.lesson
  959.                                 AND lg.complete = :completed
  960.                                 LIMIT 1 
  961.                             )
  962.                         WHEN e.type = :typeModule
  963.                         THEN
  964.                             (   
  965.                                 SELECT 
  966.                                     lg.id
  967.                                 FROM EADPlataforma:LessonLogOrigin AS lg
  968.                                 WHERE lg.user = :user
  969.                                 AND lg.complete = :completed
  970.                                 AND lg.lesson = (
  971.                                     SELECT
  972.                                         le.aula_id 
  973.                                     FROM EADPlataforma:Lesson AS le
  974.                                     WHERE le.lessonModule = e.lessonModule 
  975.                                     AND le.status = :statusL
  976.                                     AND le.deleted = 0
  977.                                     ORDER BY le.order DESC LIMIT 1
  978.                                 )
  979.                                 LIMIT 1
  980.                             )
  981.                         ELSE 0
  982.                     END";
  983.                     
  984.             AND (1) > 0
  985.             AND (
  986.                 TIME_TO_SEC({$caseDate}) + (e.periodStart * {$secondsDay})
  987.             ) <= TIME_TO_SEC(:now)
  988.             AND (
  989.                 TIME_TO_SEC({$caseDate}) + (e.periodEnd * {$secondsDay})
  990.             ) >= TIME_TO_SEC(:now)
  991.         */
  993.         $query->setParameter('lmDeleted', LessonModuleEnum::ITEM_NO_DELETED);
  994.         $query->setParameter('lmStatus', LessonModuleEnum::PUBLISHED);
  995.         $query->setParameter('lDeleted', LessonEnum::ITEM_NO_DELETED);
  996.         $query->setParameter('lStatus', LessonEnum::PUBLISHED);
  998.         $query->setParameter('now', date('Y-m-d H:i:s'));
  999.         $query->setParameter('typeStartReleased', ExamEnum::RELEASED);
  1000.         $query->setParameter('typeStartFixedDate', ExamEnum::FIXED_DATE);
  1001.         $query->setParameter('typeStartFlexPeriod', ExamEnum::FLEXIBLE_PERIOD);
  1003.         $query->setParameter('course', $course->getId());
  1004.         $query->setParameter('user', $user->getId());
  1005.         $query->setParameter('yes', ExamEnum::YES);
  1006.         $query->setParameter('no', ExamEnum::NO);
  1007.         $query->setParameter('statusAproved', ExamUserEnum::APPROVED);
  1008.         $query->setParameter('statusExam', ExamEnum::PUBLISHED);
  1009.         $query->setParameter('typeModule', ExamEnum::MODULE);
  1010.         $query->setParameter('typeLesson', ExamEnum::LESSON);
  1011.         $query->setParameter('orderL', $lessonBase->getOrder());
  1012.         $query->setParameter('orderLM', $lessonModule->getOrder());
  1013.         $query->setParameter('deleted', ExamEnum::ITEM_NO_DELETED);
  1014.         $query->setParameter('deletedExamUser', ExamUserEnum::ITEM_NO_DELETED);
  1016.         $query->setMaxResults(1);
  1017.         
  1018.         return $query->getQuery()->getOneOrNullResult();
  1019.     }
  1021.     public function getLastExamIdByLesson(Lesson $lessonBase, bool $complete = false)
  1022.     {
  1024.         $addExams = false;
  1025.         $addExamsLimited = false;
  1027.         if(
  1028.             $this->configuration->isModuleActive("exam_module") &&
  1029.             $this->configuration->checkModuleIsAbleOnPlan("examFunction")
  1030.         ){
  1031.             $addExams = true;
  1032.             $addExamsLimited = $this->configuration->checkModuleIsAbleOnPlan(
  1033.                 "unlimitedExamFunction"
  1034.             );
  1035.         }
  1037.         $lessonRepository = $this->em->getRepository(Lesson::class);
  1038.         
  1039.         $lessonIdBefore = $lessonRepository->getLessonIdBeforeThat($lessonBase);
  1040.         $lesson = $lessonRepository->findOneBy([
  1041.             "id" => $lessonIdBefore,
  1042.             "deleted" => ExamEnum::ITEM_NO_DELETED,
  1043.         ]);
  1045.         if(!$lesson){
  1046.             return;
  1047.         }
  1049.         $course = $lesson->getCourse();
  1050.         $lessonModule = $lesson->getLessonModule();
  1051.         $exam = null;
  1053.         if(!$exam && $lessonRepository->isLastModuleLesson($lesson)){
  1056.             if(!$addExams || !$addExamsLimited){
  1057.                 return;
  1058.             }
  1060.             $exam = $this->findOneBy([
  1061.                 "deleted" => ExamEnum::ITEM_NO_DELETED,
  1062.                 "course" => $course->getId(),
  1063.                 "lessonModule" => $lessonModule->getId(),
  1064.                 "status" => ExamEnum::PUBLISHED,
  1065.                 "type" => ExamEnum::MODULE
  1066.             ]);
  1067.         }
  1069.         if(!$exam){
  1070.             if(!$addExams || !$addExamsLimited){
  1071.                 return;
  1072.             }
  1074.             $exam = $this->findOneBy([
  1075.                 "deleted" => ExamEnum::ITEM_NO_DELETED,
  1076.                 "course" => $course->getId(),
  1077.                 "lessonModule" => $lessonModule->getId(),
  1078.                 "lesson" => $lesson->getId(),
  1079.                 "status" => ExamEnum::PUBLISHED,
  1080.                 "type" => ExamEnum::LESSON
  1081.             ]);
  1082.         }
  1084.         if(!$exam){
  1085.             $exam = $this->findOneBy([
  1086.                 "deleted" => ExamEnum::ITEM_NO_DELETED,
  1087.                 "course" => $course->getId(),
  1088.                 "lessonModule" => $lessonModule->getId(),
  1089.                 "lesson" => $lesson->getId(),
  1090.                 "status" => ExamEnum::PUBLISHED,
  1091.                 "type" => ExamEnum::QUIZ
  1092.             ]);
  1093.         }
  1095.         if($exam){
  1097.             if($complete){
  1098.                 return (object)[ 
  1099.                     "id" => $exam->getId(),
  1100.                     "title" => $exam->getTitle(),
  1101.                     "courseId" => $exam->getCourse()->getId(),
  1102.                     "moduleId" => (
  1103.                         $exam->getLessonModule() ?
  1104.                         $exam->getLessonModule()->getId() :
  1105.                         null
  1106.                     ),
  1107.                     "moduleTitle" => (
  1108.                         $exam->getLessonModule() ?
  1109.                         $exam->getLessonModule()->getTitle() :
  1110.                         null
  1111.                     ),
  1112.                     "lessonId" => (
  1113.                         $exam->getLesson() ?
  1114.                         $exam->getLesson()->getId() :
  1115.                         null
  1116.                     ),
  1117.                     "type" => $exam->getType(),
  1118.                 ];
  1119.             }
  1120.             
  1121.             return $exam->getId();
  1122.         }
  1123.         return;
  1124.     }
  1126.     public function sumCourseWeight($courseId)
  1127.     {
  1128.         $query = $this->createQueryBuilder('e');
  1129.         $query->select('SUM(e.examWeight) AS examWeight');
  1130.         $query->andWhere('e.status = :yes');
  1131.         $query->andWhere('e.requirement = :yes');
  1132.         $query->andWhere('e.course = :course');
  1133.         $query->andWhere('e.deleted = :deleted');
  1134.         $query->setParameter('course', $courseId);
  1135.         $query->setParameter('yes', ExamEnum::YES);
  1136.         $query->setParameter('deleted', ExamEnum::ITEM_NO_DELETED);
  1137.         
  1138.         $result = (object)$query->getQuery()->getOneOrNullResult();
  1140.         return $result->examWeight;
  1141.     }
  1143.     public function countCourseWeight($courseId)
  1144.     {
  1145.         $query = $this->createQueryBuilder('e');
  1146.         $query->select('COUNT(e.id) AS total');
  1147.         $query->andWhere('e.status = 1');
  1148.         $query->andWhere('e.examWeight > 0');
  1149.         $query->andWhere('e.requirement = 1');
  1150.         $query->andWhere('e.course = :course');
  1151.         $query->setParameter('course', $courseId);
  1152.         
  1153.         $result = (object)$query->getQuery()->getOneOrNullResult();
  1155.         return $result->total;
  1156.     }
  1158.     public function countValidExamByCourse(int $courseId)
  1159.     {
  1160.         $query = $this->createQueryBuilder('e');
  1162.         $query->innerJoin('EADPlataforma:Course', 'c', 'WITH', 'c.id = e.course');
  1163.         $query->leftJoin('EADPlataforma:LessonModule', 'lm', 'WITH', 'lm.id = e.lessonModule');
  1164.         $query->leftJoin('EADPlataforma:Lesson', 'l', 'WITH', 'l.id = e.lesson');
  1166.         $query->select('COUNT(e.id) AS total');
  1168.         $query->andWhere('e.deleted = :examDeleted');
  1169.         $query->andWhere('e.status = :examStatus');
  1170.         $query->andWhere('e.examWeight > 0');
  1171.         //$query->andWhere('e.requirement = :yes');
  1172.         $query->andWhere('e.course = :course');
  1174.         $query->andWhere('
  1175.             (
  1176.                 (e.type = :typeCourse AND c.deleted = :courseDeleted)
  1177.                 OR (
  1178.                     e.type = :typeLessonModule
  1179.                     AND lm.status = :lessonModuleStatus 
  1180.                     AND lm.deleted = :lessonModuleDeleted
  1181.                 ) 
  1182.                 OR (
  1183.                     e.type = :typeLesson 
  1184.                     AND l.status = :lessonStatus 
  1185.                     AND l.deleted = :lessonDeleted
  1186.                 )
  1187.             )
  1188.         ');
  1190.         $query->setParameter('typeCourse', ExamEnum::COURSE);
  1191.         $query->setParameter('typeLessonModule', ExamEnum::MODULE);
  1192.         $query->setParameter('typeLesson', ExamEnum::LESSON);
  1194.         $query->setParameter('examDeleted', ExamEnum::ITEM_NO_DELETED);
  1195.         $query->setParameter('courseDeleted', CourseEnum::ITEM_NO_DELETED);
  1196.         $query->setParameter('lessonModuleDeleted', LessonModuleEnum::ITEM_NO_DELETED);
  1197.         $query->setParameter('lessonDeleted', LessonEnum::ITEM_NO_DELETED);
  1198.         
  1199.         $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  1200.         $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  1201.         $query->setParameter('examStatus', ExamEnum::PUBLISHED);
  1202.         //$query->setParameter('yes', ExamEnum::YES);
  1203.         $query->setParameter('course', $courseId);
  1204.         
  1205.         $result = (object)$query->getQuery()->getOneOrNullResult();
  1207.         return $result->total;
  1208.     }
  1210.     public function copyExamQuestion(Exam $oldExam, Exam $newExam)
  1211.     {   
  1212.         $questionRepository = $this->em->getRepository(Question::class);
  1213.         $questions = $oldExam->getQuestion();
  1214.         if($questions){
  1215.             foreach ($questions as $key => $question) {
  1216.                 if($question->isLive()){
  1217.                     if($oldExam->getCourse()->getId() != $newExam->getCourse()->getId()){
  1218.                         $newQuestion = $questionRepository->copyQuestionsByCourse(
  1219.                             $question, 
  1220.                             $newExam->getCourse()
  1221.                         );
  1222.                         
  1223.                         if($newQuestion){
  1224.                             $newExam->addQuestion($newQuestion);
  1225.                         }
  1226.                     }else{
  1227.                         $newExam->addQuestion($question); 
  1228.                     }
  1229.                 }
  1230.             }
  1231.         }
  1233.         return $newExam;
  1234.     }
  1236.     public function copyExamByCourse(Course $oldCourse, Course $newCourse)
  1237.     {
  1238.         $oldExam = $this->findOneBy([
  1239.             "course" => $oldCourse->getId(),
  1240.             "type" => ExamEnum::COURSE,
  1241.             "deleted" => ExamEnum::ITEM_NO_DELETED
  1242.         ]);
  1244.         if($oldExam){
  1245.             $newExam = new Exam();
  1246.             
  1247.             $newExam->setTitle($oldExam->getTitle());
  1248.             $newExam->setType($oldExam->getType());
  1249.             $newExam->setStatus($oldExam->getStatus());
  1250.             $newExam->setRequirement($oldExam->getRequirement());
  1251.             $newExam->setQuestionOrder($oldExam->getQuestionOrder());
  1252.             $newExam->setQuestionNumber($oldExam->getQuestionNumber());
  1253.             $newExam->setExamAverage($oldExam->getExamAverage());
  1254.             $newExam->setExamWeight($oldExam->getExamWeight());
  1255.             $newExam->setTypeRelease($oldExam->getTypeRelease());
  1256.             $newExam->setPeriodStart($oldExam->getPeriodStart());
  1257.             $newExam->setPeriodEnd($oldExam->getPeriodEnd());
  1258.             $newExam->setDateStart($oldExam->getDateStart());
  1259.             $newExam->setExamTime($oldExam->getExamTime());
  1260.             $newExam->setAttempts($oldExam->getAttempts());
  1261.             $newExam->setAttemptsNumber($oldExam->getAttemptsNumber());
  1262.             $newExam->setAttemptsAutoRelease($oldExam->getAttemptsAutoRelease());
  1263.             $newExam->setAttemptsTypeRelease($oldExam->getAttemptsTypeRelease());
  1264.             $newExam->setAttemptsTime($oldExam->getAttemptsTime());
  1265.             $newExam->setAttemptsPeriod($oldExam->getAttemptsPeriod());
  1266.             $newExam->setShowTemplate($oldExam->getShowTemplate());
  1267.             $newExam->setNote($oldExam->getNote());
  1268.             $newExam->setDateLastNotify($oldExam->getDateLastNotify());
  1269.             $newExam->setCourse($newCourse);
  1270.             
  1271.             $newExam = $this->copyExamQuestion($oldExam, $newExam);
  1273.             $this->em->persist($newExam);
  1274.             $this->em->flush();
  1275.         }
  1276.     }
  1278.     public function copyExamByModule(LessonModule $oldModule, LessonModule $newModule)
  1279.     {
  1280.         $oldExam = $this->findOneBy([
  1281.             "course" => $oldModule->getCourse()->getId(), 
  1282.             "lessonModule"=> $oldModule->getId(),
  1283.             "type" => ExamEnum::MODULE,
  1284.             "deleted" => ExamEnum::ITEM_NO_DELETED
  1285.         ]);
  1287.         if($oldExam){
  1288.             $newExam = new Exam();
  1289.             
  1290.             $newExam->setTitle($oldExam->getTitle());
  1291.             $newExam->setType($oldExam->getType());
  1292.             $newExam->setStatus($oldExam->getStatus());
  1293.             $newExam->setRequirement($oldExam->getRequirement());
  1294.             $newExam->setQuestionOrder($oldExam->getQuestionOrder());
  1295.             $newExam->setQuestionNumber($oldExam->getQuestionNumber());
  1296.             $newExam->setExamAverage($oldExam->getExamAverage());
  1297.             $newExam->setExamWeight($oldExam->getExamWeight());
  1298.             $newExam->setTypeRelease($oldExam->getTypeRelease());
  1299.             $newExam->setPeriodStart($oldExam->getPeriodStart());
  1300.             $newExam->setPeriodEnd($oldExam->getPeriodEnd());
  1301.             $newExam->setDateStart($oldExam->getDateStart());
  1302.             $newExam->setExamTime($oldExam->getExamTime());
  1303.             $newExam->setAttempts($oldExam->getAttempts());
  1304.             $newExam->setAttemptsNumber($oldExam->getAttemptsNumber());
  1305.             $newExam->setAttemptsAutoRelease($oldExam->getAttemptsAutoRelease());
  1306.             $newExam->setAttemptsTypeRelease($oldExam->getAttemptsTypeRelease());
  1307.             $newExam->setAttemptsTime($oldExam->getAttemptsTime());
  1308.             $newExam->setAttemptsPeriod($oldExam->getAttemptsPeriod());
  1309.             $newExam->setShowTemplate($oldExam->getShowTemplate());
  1310.             $newExam->setNote($oldExam->getNote());
  1311.             $newExam->setDateLastNotify($oldExam->getDateLastNotify());
  1312.             $newExam->setCourse($newModule->getCourse());
  1313.             $newExam->setLessonModule($newModule);
  1314.             
  1315.             $newExam = $this->copyExamQuestion($oldExam, $newExam);
  1317.             $this->em->persist($newExam);
  1318.             $this->em->flush();
  1319.         }
  1320.     }
  1322.     public function copyExamByLesson(Lesson $oldLesson, Lesson $newLesson)
  1323.     {
  1324.         $oldExam = $this->findOneBy([
  1325.             "course" => $oldLesson->getCourse()->getId(),
  1326.             "lessonModule" => $oldLesson->getLessonModule()->getId(),
  1327.             "lesson"=> $oldLesson->getId(),
  1328.             "type" => ExamEnum::LESSON,
  1329.             "deleted" => ExamEnum::ITEM_NO_DELETED
  1330.         ]);
  1332.         if($oldExam){
  1333.             $newExam = new Exam();
  1334.             
  1335.             $newExam->setTitle($oldExam->getTitle());
  1336.             $newExam->setType($oldExam->getType());
  1337.             $newExam->setStatus($oldExam->getStatus());
  1338.             $newExam->setRequirement($oldExam->getRequirement());
  1339.             $newExam->setQuestionOrder($oldExam->getQuestionOrder());
  1340.             $newExam->setQuestionNumber($oldExam->getQuestionNumber());
  1341.             $newExam->setExamAverage($oldExam->getExamAverage());
  1342.             $newExam->setExamWeight($oldExam->getExamWeight());
  1343.             $newExam->setTypeRelease($oldExam->getTypeRelease());
  1344.             $newExam->setPeriodStart($oldExam->getPeriodStart());
  1345.             $newExam->setPeriodEnd($oldExam->getPeriodEnd());
  1346.             $newExam->setDateStart($oldExam->getDateStart());
  1347.             $newExam->setExamTime($oldExam->getExamTime());
  1348.             $newExam->setAttempts($oldExam->getAttempts());
  1349.             $newExam->setAttemptsNumber($oldExam->getAttemptsNumber());
  1350.             $newExam->setAttemptsAutoRelease($oldExam->getAttemptsAutoRelease());
  1351.             $newExam->setAttemptsTypeRelease($oldExam->getAttemptsTypeRelease());
  1352.             $newExam->setAttemptsTime($oldExam->getAttemptsTime());
  1353.             $newExam->setAttemptsPeriod($oldExam->getAttemptsPeriod());
  1354.             $newExam->setShowTemplate($oldExam->getShowTemplate());
  1355.             $newExam->setNote($oldExam->getNote());
  1356.             $newExam->setDateLastNotify($oldExam->getDateLastNotify());
  1357.             $newExam->setCourse($newLesson->getCourse());
  1358.             $newExam->setLessonModule($newLesson->getLessonModule());
  1359.             $newExam->setLesson($newLesson);
  1360.             
  1361.             $newExam = $this->copyExamQuestion($oldExam, $newExam);
  1362.             
  1363.             $this->em->persist($newExam);
  1364.             $this->em->flush();
  1365.         }
  1366.     }
  1368.     public function copyQuizByLesson(Lesson $oldLesson, Lesson $newLesson)
  1369.     {
  1370.         $oldExam = $this->findOneBy([
  1371.             "course" => $oldLesson->getCourse()->getId(),
  1372.             "lessonModule" => $oldLesson->getLessonModule()->getId(),
  1373.             "lesson"=> $oldLesson->getId(),
  1374.             "type" => ExamEnum::QUIZ,
  1375.             "deleted" => ExamEnum::ITEM_NO_DELETED
  1376.         ]);
  1378.         if($oldExam){
  1379.             $newExam = new Exam();
  1380.             
  1381.             $newExam->setTitle($oldExam->getTitle());
  1382.             $newExam->setType($oldExam->getType());
  1383.             $newExam->setStatus($oldExam->getStatus());
  1384.             $newExam->setRequirement($oldExam->getRequirement());
  1385.             $newExam->setQuestionOrder($oldExam->getQuestionOrder());
  1386.             $newExam->setQuestionNumber($oldExam->getQuestionNumber());
  1387.             $newExam->setExamAverage($oldExam->getExamAverage());
  1388.             $newExam->setExamWeight($oldExam->getExamWeight());
  1389.             $newExam->setTypeRelease($oldExam->getTypeRelease());
  1390.             $newExam->setPeriodStart($oldExam->getPeriodStart());
  1391.             $newExam->setPeriodEnd($oldExam->getPeriodEnd());
  1392.             $newExam->setDateStart($oldExam->getDateStart());
  1393.             $newExam->setExamTime($oldExam->getExamTime());
  1394.             $newExam->setAttempts($oldExam->getAttempts());
  1395.             $newExam->setAttemptsNumber($oldExam->getAttemptsNumber());
  1396.             $newExam->setAttemptsAutoRelease($oldExam->getAttemptsAutoRelease());
  1397.             $newExam->setAttemptsTypeRelease($oldExam->getAttemptsTypeRelease());
  1398.             $newExam->setAttemptsTime($oldExam->getAttemptsTime());
  1399.             $newExam->setAttemptsPeriod($oldExam->getAttemptsPeriod());
  1400.             $newExam->setShowTemplate($oldExam->getShowTemplate());
  1401.             $newExam->setNote($oldExam->getNote());
  1402.             $newExam->setDateLastNotify($oldExam->getDateLastNotify());
  1403.             $newExam->setCourse($newLesson->getCourse());
  1404.             $newExam->setLessonModule($newLesson->getLessonModule());
  1405.             $newExam->setLesson($newLesson);
  1406.             
  1407.             $newExam = $this->copyExamQuestion($oldExam, $newExam);
  1408.             
  1409.             $this->em->persist($newExam);
  1410.             $this->em->flush();
  1411.         }
  1412.     }
  1414.     public function editManyStatus(Exam $exam, $permission, $status)
  1415.     {
  1416.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  1418.         $allTypes = $this->configuration->checkModuleIsAbleOnPlan('unlimitedExamFunction');
  1419.         if(!$allTypes){
  1420.             if($exam->getType() != ExamEnum::COURSE && $exam->getType() != ExamEnum::QUIZ){
  1421.                 return false;
  1422.             }
  1423.         }
  1425.         if($exam->getType() == ExamEnum::MODULE){
  1426.             $permission = $userPermissionUtil->getPermission(
  1427.                 "course", 
  1428.                 "lesson_module", 
  1429.                 "exam_configuration", 
  1430.                 "edit"
  1431.             );
  1432.         }else if($exam->getType() == ExamEnum::LESSON){
  1433.             $permission = $userPermissionUtil->getPermission(
  1434.                 "course", 
  1435.                 "lesson", 
  1436.                 "exam_configuration", 
  1437.                 "edit"
  1438.             );
  1439.         }else if($exam->getType() == ExamEnum::QUIZ){
  1440.             $permission = $userPermissionUtil->getPermission(
  1441.                 "course", 
  1442.                 "lesson", 
  1443.                 "quiz_configuration", 
  1444.                 "edit"
  1445.             );
  1446.         }
  1448.         $isExamTeacher = $this->isExamTeacher($exam, $this->getUser());
  1449.         if($isExamTeacher && $userPermissionUtil->isMiddle($permission) || 
  1450.             $userPermissionUtil->isHigh($permission)){
  1452.             $exam->setStatus($status);
  1453.         }
  1454.     }
  1456.     public function delete(Exam $exam, $typeItem, $permission, $isTrash)
  1457.     {
  1458.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  1460.         $allTypes = $this->configuration->checkModuleIsAbleOnPlan('unlimitedExamFunction');
  1461.         if(!$allTypes){
  1462.             if($exam->getType() != ExamEnum::COURSE && $exam->getType() != ExamEnum::QUIZ){
  1463.                 return false;
  1464.             }
  1465.         }
  1467.         if($exam->getType() == ExamEnum::MODULE){
  1468.             $permission = $userPermissionUtil->getPermission(
  1469.                 "course", 
  1470.                 "lesson_module", 
  1471.                 "exam_configuration", 
  1472.                 "delete"
  1473.             );
  1474.         }else if($exam->getType() == ExamEnum::LESSON){
  1475.             $permission = $userPermissionUtil->getPermission(
  1476.                 "course", 
  1477.                 "lesson", 
  1478.                 "exam_configuration", 
  1479.                 "delete"
  1480.             );
  1481.         }else if($exam->getType() == ExamEnum::QUIZ){
  1482.             $permission = $userPermissionUtil->getPermission(
  1483.                 "course", 
  1484.                 "lesson", 
  1485.                 "quiz_configuration", 
  1486.                 "delete"
  1487.             );
  1488.         }
  1490.         $isExamTeacher = $this->isExamTeacher($exam, $this->getUser());
  1491.         if($isExamTeacher || $userPermissionUtil->isHigh($permission)){
  1492.             $questions = $exam->getQuestion();
  1493.             if(!empty($questions)){
  1494.                 foreach ($questions as $key => $question) {
  1495.                     $exam->removeQuestion($question);
  1496.                 }
  1497.             }
  1499.             $exam->setTitle(null);
  1500.             $exam->setStatus(ExamEnum::DRAFT);
  1501.             $exam->setRequirement(ExamEnum::NO);
  1502.             $exam->setQuestionOrder(ExamEnum::SEQUENTIAL);
  1503.             $exam->setQuestionNumber(0);
  1504.             $exam->setExamAverage(7);
  1505.             $exam->setExamWeight(0);
  1506.             $exam->setTypeRelease(ExamEnum::RELEASED);
  1507.             $exam->setControlTime(ExamEnum::NO);
  1508.             $exam->setPeriodStart(0);
  1509.             $exam->setPeriodEnd(0);
  1510.             $exam->setDateStart(null);
  1511.             $exam->setExamTime(null);
  1512.             $exam->setAttempts(ExamEnum::NO);
  1513.             $exam->setAttemptsNumber(1);
  1514.             $exam->setAttemptsAutoRelease(ExamEnum::YES);
  1515.             $exam->setAttemptsTypeRelease(ExamEnum::DAYS);
  1516.             $exam->setAttemptsTime(null);
  1517.             $exam->setAttemptsPeriod(null);
  1518.             $exam->setShowTemplate(ExamEnum::NO);
  1519.             $exam->setNote(null);
  1520.             $exam->setDateLastNotify(null);
  1522.             $this->em->flush();
  1523.         }
  1524.     }
  1526.     public function restoreByCourse($courseId, $deleted, $typeDelete, $userDelete, $dateNow){
  1527.         $sql = "UPDATE EADPlataforma:Exam AS e 
  1528.                 SET e.deleted = :deleted, e.userDelete = :userDelete, 
  1529.                     e.dateDelete = :dateNow
  1530.                 WHERE e.deleted = (1 - :deleted)
  1531.                 AND e.typeDelete = :typeDelete
  1532.                 AND e.course = :courseId";
  1533.         $query = $this->em->createQuery($sql);
  1534.         $query->setParameter('courseId', $courseId);
  1535.         $query->setParameter('deleted', $deleted);
  1536.         $query->setParameter('typeDelete', $typeDelete);
  1537.         $query->setParameter('userDelete', $userDelete);
  1538.         $query->setParameter('dateNow', $dateNow);
  1539.         $query->execute();
  1540.         
  1541.         return true;
  1542.     }
  1544.     public function deleteByCourse($courseId, $deleted, $typeDelete, $userDelete, $dateNow){
  1545.         $sql = "UPDATE EADPlataforma:Exam AS e 
  1546.                 SET e.deleted = :deleted, e.typeDelete = :typeDelete,
  1547.                     e.userDelete = :userDelete, e.dateDelete = :dateNow
  1548.                 WHERE e.deleted = (:deleted - 1)
  1549.                 AND e.course = :courseId";
  1550.         $query = $this->em->createQuery($sql);
  1551.         $query->setParameter('courseId', $courseId);
  1552.         $query->setParameter('deleted', $deleted);
  1553.         $query->setParameter('typeDelete', $typeDelete);
  1554.         $query->setParameter('userDelete', $userDelete);
  1555.         $query->setParameter('dateNow', $dateNow);
  1556.         $query->execute();
  1557.         
  1558.         return true;
  1559.     }
  1561.     public function restoreByLessonModule($lessonModuleId, $deleted, $typeDelete, $userDelete, $dateNow){
  1562.         $sql = "UPDATE EADPlataforma:Exam AS e 
  1563.                 SET e.deleted = :deleted, e.userDelete = :userDelete, 
  1564.                     e.dateDelete = :dateNow
  1565.                 WHERE e.deleted = (1 - :deleted)
  1566.                 AND e.typeDelete = :typeDelete
  1567.                 AND e.lessonModule = :lessonModuleId";
  1568.         $query = $this->em->createQuery($sql);
  1569.         $query->setParameter('lessonModuleId', $lessonModuleId);
  1570.         $query->setParameter('deleted', $deleted);
  1571.         $query->setParameter('typeDelete', $typeDelete);
  1572.         $query->setParameter('userDelete', $userDelete);
  1573.         $query->setParameter('dateNow', $dateNow);
  1574.         $query->execute();
  1575.         
  1576.         return true;
  1577.     }
  1579.     public function deleteByLessonModule($lessonModuleId, $deleted, $typeDelete, $userDelete, $dateNow){
  1580.         $sql = "UPDATE EADPlataforma:Exam AS e 
  1581.                 SET e.deleted = :deleted, e.typeDelete = :typeDelete,
  1582.                     e.userDelete = :userDelete, e.dateDelete = :dateNow
  1583.                 WHERE e.deleted = (:deleted - 1)
  1584.                 AND e.lessonModule = :lessonModuleId";
  1585.         $query = $this->em->createQuery($sql);
  1586.         $query->setParameter('lessonModuleId', $lessonModuleId);
  1587.         $query->setParameter('deleted', $deleted);
  1588.         $query->setParameter('typeDelete', $typeDelete);
  1589.         $query->setParameter('userDelete', $userDelete);
  1590.         $query->setParameter('dateNow', $dateNow);
  1591.         $query->execute();
  1592.         
  1593.         return true;
  1594.     }
  1596.     public function restoreByLesson($lessonId, $deleted, $typeDelete, $userDelete, $dateNow){
  1597.         $sql = "UPDATE EADPlataforma:Exam AS e 
  1598.                 SET e.deleted = :deleted, e.userDelete = :userDelete, 
  1599.                     e.dateDelete = :dateNow
  1600.                 WHERE e.deleted = (1 - :deleted)
  1601.                 AND e.typeDelete = :typeDelete
  1602.                 AND e.lesson = :lessonId";
  1603.         $query = $this->em->createQuery($sql);
  1604.         $query->setParameter('lessonId', $lessonId);
  1605.         $query->setParameter('deleted', $deleted);
  1606.         $query->setParameter('typeDelete', $typeDelete);
  1607.         $query->setParameter('userDelete', $userDelete);
  1608.         $query->setParameter('dateNow', $dateNow);
  1609.         $query->execute();
  1610.         
  1611.         return true;
  1612.     }
  1614.     public function deleteByLesson($lessonId, $deleted, $typeDelete, $userDelete, $dateNow){
  1615.         $sql = "UPDATE EADPlataforma:Exam AS e 
  1616.                 SET e.deleted = :deleted, e.typeDelete = :typeDelete,
  1617.                     e.userDelete = :userDelete, e.dateDelete = :dateNow
  1618.                 WHERE e.deleted = (:deleted - 1)
  1619.                 AND e.lesson = :lessonId";
  1620.         $query = $this->em->createQuery($sql);
  1621.         $query->setParameter('lessonId', $lessonId);
  1622.         $query->setParameter('deleted', $deleted);
  1623.         $query->setParameter('typeDelete', $typeDelete);
  1624.         $query->setParameter('userDelete', $userDelete);
  1625.         $query->setParameter('dateNow', $dateNow);
  1626.         $query->execute();
  1627.         
  1628.         return true;
  1629.     }
  1631.     public function deleteTrashCron()
  1632.     {
  1633.         $sql = "UPDATE EADPlataforma:Exam AS e 
  1634.                 SET e.deleted = 2 WHERE e.dateDelete <= :date AND e.deleted = 1 ";
  1635.         $query = $this->em->createQuery($sql);
  1636.         $query->setParameter('date', date('Y-m-d H:i:s', strtotime('-90 days')));
  1637.         $query->execute();
  1638.     }
  1639. }