src/Repository/LessonRepository.php line 394

Open in your IDE?
  1. <?php
  3. namespace EADPlataforma\Repository;
  5. use EADPlataforma\Entity\Course;
  6. use EADPlataforma\Entity\Product;
  7. use EADPlataforma\Entity\LessonModule;
  8. use EADPlataforma\Entity\Lesson;
  9. use EADPlataforma\Entity\LessonLog;
  10. use EADPlataforma\Entity\LessonLogOrigin;
  11. use EADPlataforma\Entity\CourseTeam;
  12. use EADPlataforma\Entity\Exam;
  13. use EADPlataforma\Entity\ExamUser;
  14. use EADPlataforma\Entity\Enrollment;
  15. use EADPlataforma\Entity\Library;
  16. use EADPlataforma\Entity\LessonXLibrary;
  17. use EADPlataforma\Entity\LessonSupport;
  18. use EADPlataforma\Entity\User;
  19. use EADPlataforma\Entity\Trash;
  20. use EADPlataforma\Enum\CourseEnum;
  21. use EADPlataforma\Enum\CourseTeamEnum;
  22. use EADPlataforma\Enum\LessonEnum;
  23. use EADPlataforma\Enum\LessonModuleEnum;
  24. use EADPlataforma\Enum\EnrollmentEnum;
  25. use EADPlataforma\Enum\ExamEnum;
  26. use EADPlataforma\Enum\UserEnum;
  27. use EADPlataforma\Enum\LibraryEnum;
  28. use EADPlataforma\Enum\LessonXLibraryEnum;
  29. use EADPlataforma\Enum\ServicesEnum;
  30. use EADPlataforma\Enum\NotificationEnum;
  31. use EADPlataforma\Enum\TrashEnum;
  32. use Firebase\JWT\JWT;
  33. use \PDO;
  35. /**
  36.  * @method Lesson|null find($id, $lockMode = null, $lockVersion = null)
  37.  * @method Lesson|null findOneBy(array $criteria, array $orderBy = null)
  38.  * @method Lesson[]    findAll()
  39.  * @method Lesson[]    findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null)
  40.  */
  41. class LessonRepository extends AbstractRepository
  42. {
  43.     private $lessonIdsCourse = [];
  45.     public function getEntityClass(){
  46.         return Lesson::class;
  47.     }
  49.     public function getConnectionName(){
  50.         return "school";
  51.     }
  53.     public function getMeetCredentials(lesson $lesson, User $user)
  54.     {
  56.         $library = $lesson->getLibrary();
  58.         if(!$library){
  59.             return null;
  60.         }
  62.         $libraryType = $library->getType();
  63.         if($libraryType != LibraryEnum::CONTENT_CONFERENCE){
  64.             return null;
  65.         }
  67.         $info = $this->generalService->getServiceAccess(ServicesEnum::MEET);
  69.         $privateKey = $info->privateKey;
  70.         $publicKey = $info->publicKey;
  71.         $appId = $info->appId;
  73.         $fileService = $this->generalService->getService('FileService');
  74.         $photo = $fileService->getFilePathComplete(
  75.             $user->getPhoto(), 
  76.             UserEnum::PATH_PROFILES, 
  77.             true, 
  78.             true
  79.         );
  81.         $courseRepository = $this->em->getRepository(Course::class);
  82.         $isStudent = $courseRepository->isStudent($lesson->getCourse());
  83.         $isAdmin = ($isStudent ? false : true );
  85.         $client = $this->getConfiguration()->getClient();
  86.         $clientId = $client->getClientId();
  88.         $formatClientId = [
  89.             "1" => "00000{$clientId}",
  90.             "2" => "0000{$clientId}",
  91.             "3" => "000{$clientId}",
  92.             "4" => "00{$clientId}",
  93.             "5" => "0{$clientId}",
  94.         ];
  95.         
  96.         if(isset($formatClientId[strlen($clientId)])){
  97.             $clientId = $formatClientId[strlen($clientId)];
  98.         }
  99.         
  100.         $channelId = md5($clientId . $lesson->getId());
  101.         $userId = md5($clientId . $this->getUser()->getId());
  103.         $payload = [
  104.             'iss' => 'chat',
  105.             'aud' => 'jitsi',
  106.             'exp' => time() + 7200,
  107.             'nbf' => time() - 10,
  108.             'room'=> '*',
  109.             'sub' => $appId,
  110.             'context' => [
  111.                 'user' => [
  112.                     'moderator' => $isAdmin ? "true" : "false",
  113.                     'email' => $user->getEmail(),
  114.                     'name' => $user->getName(),
  115.                     'avatar' => $photo,
  116.                     'id' => $userId
  117.                 ],
  118.                 'features' => [
  119.                     'recording' => $isAdmin ? "true" : "false",
  120.                     'livestreaming' => "false",
  121.                     'transcription' => "false",
  122.                     'outbound-call' => "false"
  123.                 ]
  124.             ]
  125.         ];
  127.         $token = JWT::encode($payload, $privateKey, "RS256", $publicKey);
  129.         return (object)[
  130.             "token" => $token,
  131.             "room" => $channelId,
  132.             "appId" => $appId,
  133.         ];
  134.     }
  136.     public function getLessonChatCredentialsNew(Lesson $lesson)
  137.     {
  139.         $library = $lesson->getLibrary();
  141.         if(!$this->getUser()){
  142.             return;
  143.         }
  145.         if(!$library){
  146.             return;
  147.         }
  149.         if(
  150.             $library->getType() != LibraryEnum::CONTENT_LIVE && 
  151.             $library->getType() != LibraryEnum::CONTENT_EXTERNAL_LIVE
  152.         ){
  153.             return;
  154.         }
  156.         $courseRepository = $this->em->getRepository(Course::class);
  157.         $isStudent = $courseRepository->isStudent($lesson->getCourse());
  159.         if($lesson->getShowLiveChat() == LessonEnum::NO && $isStudent){
  160.             return;
  161.         }
  162.         
  163.         $today = date('Y-m-d H:i:s');
  164.         $todayDate = date('Y-m-d');
  165.         $timeToday = strtotime($today);
  167.         $showLiveChat = LessonEnum::NO;
  168.         $liveDateStart = $library->getLiveStart();
  169.         $timeLiveEnd = date('Y-m-d', strtotime($liveDateStart));
  170.         $timeLiveStart = strtotime($liveDateStart . ' - 1 hours'); 
  171.         
  172.         if($timeToday >= $timeLiveStart && $todayDate == $timeLiveEnd || !$isStudent){
  173.             $showLiveChat = LessonEnum::YES;
  174.         }
  176.         if($showLiveChat == LessonEnum::NO){
  177.             return;
  178.         }
  180.         $client = $this->getConfiguration()->getClient();
  181.         $clientId = $client->getClientId();
  183.         $formatClientId = [
  184.             "1" => "00000{$clientId}",
  185.             "2" => "0000{$clientId}",
  186.             "3" => "000{$clientId}",
  187.             "4" => "00{$clientId}",
  188.             "5" => "0{$clientId}",
  189.         ];
  190.         
  191.         if(isset($formatClientId[strlen($clientId)])){
  192.             $clientId = $formatClientId[strlen($clientId)];
  193.         }
  194.         
  195.         $channelId = md5($clientId . $lesson->getId());
  196.         $userId = md5($clientId . $this->getUser()->getId());
  197.         $isAdmin = ($isStudent ? false : true );
  199.         $fileService = $this->generalService->getService('FileService');
  200.         $photo = $fileService->getFilePathComplete(
  201.             $this->getUser()->getPhoto(), 
  202.             UserEnum::PATH_PROFILES, 
  203.             true, 
  204.             true
  205.         );
  207.         $tokenAuth = $this->generalService->getTokenCron();
  208.         $url = "https://chat.eadplataforma.app/api/users/token";
  210.         $ch = curl_init($url);
  212.         $dataPost = [
  213.             "isAdmin" => $isAdmin,
  214.             "id" => $userId,
  215.             "name" => $this->getUser()->getName(),
  216.             "roomId" => $channelId,
  217.             "photoSrc" => $photo,
  218.             "lessonId" => $lesson->getId(),
  219.             "clientId" => $clientId,
  220.         ];
  222.         curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
  223.         curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($dataPost));
  224.         curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  225.         curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
  226.         curl_setopt($ch, CURLOPT_HTTPHEADER, [ 
  227.             "Authorization: {$tokenAuth}",
  228.             "Content-Type: application/json"
  229.         ]);
  231.         $dataToken = curl_exec($ch);
  232.         $error = curl_error($ch);
  233.         $dataToken = json_decode($dataToken);
  234.         curl_close($ch);
  236.         return (object)[
  237.             "role" => ($isAdmin ? "admin" : "user"),
  238.             "userId" => $userId,
  239.             "userFoto" => $photo,
  240.             "userName" => $this->getUser()->getName(),
  241.             "channelId" => $channelId,
  242.             "channelLogo" => "",
  243.             "channelName" => $lesson->getTitle(),
  244.             "userToken" => (!empty($dataToken->token) ? $dataToken->token : null),
  245.             "clientId" => $clientId
  246.         ];
  247.     }
  249.     public function getLessonChatCredentials(Lesson $lesson)
  250.     {
  251.         $library = $lesson->getLibrary();
  253.         if(!$this->getUser()){
  254.             return;
  255.         }
  257.         if(!$library){
  258.             return;
  259.         }
  261.         if(
  262.             $library->getType() != LibraryEnum::CONTENT_LIVE && 
  263.             $library->getType() != LibraryEnum::CONTENT_EXTERNAL_LIVE
  264.         ){
  265.             return;
  266.         }
  268.         $courseRepository = $this->em->getRepository(Course::class);
  269.         $isStudent = $courseRepository->isStudent($lesson->getCourse());
  271.         if($lesson->getShowLiveChat() == LessonEnum::NO && $isStudent){
  272.             return;
  273.         }
  274.         
  275.         $today = date('Y-m-d H:i:s');
  276.         $todayDate = date('Y-m-d');
  277.         $timeToday = strtotime($today);
  279.         $showLiveChat = LessonEnum::NO;
  280.         $liveDateStart = $library->getLiveStart();
  281.         $timeLiveEnd = date('Y-m-d', strtotime($liveDateStart));
  282.         $timeLiveStart = strtotime($liveDateStart . ' - 1 hours'); 
  283.         
  284.         if($timeToday >= $timeLiveStart && $todayDate == $timeLiveEnd || !$isStudent){
  285.             $showLiveChat = LessonEnum::YES;
  286.         }
  288.         if($showLiveChat == LessonEnum::NO){
  289.             return;
  290.         }
  292.         $header = [ 
  293.             'typ' => 'JWT', 
  294.             'alg' => 'HS256'
  295.         ];
  297.         $info = $this->generalService->getServiceAccess(ServicesEnum::LIVECHAT);
  299.         $client = $this->getConfiguration()->getClient();
  300.         $clientId = $client->getClientId();
  302.         $formatClientId = [
  303.             "1" => "00000{$clientId}",
  304.             "2" => "0000{$clientId}",
  305.             "3" => "000{$clientId}",
  306.             "4" => "00{$clientId}",
  307.             "5" => "0{$clientId}",
  308.         ];
  309.         
  310.         if(isset($formatClientId[strlen($clientId)])){
  311.             $clientId = $formatClientId[strlen($clientId)];
  312.         }
  313.         
  314.         $channelId = md5($clientId . $lesson->getId());
  315.         $clientStream = new \GetStream\StreamChat\Client($info->client, $info->token);
  316.         $channel = $clientStream->Channel("livestream", $channelId);
  318.         $userId = md5($clientId . $this->getUser()->getId());
  319.         $role = ($isStudent ? 'user' : 'admin' );
  321.         $stringUtil = $this->generalService->getUtil('StringUtil');
  323.         $chatToken = $info->token;
  324.         $segments = [];
  325.         $segments[] = $stringUtil->urlSafeB64Encode(json_encode($header));
  326.         $segments[] = $stringUtil->urlSafeB64Encode(json_encode([ 
  327.             "user_id" => $userId 
  328.         ]));
  330.         $signingInput = implode('.', $segments);
  331.         $signature = hash_hmac('SHA256', $signingInput, $chatToken, true);
  332.         $segments[] = $stringUtil->urlSafeB64Encode($signature);
  333.         $userToken =  implode('.', $segments);
  335.         $fileService = $this->generalService->getService('FileService');
  336.         $photo = $fileService->getFilePathComplete(
  337.             $this->getUser()->getPhoto(), 
  338.             UserEnum::PATH_PROFILES, 
  339.             true, 
  340.             true
  341.         );
  343.         return (object)[
  344.             "role" => $role,
  345.             "userId" => $userId,
  346.             "userFoto" => $photo,
  347.             "userName" => $this->getUser()->getName(),
  348.             "channelId" => $channelId,
  349.             "channelLogo" => "",
  350.             "channelName" => $lesson->getTitle(),
  351.             "userToken" => $userToken,
  352.             "clientId" => $info->client
  353.         ];
  354.     }
  356.     public function getLessonTeacher(Lesson $lesson)
  357.     {
  358.         $userLesson = $lesson->getUser();
  359.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  360.         $fileService = $this->generalService->getService('FileService');
  362.         $dataImg = [
  363.             "fileName" => $userLesson->getPhoto(),
  364.             "pathConst" => LessonEnum::PATH_PROFILES,
  365.             "option" => "l-user-profile-teacher",
  366.             "addUpload" => true,
  367.             "addStream" => true,
  368.         ];
  370.         $request = $this->generalService->getRequest();
  372.         $teacher = (object)[
  373.             "id" => $userLesson->getId(),
  374.             "ip" => $request->getClientIp(),
  375.             "name" => $userLesson->getName(),
  376.             "canAccessAdm" => $userPermissionUtil->canAccessAdm(),
  377.             "document" => $userLesson->getDocument(),
  378.             "username" => $userLesson->getUsername(),
  379.             "photo" => $fileService->getFilePathObj($dataImg),
  380.             "permissionName" => (
  381.                 $userLesson->getUserProfile() ? 
  382.                 $userLesson->getUserProfile()->getName() 
  383.                 : null
  384.             ),
  385.         ];
  387.         return $teacher;
  388.     }
  390.     public function getLessonNextContent(Lesson $lesson, ?LessonLog $lessonLog = null)
  391.     {
  392.         $libraryRepository = $this->em->getRepository(Library::class);
  393.         $examRepository = $this->em->getRepository(Exam::class);
  394.         $nextExamLesson = $examRepository->getNextExamIdByLesson($lesson, true);
  395.         $lessonAfter = $this->getLessonIdAfterThat($lesson, true);
  397.         $course = $lesson->getCourse();
  398.         $courseId = $course->getId();
  400.         $isAccessible = false;
  401.         $acessMessage = null;
  403.         $lessonAfterClass = null;
  404.         $nextContent = null;
  405.         if($nextExamLesson || $lessonAfter){
  407.             $contentPagesNumber = null;
  408.             $contentDuration = null;
  409.             $contentType = null;
  410.             $contentThumb = null;
  412.             if($lessonAfter && empty($nextExamLesson)){
  413.                 $lessonAfterClass = $this->find($lessonAfter->id);
  415.                 if($lessonAfterClass){
  416.                     $library = $lessonAfterClass->getLibrary();
  417.                     if($library){
  418.                         $contentPagesNumber = $library->getPagesNumber();
  419.                         $contentDuration = $library->getDuration();
  420.                         $contentType = $library->getType();
  422.                         $libraryType = [
  423.                             LibraryEnum::CONTENT_EMBED, 
  424.                             LibraryEnum::CONTENT_CONFERENCE, 
  425.                             LibraryEnum::CONTENT_TEXT, 
  426.                             LibraryEnum::CONTENT_FILES
  427.                         ];
  428.                         if(!in_array($contentType, $libraryType)){
  429.                             $contentThumb = $libraryRepository->getCover($library);
  430.                         }
  431.                     }
  432.                 }
  433.             }
  435.             if($nextExamLesson){
  436.                 $nextExamLessonClass = $examRepository->find($nextExamLesson->id);
  437.                 $infoAccess = $examRepository->checkExamIsAccessible($nextExamLessonClass);
  438.                 $isAccessible = $infoAccess->isAccessible;
  439.                 $acessMessage = $infoAccess->message;
  440.             }else{
  441.                 $enrollmentRepository = $this->em->getRepository(Enrollment::class);
  442.                 $courseRepository = $this->em->getRepository(Course::class);
  444.                 $enrollment = $enrollmentRepository->findOneBy([
  445.                     "user" => $this->getUser()->getId(),
  446.                     "course" => $courseId,
  447.                 ]);
  449.                 if($enrollment){
  450.                     $isStudent = $courseRepository->isStudent($course);
  451.                     $infoAccess = $this->checkLessonIsAccessibleToUser(
  452.                         $lessonAfterClass, 
  453.                         $enrollment, 
  454.                         $lessonLog, 
  455.                         $isStudent,
  456.                         $lesson->getId()
  457.                     );
  459.                     $isAccessible = $infoAccess->isAccessible;
  460.                     $acessMessage = $infoAccess->message;
  461.                 }
  462.             }
  464.             $module = null;
  466.             if($lessonAfter){
  467.                 $module = (object)[
  468.                     "id" => (int)$lessonAfter->moduleId,
  469.                     "title" => $lessonAfter->moduleTitle,
  470.                 ];
  471.             }
  473.             if($nextExamLesson){
  474.                 $module = null;
  475.                 if(!empty($nextExamLesson->moduleId)){
  476.                     $module = (object)[
  477.                         "id" => (int)$nextExamLesson->moduleId,
  478.                         "title" => $nextExamLesson->moduleTitle,
  479.                     ];
  480.                 }
  481.             }
  483.             $timeUtil = $this->generalService->getUtil('DateTimeUtil');
  485.             $nextContent = (object)[
  486.                 "id" => (int)($nextExamLesson ? $nextExamLesson->id : $lessonAfter->id),
  487.                 "lessonId" => (
  488.                     $nextExamLesson ? 
  489.                     $nextExamLesson->lessonId : 
  490.                     (int)$lessonAfter->id
  491.                 ),
  492.                 "module" => $module,
  493.                 "courseId" => (
  494.                     $nextExamLesson ? 
  495.                     $nextExamLesson->courseId : 
  496.                     (int)$lessonAfter->courseId
  497.                 ),
  498.                 "title" => ($nextExamLesson ? $nextExamLesson->title : $lessonAfter->title),
  499.                 "type" => (
  500.                     $nextExamLesson ? 
  501.                     ($nextExamLesson->type == ExamEnum::QUIZ ? 'quiz' : 'exam') : 
  502.                     'lesson'
  503.                 ),
  504.                 "contentPagesNumber" => $contentPagesNumber,
  505.                 "contentDuration" => $contentDuration ? $timeUtil->timeToSec($contentDuration) : null,
  506.                 "contentType" => $contentType,
  507.                 "contentThumb" => $contentThumb,
  508.                 "isAccessible" => $isAccessible,
  509.                 "acessMessage" => $acessMessage,
  510.             ];
  511.         }
  513.         return $nextContent;
  514.     }
  516.     public function getLessonLastContent(Lesson $lesson)
  517.     {
  518.         $libraryRepository = $this->em->getRepository(Library::class);
  519.         $examRepository = $this->em->getRepository(Exam::class);
  520.         $lastExamLesson = $examRepository->getLastExamIdByLesson($lesson, true);
  521.         $lessonBefore = $this->getLessonIdBeforeThat($lesson, true);
  522.         $timeUtil = $this->generalService->getUtil('DateTimeUtil');
  524.         $lastContent = null;
  525.         if($lastExamLesson || $lessonBefore){
  527.             $contentPagesNumber = null;
  528.             $contentDuration = null;
  529.             $contentType = null;
  530.             $contentThumb = null;
  532.             if($lessonBefore && empty($lastExamLesson)){
  534.                 $lessonBeforeClass = $this->find($lessonBefore->id);
  536.                 if($lessonBeforeClass){
  537.                     $library = $lessonBeforeClass->getLibrary();
  538.                     if($library){
  539.                         $contentPagesNumber = $library->getPagesNumber();
  540.                         $contentDuration = $library->getDuration();
  541.                         $contentType = $library->getType();
  542.                         
  543.                         $libraryType = [
  544.                             LibraryEnum::CONTENT_EMBED, 
  545.                             LibraryEnum::CONTENT_CONFERENCE, 
  546.                             LibraryEnum::CONTENT_TEXT, 
  547.                             LibraryEnum::CONTENT_FILES
  548.                         ];
  549.                         if(!in_array($contentType, $libraryType)){
  550.                             $contentThumb = $libraryRepository->getCover($library);
  551.                         }
  552.                     }
  553.                 }
  554.             }
  556.             $module = (object)[
  557.                 "id" => (int)$lessonBefore->moduleId,
  558.                 "title" => $lessonBefore->moduleTitle,
  559.             ];
  561.             if($lastExamLesson){
  562.                 $module = null;
  563.                 if(!empty($lastExamLesson->moduleId)){
  564.                     $module = (object)[
  565.                         "id" => (int)$lastExamLesson->moduleId,
  566.                         "title" => $lastExamLesson->moduleTitle,
  567.                     ];
  568.                 }
  569.             }
  571.             $lastContent = (object)[
  572.                 "id" => (int)($lastExamLesson ? $lastExamLesson->id : $lessonBefore->id),
  573.                 "lessonId" => (
  574.                     $lastExamLesson ? 
  575.                     $lastExamLesson->lessonId : 
  576.                     (int)$lessonBefore->id
  577.                 ),
  578.                 "module" => $module,
  579.                 "courseId" => (
  580.                     $lastExamLesson ? 
  581.                     $lastExamLesson->courseId : 
  582.                     (int)$lessonBefore->courseId
  583.                 ),
  584.                 "title" => ($lastExamLesson ? $lastExamLesson->title : $lessonBefore->title),
  585.                 "type" => (
  586.                     $lastExamLesson ? 
  587.                     ($lastExamLesson->type == ExamEnum::QUIZ ? 'quiz' : 'exam') : 
  588.                     'lesson'
  589.                 ),
  590.                 "contentPagesNumber" => $contentPagesNumber,
  591.                 "contentDuration" => $contentDuration ? $timeUtil->timeToSec($contentDuration) : null,
  592.                 "contentType" => $contentType,
  593.                 "contentThumb" => $contentThumb,
  594.                 "isAccessible" => true,
  595.                 "acessMessage" => null,
  596.             ];
  597.         }
  599.         return $lastContent;
  600.     }
  602.     public function getShowLiveChat(Lesson $lesson, ?bool $isStudent = true)
  603.     {   
  604.         $library = $lesson->getLibrary();
  606.         if(!$library){
  607.             return LessonEnum::NO;
  608.         }
  610.         if($library->getType() == LibraryEnum::CONTENT_LIVE){
  611.             if($this->configuration->checkModuleIsAbleOnPlan('liveContentFunction')){
  612.                 if($lesson->getShowLiveChat() == LessonEnum::YES){
  613.                     $liveDateStart = $library->getLiveStart();
  615.                     $timeLiveEnd = date('Y-m-d', strtotime($liveDateStart));
  616.                     $timeLiveStart = strtotime($liveDateStart . ' - 1 hours'); 
  617.                     $todayDate = date('Y-m-d');
  618.                     $timeToday = strtotime($todayDate);
  620.                     if(
  621.                         $timeToday >= $timeLiveStart && 
  622.                         $todayDate == $timeLiveEnd || !$isStudent
  623.                     ){
  624.                         return LessonEnum::YES;
  625.                     }
  626.                 }
  627.             }
  628.         }
  630.         return LessonEnum::NO;
  631.     }
  633.     public function findItems(?Course $course)
  634.     {
  635.         $query = $this->createQueryBuilder('l');
  637.         if($course){
  638.             $query->andWhere('l.course = :courseId');
  639.             $query->setParameter('courseId', $course->getId());
  640.         }
  642.         return $query->orderBy('l.order', 'ASC')->getQuery()->getResult();
  643.     }
  645.     public function countLessons()
  646.     {
  647.         $query = $this->createQueryBuilder('l');
  648.         $query->select("COUNT(l.id) AS total");
  649.         $query->andWhere('l.deleted != :deleted');
  650.         $query->setParameter('deleted', LessonEnum::ITEM_DELETED);
  652.         $result = (object)$query->getQuery()->getOneOrNullResult();
  653.         return $result->total;
  654.     }
  656.     public function countLessonByLibrary(int $libraryId, ?Lesson $lesson = null)
  657.     {
  658.         
  659.         $query = $this->createQueryBuilder('l');
  660.         $query->select("COUNT(l.id) AS total");
  662.         $query->andWhere('l.library = :library');
  663.         $query->andWhere('l.deleted != :deleted');
  664.         
  665.         $query->setParameter('deleted', LessonEnum::ITEM_DELETED);
  666.         $query->setParameter('library', $libraryId);
  668.         if(!empty($lesson)){
  669.             $query->andWhere('l.id =! :lessonId');
  670.             $query->setParameter('lessonId', $lesson->getId());
  671.         }
  673.         $result = (object)$query->getQuery()->getOneOrNullResult();
  674.         return $result->total;
  675.     }
  677.     public function countAllLessonByLibraryType(?int $status = null, ?int $type = null)
  678.     {
  679.         $query = $this->createQueryBuilder('l');
  680.         $query->select("COUNT(l.id) AS total");
  682.         if(!is_null($type)){
  683.             $query->innerJoin('EADPlataforma:Library', 'lb', 'WITH', 'lb.id = l.library');
  684.             $query->andWhere('lb.type = :type');
  685.             $query->andWhere('lb.deleted = :deleted');
  687.             $query->setParameter('type', $type);
  688.             $query->setParameter('deleted', LibraryEnum::ITEM_NO_DELETED);
  689.         }
  691.         if(!empty($status)){
  692.             $query->andWhere('l.status = :status');
  693.             $query->setParameter('status', $status);
  694.         }
  696.         $query->andWhere('l.deleted = :deleted');
  697.         $query->setParameter('deleted', LessonEnum::ITEM_NO_DELETED);
  699.         $result = (object)$query->getQuery()->getOneOrNullResult();
  700.         return $result->total;
  701.     }
  703.     public function getAllLessonByLibraryLive(?int $user = null)
  704.     {
  705.         $query = $this->createQueryBuilder('l');
  707.         $query->innerJoin('EADPlataforma:Course', 'c', 'WITH', 'l.course = c.id');
  708.         $query->innerJoin('EADPlataforma:LessonModule', 'lm', 'WITH', 'l.lessonModule = lm.id');
  709.         $query->innerJoin('EADPlataforma:Library', 'lb', 'WITH', 'lb.id = l.library');
  711.         $query->andWhere('(lb.type = :type OR lb.type = :typeExternalLive)');
  712.         $query->setParameter('type', LibraryEnum::CONTENT_LIVE);
  713.         $query->setParameter('typeExternalLive', LibraryEnum::CONTENT_EXTERNAL_LIVE);
  714.         
  716.         if(!empty($user)){
  717.             
  718.             $query->andWhere('(
  719.                 l.user = :user OR 
  720.                 lm.user = :user OR 
  721.                 c.user = :user
  722.             )');
  724.             $query->setParameter('user', $user);
  725.         }
  727.         $query->andWhere('c.deleted = :deletedCourse');
  728.         $query->andWhere('lm.deleted = :deletedLessonModule');
  729.         $query->andWhere('lb.deleted = :deletedLibrary');
  730.         $query->andWhere('l.deleted = :deleted');
  732.         $query->setParameter('deletedCourse', CourseEnum::ITEM_NO_DELETED);
  733.         $query->setParameter('deletedLessonModule', LessonModuleEnum::ITEM_NO_DELETED);
  734.         $query->setParameter('deletedLibrary', LibraryEnum::ITEM_NO_DELETED);
  735.         $query->setParameter('deleted', LessonEnum::ITEM_NO_DELETED);
  737.         $data = $query->getQuery()->getResult();
  739.         return $data;
  740.     }
  742.     public function getAllLessons()
  743.     {
  744.         $query = $this->createQueryBuilder('l');
  746.         $query->select('
  747.             l.id AS lessonId,
  748.             c.id AS courseId,
  749.             lm.id AS lessonModuleId,
  750.             l.title AS lessonTitle,
  751.             c.title AS courseTitle,
  752.             lm.title AS lessonModuleTitle
  753.         ');
  755.         $query->innerJoin(
  756.             'EADPlataforma:Course', 
  757.             'c', 
  758.             'WITH', 
  759.             'c.id = l.course AND c.deleted = :courseDeleted'
  760.         );
  762.         $query->innerJoin(
  763.             'EADPlataforma:LessonModule', 
  764.             'lm', 
  765.             'WITH', 
  766.             'lm.id = l.lessonModule AND lm.deleted = :lessonModuleDeleted'
  767.         );
  769.         $query->andWhere('l.deleted = :lessonDeleted');
  771.         $query->setParameter('courseDeleted', CourseEnum::ITEM_NO_DELETED);
  772.         $query->setParameter('lessonModuleDeleted', LessonModuleEnum::ITEM_NO_DELETED);
  773.         $query->setParameter('lessonDeleted', LessonEnum::ITEM_NO_DELETED);
  775.         $query->addOrderBy('c.order', 'ASC');
  776.         $query->addOrderBy('lm.order', 'ASC');
  777.         $query->addOrderBy('l.order', 'ASC');
  779.         $data = $query->getQuery()->getResult();
  781.         return $data;
  782.     }
  784.     public function getLessonPublicDemoById(int $lessonId)
  785.     {
  786.         $query = $this->createQueryBuilder('l');
  787.         $query->innerJoin(
  788.             'EADPlataforma:LessonModule', 
  789.             'lm', 
  790.             'WITH', 
  791.             'lm.id = l.lessonModule AND lm.deleted = 0'
  792.         );
  794.         $query->innerJoin(
  795.             'EADPlataforma:Course', 
  796.             'c', 
  797.             'WITH', 
  798.             'c.id = l.course AND c.deleted = 0'
  799.         );
  801.         $query->andWhere('l.deleted = 0');
  802.         $query->andWhere('l.id = :lessonId');
  803.         $query->andWhere('l.demonstration = :demonstration');
  804.         $query->andWhere('c.status = :courseStatus');
  805.         $query->andWhere('l.status = :lessonStatus');
  806.         $query->andWhere('lm.status = :lessonModuleStatus');
  808.         $query->setParameter('lessonId', $lessonId);
  809.         $query->setParameter('demonstration', LessonEnum::YES);
  810.         $query->setParameter('courseStatus', CourseEnum::PUBLISHED);
  811.         $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  812.         $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  814.         $data = $query->getQuery()->getOneOrNullResult();
  815.         return $data;
  816.     }
  818.     public function isLessonTeacher(Lesson $lesson, User $user)
  819.     {
  820.         if(!$lesson->getCourse()){
  821.             return false;
  822.         }
  824.         if(!$lesson->getLessonModule()){
  825.             return false;
  826.         }
  828.         $courseTeacherId = $lesson->getCourse()->getUser()->getId();
  829.         $lessonModuleTeacherId = $lesson->getLessonModule()->getUser()->getId();
  830.         $lessonTeacherId = $lesson->getUser()->getId();
  832.         if(
  833.             $courseTeacherId == $user->getId() || 
  834.             $lessonModuleTeacherId == $user->getId() || 
  835.             $lessonTeacherId == $user->getId()
  836.         ){
  837.             return true;
  838.         }
  840.         return false;
  841.     }
  843.     public function checkLessonIsAccessibleToUser(
  844.         Lesson $lesson, 
  845.         Enrollment $enrollment, 
  846.         ?LessonLog $log = null, 
  847.         ?bool $isStudent = true,
  848.         ?int $lessonIdBefore = null,
  849.         ?bool $blockIsNotAccess = false
  850.     )
  851.     {
  852.         $info = (object)[
  853.             "isAccessible" => false,
  854.             "isAccessPeriodExpired" => false,
  855.             "message" => null,
  856.         ];
  858.         if(!$this->getUser()){
  860.             $info->message = $this->configuration->getLanguage('error_auth', 'lesson_view_error');
  862.             return $info;
  863.         }
  865.         $user = $enrollment->getUser();
  866.         $course = $lesson->getCourse();
  867.         $lessonModule = $lesson->getLessonModule();
  869.         $today = strtotime('now');
  870.         if(!$isStudent){
  872.             $info->isAccessible = true;
  874.             return $info;
  875.         }
  877.         if(!$enrollment){
  879.             $info->message = $this->configuration->getLanguage(
  880.                 'error_enrollment_not_found',
  881.                 'lesson_view'
  882.             );
  884.             return $info;
  885.         }
  887.         if(
  888.             $lesson->getStatus() == LessonEnum::DRAFT ||
  889.             $lessonModule->getStatus() == LessonModuleEnum::DRAFT ||
  890.             $course->getStatus() == CourseEnum::DRAFT
  891.         ){
  892.             $info->message = $this->configuration->getLanguage(
  893.                 'error_unavailable',
  894.                 'lesson_view'
  895.             );
  897.             return $info;
  898.         }
  900.         if($enrollment->getStatus(false, true) == EnrollmentEnum::STATUS_EXPIRED){
  901.             
  902.             $info->message = $this->configuration->getLanguage(
  903.                 'error_enrollment_expired', 
  904.                 'lesson_view_error'
  905.             );
  907.             return $info;
  908.         }
  910.         $courseDateRelease = strtotime($course->getDateRelease());
  911.         if($courseDateRelease >= $today){
  913.             $info->message = "{$this->configuration->getLanguage(
  914.                 'error_date_release', 
  915.                 'lesson_view_error'
  916.             )} {$course->getDateRelease('d/m/Y')}";
  918.             return $info;
  919.         }
  921.         $lessonModuleRepository = $this->em->getRepository(LessonModule::class);
  922.         $moduleInfo = $lessonModuleRepository->checkLessonModuleIsAccessibleToUser(
  923.             $lessonModule, 
  924.             $enrollment, 
  925.             $isStudent,
  926.             $lessonIdBefore
  927.         );
  928.         
  929.         if(!$moduleInfo->isAccessible) {
  931.             return $moduleInfo;
  932.         }
  934.         $unlimitedexamFunction = $this->configuration->checkModuleIsAbleOnPlan(
  935.             'unlimitedExamFunction'
  936.         );
  938.         $hasLessonControl = $this->configuration->checkModuleIsAbleOnPlan(
  939.             'lessonControlFunction'
  940.         );
  942.         $examModule = $this->configuration->isModuleActive("exam_module");
  944.         if(!$hasLessonControl){
  945.             $info->isAccessible = true;
  947.             return $info;
  948.         }
  950.         $lessonLogRepository = $this->emEadmin->getRepository(LessonLog::class);
  951.         if(empty($log)){
  952.             $logLessonId = "{$course->getId()}#{$user->getId()}#{$lesson->getId()}";
  953.             $log = $lessonLogRepository->find($logLessonId);
  954.         }
  956.         if($log && !empty($log->getDateConclusion())){
  957.             $info->isAccessible = true;
  959.             $periodEnd = $lesson->getControlClosePeriod();
  960.             if(!empty($periodEnd)){
  961.                 $dateEnd = strtotime("{$log->getDateConclusion()} + {$periodEnd} days");
  962.                 if($dateEnd < $today){                    
  963.                     $info->isAccessible = false;
  964.                     $info->isAccessPeriodExpired = true;
  965.                 }
  966.             }
  968.             return $info;
  969.         }
  971.         if($blockIsNotAccess){
  972.             $info->message = $this->configuration->getLanguage(
  973.                 'error_required_incomplete', 
  974.                 'lesson_view_error'
  975.             );
  977.             return $info;
  978.         }
  980.         if($examModule){
  981.             if($log && empty($log->getDateConclusion()) || !$log){
  983.                 $examUserRepository = $this->em->getRepository(ExamUser::class);
  984.                 $currentExam = $examUserRepository->getCurrentExamOnCourseToUserByLesson(
  985.                     $lesson, 
  986.                     $user
  987.                 );
  988.                 if($currentExam){
  989.                     if($unlimitedexamFunction){
  990.                         //check the exam type
  991.                         if($currentExam->getType() == ExamEnum::LESSON){
  992.                             $lessonExam = $currentExam->getLesson();
  993.                             $lessonModuleExam = $lessonExam->getLessonModule();
  995.                             //if exam is from this lesson redirect to exam
  996.                             if($lessonExam->getId() != $lesson->getId()){
  997.                                 //if the exam is from a module before that redirect to exam
  998.                                 if($lessonModuleExam->getOrder() < $lessonModule->getOrder()){
  999.                                     $info->message = $this->configuration->getLanguage(
  1000.                                         'error_required_incomplete', 
  1001.                                         'lesson_view_error'
  1002.                                     );
  1004.                                     return $info;
  1005.                                 }else if(
  1006.                                     $lessonExam->getOrder() < $lesson->getOrder() && 
  1007.                                     $lessonModuleExam->getId() == $lessonModule->getId()
  1008.                                 ){ //if is the same module but the lesson is before that rediret to exam
  1009.                                     $info->message = $this->configuration->getLanguage(
  1010.                                         'error_required_incomplete', 
  1011.                                         'lesson_view_error'
  1012.                                     );
  1014.                                     return $info;
  1015.                                 }
  1016.                             }
  1017.                         }else if($currentExam->getType() == ExamEnum::MODULE){
  1018.                             $lessonModuleExam = $currentExam->getLessonModule();
  1019.                             
  1020.                             if(
  1021.                                 $lessonModuleExam->getId() != $lessonModule->getId() && 
  1022.                                 $lessonModuleExam->getOrder() < $lessonModule->getOrder()
  1023.                             ){ //if is not the same module and the module is before that rediret to exam
  1024.                                 $info->message = $this->configuration->getLanguage(
  1025.                                     'error_required_incomplete', 
  1026.                                     'lesson_view_error'
  1027.                                 );
  1029.                                 return $info;
  1030.                             }
  1031.                         }
  1032.                     }
  1034.                     if($currentExam->getType() == ExamEnum::COURSE){
  1035.                         $info->message = $this->configuration->getLanguage(
  1036.                             'error_required_incomplete', 
  1037.                             'lesson_view_error'
  1038.                         );
  1040.                         return $info;
  1041.                     }
  1042.                 }
  1044.                 if($unlimitedexamFunction){
  1045.                     $examRepository = $this->em->getRepository(Exam::class);
  1046.                     $exam = $examRepository->getCurrentNotStartedExamUser(
  1047.                         $lesson, 
  1048.                         $user
  1049.                     );
  1051.                     if($exam){
  1052.                         $lessonExam = $exam->getLesson();
  1053.                         if(!$lessonExam || $lessonExam->getId() != $lesson->getId()){
  1055.                             $info->message = $this->configuration->getLanguage(
  1056.                                 'error_required_incomplete', 
  1057.                                 'lesson_view_error'
  1058.                             );
  1060.                             return $info;
  1061.                         }
  1062.                     }
  1063.                 }
  1064.             }
  1065.         }
  1067.         //if exist a lesson with requirement before that redirect to there
  1068.         $currentLesson = $this->getCurrentLesson($lesson, $user);
  1069.         if(!empty($currentLesson)){
  1070.             if($currentLesson->getId() != $lesson->getId()){
  1071.                 $logId = "{$course->getId()}#{$user->getId()}#{$currentLesson->getId()}";
  1072.                 $logCurrent = $lessonLogRepository->find($logId);
  1074.                 if(empty($logCurrent)){
  1075.                     $info->message = $this->configuration->getLanguage(
  1076.                         'error_required_incomplete', 
  1077.                         'lesson_view_error'
  1078.                     );
  1080.                     return $info;
  1081.                 }else if(empty($logCurrent->getDateConclusion())){
  1082.                     $info->message = $this->configuration->getLanguage(
  1083.                         'error_required_incomplete', 
  1084.                         'lesson_view_error'
  1085.                     );
  1087.                     return $info;
  1088.                 }
  1089.             }
  1090.         }
  1092.         if($lesson->getControlReleaseType() == LessonEnum::RELEASED){
  1093.             $info->isAccessible = true;
  1095.             return $info;
  1096.         }else if($lesson->getControlReleaseType() == LessonEnum::FIXED_DATE){
  1097.             $controlDateRelease = $lesson->getControlDateRelease();
  1098.             $time = strtotime($controlDateRelease);
  1100.             $todaySeconds = strtotime(date('Y-m-d H:i:s'));
  1101.            
  1102.             $controlClosePeriod = $lesson->getControlClosePeriod();
  1103.             if(!empty($controlClosePeriod)){
  1104.                 $timeLog = strtotime(
  1105.                     "{$controlDateRelease} + {$controlClosePeriod} day"
  1106.                 );
  1108.                 if($todaySeconds > $timeLog){
  1110.                     $timeLogText = date('d/m/Y H:i:s', $timeLog);
  1112.                     $info->message = "{$this->configuration->getLanguage(
  1113.                         'error_date_end', 
  1114.                         'lesson_view_error'
  1115.                     )} {$timeLogText}";
  1117.                     return $info;
  1118.                 }
  1119.             }
  1120.            
  1121.             if($today >= $time){
  1122.                 $info->isAccessible = true;
  1124.                 return $info;
  1125.             }
  1127.             $timeText = date('d/m/Y H:i:s', $time);
  1128.                         
  1129.             $info->message = "{$this->configuration->getLanguage(
  1130.                 'error_date_release', 
  1131.                 'lesson_view_error'
  1132.             )} {$timeText}";
  1134.             return $info;
  1136.         }else if($lesson->getControlReleaseType() == LessonEnum::FLEXIBLE_DATE){
  1137.             $controlReleasePeriod = $lesson->getControlReleasePeriod();
  1138.             if($lesson->getControlReleaseAfterType() == LessonEnum::ENROLLMENT){
  1139.                 $time = strtotime(
  1140.                     "{$enrollment->getDateRegister()} + {$controlReleasePeriod} day"
  1141.                 );
  1142.                 
  1143.                 $todaySeconds = strtotime(date('Y-m-d H:i:s'));
  1144.                 $controlClosePeriod = $lesson->getControlClosePeriod();
  1145.                 if(!empty($controlClosePeriod)){
  1146.                     
  1147.                     /*
  1148.                     if($log && empty($log->getDateConclusion()) || !$log){
  1149.                         return false;
  1150.                     }
  1151.                     
  1152.                     if($log->getComplete() == LessonEnum::NO){
  1153.                         return false;
  1154.                     }*/
  1156.                     if($log && !empty($log->getDateConclusion())){
  1157.                         $timeLog = strtotime(
  1158.                             "{$log->getDateConclusion()} + {$controlClosePeriod} day"
  1159.                         );
  1161.                         if($todaySeconds > $timeLog){
  1162.                             $timeLogText = date('d/m/Y H:i:s', $timeLog);
  1164.                             $info->message = "{$this->configuration->getLanguage(
  1165.                                 'error_date_end', 
  1166.                                 'lesson_view_error'
  1167.                             )} {$timeLogText}";
  1169.                             return $info;
  1170.                         }
  1171.                     }
  1172.                 }
  1173.                 
  1174.                 if($today >= $time){
  1175.                     $info->isAccessible = true;
  1177.                     return $info;
  1178.                 }
  1180.                 $timeText = date('d/m/Y H:i:s', $time);
  1181.                         
  1182.                 $info->message = "{$this->configuration->getLanguage(
  1183.                     'error_date_release', 
  1184.                     'lesson_view_error'
  1185.                 )} {$timeText}";
  1187.                 return $info;
  1188.             }else if(
  1189.                 $lesson->getControlReleaseAfterType() == LessonEnum::LAST_LESSON && 
  1190.                 !empty($lessonIdBefore)
  1191.             ){
  1192.                 $logId = "{$course->getId()}#{$user->getId()}#{$lessonIdBefore}";
  1193.                 $logLast = $lessonLogRepository->find($logId);
  1194.                 
  1195.                 if($logLast && !empty($logLast->getDateConclusion())){
  1196.                     $time = strtotime(
  1197.                         "{$logLast->getDateConclusion()} + {$controlReleasePeriod} day"
  1198.                     );
  1199.                     if($today >= $time){
  1200.                         $info->isAccessible = true;
  1202.                         return $info;
  1203.                     }
  1204.                 }
  1205.             }
  1206.         }
  1208.         $info->message = $this->configuration->getLanguage('error_unavailable', 'lesson_view_error');
  1210.         return $info;
  1211.     }
  1213.     public function getLessonDateReleaseAccess(
  1214.         Lesson $lesson, 
  1215.         Enrollment $enrollment, 
  1216.         ?bool $isStudent = true, 
  1217.         ?int $lessonIdBefore = null
  1218.     )
  1219.     {
  1220.         $date = date('Y-m-d H:i:s');
  1222.         if(!$this->getUser()){
  1223.             return $date;
  1224.         }
  1226.         $user = $enrollment->getUser();
  1227.         $course = $lesson->getCourse();
  1228.         $today = strtotime('now');
  1230.         if(!$isStudent){
  1231.             return $date;
  1232.         }
  1234.         if(!$enrollment){
  1235.             return $date;
  1236.         }
  1238.         $lessonLogRepository = $this->emEadmin->getRepository(LessonLog::class);
  1239.         if($lesson->getStatus() == LessonEnum::PUBLISHED){
  1240.             if($lesson->getControlReleaseType() == LessonEnum::RELEASED){
  1241.                 return $date;
  1242.             }else if($lesson->getControlReleaseType() == LessonEnum::FIXED_DATE){
  1243.                 return $lesson->getControlDateRelease();
  1244.             }else if($lesson->getControlReleaseType() == LessonEnum::FLEXIBLE_DATE){
  1245.                 $controlReleasePeriod = $lesson->getControlReleasePeriod();
  1246.                 if($lesson->getControlReleaseAfterType() == LessonEnum::ENROLLMENT){
  1247.                     $time = strtotime(
  1248.                         "{$enrollment->getDateRegister()} + {$controlReleasePeriod} day"
  1249.                     );
  1250.                     return date('Y-m-d H:i:s', $time);
  1251.                 }else if(
  1252.                     $lesson->getControlReleaseAfterType() == LessonEnum::LAST_LESSON && 
  1253.                     !empty($lessonIdBefore)
  1254.                 ){
  1255.                     $logId = "{$course->getId()}#{$user->getId()}#{$lessonIdBefore}";
  1256.                     $logLast = $lessonLogRepository->find($logId);
  1258.                     if($logLast){
  1259.                         $time = strtotime(
  1260.                             "{$logLast->getDateConclusion()} + {$controlReleasePeriod} day"
  1261.                         );
  1262.                         return date('Y-m-d H:i:s', $time);
  1263.                     }
  1264.                 }
  1265.             }
  1266.         }
  1268.         return $date;
  1269.     }
  1271.     public function getCurrentLessonLogOrigin(Lesson $lessonBase)
  1272.     {
  1274.         $course = $lessonBase->getCourse();
  1275.         $lessonModule = $lessonBase->getLessonModule();
  1277.         $query = $this->createQueryBuilder('l');
  1278.         $query->select('l.id');
  1279.         $query->innerJoin(
  1280.             'EADPlataforma:LessonModule', 
  1281.             'lm', 
  1282.             'WITH', 
  1283.             'lm.id = l.lessonModule'
  1284.         );
  1286.         $query->leftJoin(
  1287.             'EADPlataforma:LessonLogOrigin', 
  1288.             'lg', 
  1289.             'WITH', 
  1290.             'lg.lesson = l.id AND lg.user = :user'
  1291.         );
  1293.         $query->andWhere('l.deleted = 0');
  1294.         $query->andWhere('lm.deleted = 0');
  1295.         $query->andWhere('l.controlRequirement = :requirement');
  1296.         $query->andWhere('l.status = :lessonStatus');
  1297.         $query->andWhere('lm.status = :lessonModuleStatus');
  1298.         $query->andWhere('l.course = :course');
  1300.         if($lessonBase->getOrder() == LessonEnum::YES){
  1301.             $query->andWhere('(
  1302.                 ( l.order <= :orderL AND lm.order = :orderLM ) OR ( lm.order < :orderLM )
  1303.             )');
  1304.         }else{
  1305.             $query->andWhere('(
  1306.                 ( l.order < :orderL AND lm.order = :orderLM ) OR ( lm.order < :orderLM )
  1307.             )');
  1308.         }
  1310.         $query->andWhere('lg.dateConclusion IS NULL');
  1312.         $query->setParameter('user', $this->getUser()->getId());
  1313.         $query->setParameter('course', $lessonBase->getCourse()->getId());
  1314.         $query->setParameter('requirement', LessonEnum::YES);
  1315.         $query->setParameter('orderL', $lessonBase->getOrder());
  1316.         $query->setParameter('orderLM', $lessonModule->getOrder());
  1317.         $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  1318.         $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  1320.         $query->addOrderBy('lm.order', 'ASC');
  1321.         $query->addOrderBy('l.order', 'ASC');
  1323.         $query->setMaxResults(1);
  1325.         $lesson = (object)$query->getQuery()->getOneOrNullResult();
  1327.         if(!empty($lesson->id)){
  1328.             return $this->findOneBy([ "id" => $lesson->id ]);
  1329.         }
  1331.         return;
  1332.     }
  1334.     public function getCurrentLesson(Lesson $lessonBase, User $user)
  1335.     {
  1336.         $course = $lessonBase->getCourse();
  1337.         $lessonModule = $lessonBase->getLessonModule();
  1339.         $query = $this->createQueryBuilder('l');
  1340.         $query->select('l.id');
  1342.         $query->innerJoin('EADPlataforma:Course', 'c', 'WITH', 'c.id = l.course');
  1344.         $query->innerJoin(
  1345.             'EADPlataforma:LessonModule', 'lm', 'WITH', 'lm.id = l.lessonModule'
  1346.         );
  1348.         $query->innerJoin('EADPlataforma:Library', 'lb', 'WITH', 'lb.id = l.library');
  1349.         
  1350.         $query->andWhere('c.deleted = 0');
  1351.         $query->andWhere('l.deleted = 0');
  1352.         $query->andWhere('lm.deleted = 0');
  1353.         $query->andWhere('lb.deleted = 0');
  1355.         $query->andWhere('l.controlRequirement = :requirement');
  1356.         $query->andWhere('l.status = :lessonStatus');
  1357.         $query->andWhere('lm.status = :lessonModuleStatus');
  1358.         $query->andWhere('l.course = :course');
  1359.         $query->andWhere('l.id != :lessonBase');
  1361.         if($lessonBase->getOrder() == LessonEnum::YES){
  1362.             $query->andWhere('(
  1363.                 ( l.order <= :orderL AND lm.order = :orderLM ) OR ( lm.order < :orderLM )
  1364.             )');
  1365.         }else{
  1366.             $query->andWhere('(
  1367.                 ( l.order < :orderL AND lm.order = :orderLM ) OR ( lm.order < :orderLM )
  1368.             )');
  1369.         }
  1371.         $query->setParameter('course', $lessonBase->getCourse()->getId());
  1372.         $query->setParameter('requirement', LessonEnum::YES);
  1373.         $query->setParameter('orderL', $lessonBase->getOrder());
  1374.         $query->setParameter('orderLM', $lessonModule->getOrder());
  1375.         $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  1376.         $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  1377.         $query->setParameter('lessonBase', $lessonBase->getId());
  1379.         $query->addOrderBy('lm.order', 'DESC');
  1380.         $query->addOrderBy('l.order', 'DESC');
  1382.         $query->setMaxResults(1);
  1384.         $lesson = (object)$query->getQuery()->getOneOrNullResult();
  1386.         if(!empty($lesson->id)){
  1387.             $logId = "{$course->getId()}#{$user->getId()}#{$lesson->id}";
  1388.             $log = $this->emEadmin->getRepository(LessonLog::class)->find($logId);
  1390.             if(!$log || ($log && empty($log->getDateConclusion()))){
  1391.                 return $this->findOneBy([ "id" => $lesson->id ]);
  1392.             }
  1393.         }
  1395.         return;
  1396.     }
  1398.     public function getCourseLessonsIds(
  1399.         Course $course, 
  1400.         ?LessonModule $lessonModule = null, 
  1401.         ?string $searchText = null
  1402.     )
  1403.     {
  1404.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  1405.         $permission = $userPermissionUtil->getPermission("course", "see");
  1406.         $user = $userPermissionUtil->getUser();
  1407.         $lessonModuleId = ($lessonModule ? $lessonModule->getId() : null);
  1409.         $keyCache = md5(
  1410.             "getCourseLessonsIds{$course->getId()}-{$user->getId()}-{$lessonModuleId}"
  1411.         );
  1413.         if(isset($this->lessonIdsCourse[$keyCache])){
  1414.             return $this->lessonIdsCourse[$keyCache];
  1415.         }
  1417.         $isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
  1418.             $course, 
  1419.             $user
  1420.         );
  1421.         
  1422.         $query = $this->createQueryBuilder('l');
  1424.         $query->select('
  1425.             l.id, 
  1426.             l.title,
  1427.             IDENTITY(l.course) AS courseId,
  1428.             IDENTITY(l.lessonModule) AS moduleId,
  1429.             lm.title AS moduleTitle
  1430.         ');
  1432.         $query->innerJoin(
  1433.             'EADPlataforma:LessonModule', 'lm', 'WITH', 'lm.id = l.lessonModule'
  1434.         );
  1436.         if(!empty($searchText)){
  1437.             $query->andWhere('l.title LIKE :searchText');
  1438.             $query->setParameter('searchText', "%{$searchText}%");
  1439.         }
  1441.         $query->andWhere('l.deleted = 0');
  1442.         $query->andWhere('lm.deleted = 0');
  1444.         $query->andWhere('l.course = :courseId');
  1445.         $query->setParameter('courseId', $course->getId());
  1447.         if($lessonModule){
  1448.             $query->andWhere('l.lessonModule = :lessonModuleId');
  1449.             $query->setParameter('lessonModuleId', $lessonModule->getId());
  1450.         }
  1452.         if(
  1453.             $userPermissionUtil->isLow($permission) || 
  1454.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  1455.         ){
  1457.             $query->andWhere('l.status = :lessonStatus');
  1458.             $query->andWhere('lm.status = :lessonModuleStatus');
  1459.             $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  1460.             $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  1461.         }
  1462.         
  1463.         $query->addOrderBy('lm.order', 'ASC');
  1464.         $query->addOrderBy('l.order', 'ASC');
  1465.         
  1466.         $data = $query->getQuery()->execute();
  1468.         $this->lessonIdsCourse[$keyCache] = $data;
  1470.         return $this->lessonIdsCourse[$keyCache];
  1471.     }
  1473.     public function getLessonIdBeforeThat(Lesson $lessonBase, bool $complete = false)
  1474.     {
  1475.         $lessons = $this->getCourseLessonsIds($lessonBase->getCourse());
  1477.         foreach ($lessons as $key => $lesson) {
  1478.             $lesson = (object)$lesson;
  1479.             if($lesson->id == $lessonBase->getId()){
  1480.                 if($key == 0){
  1481.                     return;
  1482.                 }else{
  1483.                     $obj = (object)$lessons[$key-1];
  1485.                     if($complete){
  1486.                         return $obj;
  1487.                     }
  1488.                     
  1489.                     return $obj->id;
  1490.                 }
  1491.             }
  1492.         }
  1493.         return;
  1494.     }
  1496.     public function getLessonIdAfterThat(Lesson $lessonBase, bool $complete = false)
  1497.     {
  1498.         $lessons = $this->getCourseLessonsIds($lessonBase->getCourse());
  1499.         $maxPosition = count($lessons) - 1;
  1501.         foreach ($lessons as $key => $lesson) {
  1502.             $lesson = (object)$lesson;
  1503.             if($lesson->id == $lessonBase->getId()){
  1504.                 if($key == $maxPosition){
  1505.                     return;
  1506.                 }else{
  1507.                     $obj = (object)$lessons[$key+1];
  1509.                     if($complete){
  1510.                         return $obj;
  1511.                     }
  1513.                     return $obj->id;
  1514.                 }
  1515.             }
  1516.         }
  1517.         return;
  1518.     }
  1520.     public function refreshOrder(
  1521.         $courseId, 
  1522.         $lessonModuleId, 
  1523.         $oldOrder, 
  1524.         $newOrder, 
  1525.         $isDelete = false
  1526.     )
  1527.     {
  1528.         $sql = "UPDATE EADPlataforma:Lesson AS l 
  1529.                 SET l.order = l.order - 1 
  1530.                 WHERE l.order > :oldOrder
  1531.                 AND l.deleted = 0
  1532.                 AND l.course = :courseId
  1533.                 AND l.lessonModule = :lessonModuleId ";
  1534.         
  1535.         $query = $this->em->createQuery($sql);
  1537.         $query->setParameter('oldOrder', $oldOrder);
  1538.         $query->setParameter('courseId', $courseId);
  1539.         $query->setParameter('lessonModuleId', $lessonModuleId);
  1540.         
  1541.         $query->execute();
  1543.         if(!$isDelete){
  1544.             $sql = "UPDATE EADPlataforma:Lesson AS l 
  1545.                     SET l.order = l.order + 1 
  1546.                     WHERE l.order >= :newOrder
  1547.                     AND l.deleted = 0
  1548.                     AND l.course = :courseId
  1549.                     AND l.lessonModule = :lessonModuleId ";
  1550.             $query = $this->em->createQuery($sql);
  1551.             
  1552.             $query->setParameter('newOrder', $newOrder);
  1553.             $query->setParameter('courseId', $courseId);
  1554.             $query->setParameter('lessonModuleId', $lessonModuleId);
  1556.             $query->execute();
  1557.         }
  1558.     }
  1560.     public function copyLesson(
  1561.         LessonModule $newModule, 
  1562.         Lesson $lesson, 
  1563.         $isPartial = false,
  1564.         $isModulePartial = false, 
  1565.         $copyType = null
  1566.     )
  1567.     {
  1568.         $course = $newModule->getCourse();
  1569.         $courseId = $course->getId();
  1570.     
  1571.         $newLesson = clone $lesson;
  1572.         $newLesson->setLessonModule($newModule);
  1573.         $newLesson->setCourse($course);
  1575.         if($copyType == LessonEnum::COPY_PUBLISHED){
  1576.             $newLesson->setStatus(LessonEnum::PUBLISHED);
  1577.         }else if($copyType == LessonEnum::COPY_DRAFT){
  1578.             $newLesson->setStatus(LessonEnum::DRAFT);
  1579.         }
  1580.         
  1581.         if($isPartial){
  1582.             $lastOrder = $this->count([ 
  1583.                 "course" => $courseId,
  1584.                 "lessonModule" => $newModule->getId(),
  1585.                 "deleted" => LessonEnum::ITEM_NO_DELETED 
  1586.             ]);
  1587.             $newLesson->setOrder($lastOrder + 1);
  1588.         }
  1590.         $this->em->persist($newLesson);
  1591.         $this->em->flush();
  1593.         if($isPartial || $isModulePartial){
  1594.             $userLessonId = $newLesson->getUser()->getId();
  1595.             $courseTeam = $this->em->getRepository(CourseTeam::class)->findOneBy([
  1596.                 "course" => $courseId, 
  1597.                 "user" => $userLessonId,
  1598.                 "deleted" => LessonEnum::ITEM_NO_DELETED
  1599.             ]);
  1600.             
  1601.             if(!$courseTeam){
  1602.                 $newCourseTeam = new CourseTeam();
  1603.                 $newCourseTeam->setCourse($course);
  1604.                 $newCourseTeam->setUser($newLesson->getUser());
  1606.                 $this->em->persist($newCourseTeam);
  1607.                 $this->em->flush();
  1608.             }
  1609.         }
  1610.         
  1611.         $files = $this->em->getRepository(LessonXLibrary::class)->findBy([
  1612.             "lesson"=> $lesson->getId(),
  1613.             "deleted"=> LessonXLibraryEnum::ITEM_NO_DELETED
  1614.         ]);
  1615.         
  1616.         if($files){
  1617.             foreach ($files as $key => $file) {
  1618.                 $newFile = clone $file;
  1619.                 $newFile->setLesson($newLesson);
  1620.                 
  1621.                 $this->em->persist($newFile);
  1622.                 $this->em->flush();
  1623.             }
  1624.         }
  1625.         
  1626.         $this->em->getRepository(Exam::class)->copyExamByLesson($lesson, $newLesson);
  1627.         $this->em->getRepository(Exam::class)->copyQuizByLesson($lesson, $newLesson);
  1628.     }
  1630.     public function notifyStudentsLesson(Lesson $lesson, $type)
  1631.     {   
  1632.         if(!$this->configuration->checkModuleIsAbleOnPlan('notificationFunction')){
  1633.             return;
  1634.         }
  1636.         $today = date('Y-m-d');
  1637.         $dateLastNotify = $lesson->getDateLastNotify('Y-m-d');
  1639.         if($today != $dateLastNotify && $lesson->getStatus() == LessonEnum::PUBLISHED){
  1640.             $course = $lesson->getCourse();
  1641.             $lessonModule = $lesson->getLessonModule();
  1643.             if(
  1644.                 $course->getStatus() == CourseEnum::PUBLISHED && 
  1645.                 $lessonModule->getStatus() == LessonModuleEnum::PUBLISHED
  1646.             ){
  1647.                 $taskQueueService = $this->generalService->getService('TaskQueueService');
  1648.                 $enrollmentRepository = $this->em->getRepository(Enrollment::class);
  1649.                 
  1650.                 $enrollments = $enrollmentRepository->getEnrollmentsByCourse(
  1651.                     $course->getId(), 
  1652.                     EnrollmentEnum::STATUS_ACTIVE
  1653.                 );
  1655.                 foreach ($enrollments as $key => $enrollment) {
  1656.                     $taskQueueService->insert($type, $enrollment->getUser(), $lesson->getId());
  1657.                 }
  1659.                 $lesson->setDateLastNotify(date('Y-m-d H:i:s'));
  1660.                 $this->em->flush();
  1661.             }
  1662.         }
  1663.     }
  1665.     public function lessonUpdateOrder($modules)
  1666.     {
  1667.         $dqlModule = "UPDATE EADPlataforma:LessonModule AS lm SET lm.order = CASE";
  1668.         $idModules = "";
  1670.         $dqlExam = "";
  1671.         $newModuleId = "";
  1672.         $whereExam = "";
  1674.         $caseLesson1 = " l.order = CASE ";
  1675.         $caseLesson2 = " l.lessonModule = CASE ";
  1676.         $caseLesson3 = " e.lessonModule = CASE ";
  1678.         $idsLesson = "";
  1680.         foreach ($modules as $key => $value) {
  1681.             
  1682.             $orderNew = $key + 1;
  1683.             $dqlModule .= " WHEN lm.id = {$value->moduleId} THEN {$orderNew}";
  1685.             if(empty($idModules)){
  1686.                 $idModules .= "{$value->moduleId}";
  1687.             }else{
  1688.                 $idModules .= ", {$value->moduleId}";
  1689.             }
  1691.             foreach ($value->lessons as $key_lesson => $valLesson) {
  1692.                 if(!empty($valLesson->lessonId)){
  1693.                     $ordemNewLesson = $key_lesson + 1;
  1694.                 
  1695.                     $caseLesson1 .= " WHEN l.id = {$valLesson->lessonId} THEN {$ordemNewLesson}";
  1696.                     $caseLesson2 .= " WHEN l.id = {$valLesson->lessonId} THEN {$value->moduleId}";
  1697.                     $caseLesson3 .= " WHEN e.lesson = {$valLesson->lessonId} THEN {$value->moduleId}";
  1698.                 
  1699.                     if(empty($idsLesson)){
  1700.                         $idsLesson .= " {$valLesson->lessonId} ";
  1701.                     }else{
  1702.                         $idsLesson .= ", {$valLesson->lessonId} ";
  1703.                     }
  1704.                 }
  1705.             }
  1706.         }
  1707.         
  1708.         $dqlModule .= " ELSE lm.order END WHERE lm.id IN ({$idModules}) ";
  1710.         $dqlLesson = "UPDATE EADPlataforma:Lesson AS l 
  1711.                       SET {$caseLesson1} ELSE l.order END, 
  1712.                           {$caseLesson2} ELSE IDENTITY(l.lessonModule) END 
  1713.                      WHERE l.id IN ({$idsLesson}) ";
  1715.         $dqlExam = "UPDATE EADPlataforma:Exam AS e
  1716.                     SET {$caseLesson3} ELSE IDENTITY(e.lessonModule) END 
  1717.                     WHERE e.lesson IN ({$idsLesson}) ";
  1719.         $query = $this->em->createQuery($dqlModule);
  1720.         $queryLesson = $this->em->createQuery($dqlLesson);
  1721.         $queryExam = $this->em->createQuery($dqlExam);
  1723.         $query->execute();
  1724.         $queryLesson->execute();
  1725.         $queryExam->execute();
  1726.     }
  1728.     public function getLessonPublicNumber(
  1729.         Course $course, 
  1730.         ?LessonModule $lessonModule = null,
  1731.         ?bool $required = false, 
  1732.         ?bool $filterModule = false
  1733.     )
  1734.     {
  1735.         $query = $this->createQueryBuilder('l');
  1736.         $query->select('COUNT(l.id) AS total');
  1737.         $query->innerJoin(
  1738.             'EADPlataforma:LessonModule', 
  1739.             'lm', 
  1740.             'WITH', 
  1741.             'lm.id = l.lessonModule AND lm.deleted = :deleted'
  1742.         );
  1744.         $query->innerJoin(
  1745.             'EADPlataforma:Course', 
  1746.             'c', 
  1747.             'WITH', 
  1748.             'c.id = l.course AND c.deleted = :deleted'
  1749.         );
  1751.         if($lessonModule){
  1752.             $query->andWhere('lm.order <= :lessonModuleOrder');
  1753.             $query->setParameter('lessonModuleOrder', $lessonModule->getOrder());
  1755.             if($filterModule){
  1756.                 $query->andWhere('lm.id = :lessonModule');
  1757.                 $query->setParameter('lessonModule', $lessonModule->getId());
  1758.             }
  1759.         }
  1761.         if($required){
  1762.             $query->andWhere('l.controlRequirement = :required');
  1763.             $query->setParameter('required', LessonEnum::YES);
  1764.         }
  1766.         $query->andWhere('l.deleted = :deleted');
  1767.         $query->andWhere('l.course = :courseId');
  1768.         $query->andWhere('l.status = :lessonStatus');
  1769.         $query->andWhere('lm.status = :lessonModuleStatus');
  1770.         
  1771.         $query->setParameter('courseId', $course->getId());
  1772.         $query->setParameter('deleted', LessonEnum::ITEM_NO_DELETED);
  1773.         $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  1774.         $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  1775.         $query->setMaxResults(1);
  1777.         $result = (object)$query->getQuery()->getOneOrNullResult();
  1778.         return $result->total;
  1779.     }
  1781.     public function countCourseLessons(
  1782.         Course $course,
  1783.         int $userId,
  1784.         ?LessonModule $lessonModule = null, 
  1785.         $isHistory = false
  1786.     )
  1787.     {
  1788.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  1790.         $permission = $userPermissionUtil->getPermission("course", "see");
  1791.         $user = $userPermissionUtil->getUser();
  1792.         $isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
  1793.             $course, 
  1794.             $user
  1795.         );
  1797.         $sqlDateConclusion = "
  1798.             SELECT
  1799.                 (
  1800.                     CASE 
  1801.                         WHEN ll.complete = :yes THEN ll.date_conclusion 
  1802.                         ELSE CURDATE() 
  1803.                     END
  1804.                 ) AS date_conclusion
  1805.             FROM lesson_log AS ll
  1806.             WHERE ll.lesson_id = l.id
  1807.             AND ll.course_id = l.course_id
  1808.             AND ll.user_id = :userId
  1809.             ORDER BY ll.id DESC
  1810.             LIMIT 1
  1811.         ";
  1813.         $sqlDateRegisterEnrollement = "
  1814.             SELECT
  1815.                 e.date_register
  1816.             FROM enrollment AS e
  1817.             WHERE e.deleted = :deletedEnrollment
  1818.             AND e.course_id = l.course_id
  1819.             AND e.user_id = :userId
  1820.             ORDER BY e.id DESC
  1821.             LIMIT 1
  1822.         ";
  1824.         $sql = "
  1825.             SELECT
  1826.                 COUNT(l.id) AS total
  1827.             FROM lesson AS l
  1828.             INNER JOIN course AS c ON (c.id = l.course_id AND c.deleted = :deletedCourse)
  1829.             INNER JOIN lesson_module AS lm ON (
  1830.                 lm.id = l.lesson_module_id AND lm.deleted = :deletedModule
  1831.             )
  1832.             LEFT JOIN library AS lb ON (lb.id = l.library_id AND lb.deleted = :deletedLibrary)
  1833.             WHERE l.deleted = :deleted
  1834.             AND l.course_id = :courseId
  1835.             /* AND  CASO FOSSE CONSIDERADA DATA DE LIBERAÇÃO DA AULA PARA ENCERRAR O ACESSO
  1836.             (
  1837.                 (
  1838.                     l.control_close_period = 0 OR 
  1839.                     l.control_close_period IS NULL
  1840.                 )
  1841.                 OR
  1842.                 (
  1843.                     l.control_close_period > 0
  1844.                     AND l.control_release_type = 0
  1845.                     AND DATEDIFF(CURDATE(), (DATE(
  1846.                         (
  1847.                             CASE 
  1848.                                 WHEN ({$sqlDateConclusion}) IS NOT NULL THEN ({$sqlDateConclusion})
  1849.                                 ELSE CURDATE()
  1850.                             END
  1851.                         )
  1852.                     ) + INTERVAL l.control_close_period DAY)) < 0
  1853.                 )
  1854.                 OR
  1855.                 (
  1856.                     l.control_close_period > 0
  1857.                     AND l.control_release_type = 1
  1858.                     AND DATEDIFF(CURDATE(), (DATE(
  1859.                         (l.control_date_release)
  1860.                     ) + INTERVAL l.control_close_period DAY)) < 0
  1861.                 )
  1862.                 OR
  1863.                 (
  1864.                     l.control_close_period > 0
  1865.                     AND l.control_release_type = 2
  1866.                     AND l.control_release_after_type = 1
  1867.                     AND DATEDIFF(CURDATE(), (DATE(
  1868.                         ({$sqlDateRegisterEnrollement})
  1869.                     ) + INTERVAL l.control_close_period DAY)) < 0
  1870.                 )
  1871.                 OR
  1872.                 (
  1873.                     l.control_close_period > 0
  1874.                     AND l.control_release_type = 2
  1875.                     AND l.control_release_after_type = 2
  1876.                 )
  1877.             )*/
  1878.         ";
  1881.         if($lessonModule){
  1882.             $sql .= " AND l.lesson_module_id = :lessonModuleId ";
  1883.         }
  1885.         if(
  1886.             $isHistory ||
  1887.             $userPermissionUtil->isLow($permission) || 
  1888.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  1889.         ){
  1890.             $sql .= " AND l.status = :lessonStatus ";
  1891.             $sql .= " AND lm.status = :lessonModuleStatus ";
  1892.         }
  1894.         $stmt = $this->em->getConnection()->prepare($sql);
  1896.         //$stmt->bindValue(':deletedEnrollment', EnrollmentEnum::ITEM_NO_DELETED, PDO::PARAM_INT);
  1897.         $stmt->bindValue(':deletedCourse', CourseEnum::ITEM_NO_DELETED, PDO::PARAM_INT);
  1898.         $stmt->bindValue(':deletedModule', LessonModuleEnum::ITEM_NO_DELETED, PDO::PARAM_INT);
  1899.         $stmt->bindValue(':deletedLibrary', LibraryEnum::ITEM_NO_DELETED, PDO::PARAM_INT);
  1900.         $stmt->bindValue(':deleted', LessonEnum::ITEM_NO_DELETED, PDO::PARAM_INT);
  1901.         $stmt->bindValue(':courseId', $course->getId(), PDO::PARAM_INT);
  1902.         //$stmt->bindValue(':yes', LessonEnum::YES, PDO::PARAM_INT);
  1903.         //$stmt->bindValue(':userId', $userId, PDO::PARAM_INT);
  1905.         if($lessonModule){
  1906.             $stmt->bindValue(':lessonModuleId', $lessonModule->getId(), PDO::PARAM_INT);
  1907.         }
  1909.         if(
  1910.             $isHistory ||
  1911.             $userPermissionUtil->isLow($permission) ||
  1912.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  1913.         ){
  1914.             $stmt->bindValue(':lessonStatus', LessonEnum::PUBLISHED, PDO::PARAM_INT);
  1915.             $stmt->bindValue(':lessonModuleStatus', LessonModuleEnum::PUBLISHED, PDO::PARAM_INT);
  1916.         }
  1917.         
  1918.         $stmt->execute();
  1920.         $result = $stmt->fetchAll(PDO::FETCH_CLASS);
  1922.         return $result[0]->total;
  1923.     }
  1925.     public function getCourseLessons(
  1926.         Course $course, 
  1927.         ?LessonModule $lessonModule = null, 
  1928.         ?array $lessonIds = null, 
  1929.         ?string $searchText = null
  1930.     )
  1931.     {
  1932.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  1934.         $permission = $userPermissionUtil->getPermission("course", "see");
  1935.         $user = $userPermissionUtil->getUser();
  1936.         $isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
  1937.             $course, 
  1938.             $user
  1939.         );
  1940.         
  1941.         $query = $this->createQueryBuilder('l');
  1942.         $query->innerJoin(
  1943.             'EADPlataforma:LessonModule', 
  1944.             'lm', 
  1945.             'WITH', 
  1946.             'lm.id = l.lessonModule AND lm.deleted = 0'
  1947.         );
  1949.         $query->innerJoin(
  1950.             'EADPlataforma:Course', 
  1951.             'c', 
  1952.             'WITH', 
  1953.             'c.id = l.course AND c.deleted = 0'
  1954.         );
  1956.         $query->leftJoin(
  1957.             'EADPlataforma:Library', 
  1958.             'lb', 
  1959.             'WITH', 
  1960.             'lb.id = l.library AND lb.deleted = 0'
  1961.         );
  1963.         $query->andWhere('l.deleted = 0');
  1964.         $query->andWhere('l.course = :courseId');
  1965.         $query->setParameter('courseId', $course->getId());
  1967.         if(!empty($searchText)){
  1968.             $query->andWhere('(l.title LIKE :searchText OR lm.title LIKE :searchText)');
  1969.             $query->setParameter('searchText', "%{$searchText}%");
  1970.         }
  1972.         if($lessonModule){
  1973.             $query->andWhere('l.lessonModule = :lessonModuleId');
  1974.             $query->setParameter('lessonModuleId', $lessonModule->getId());
  1975.         }
  1977.         if(is_array($lessonIds) && !empty($lessonIds)){
  1978.             $query->andWhere($query->expr()->in('l.id', $lessonIds));
  1979.         }
  1981.         if(
  1982.             $userPermissionUtil->isLow($permission) || 
  1983.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  1984.         ){
  1985.             $query->andWhere('l.status = :lessonStatus');
  1986.             $query->andWhere('lm.status = :lessonModuleStatus');
  1987.             $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  1988.             $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  1989.         }
  1991.         $query->addOrderBy('l.order', 'ASC');
  1992.         $query->addOrderBy('l.lessonModule', 'ASC');
  1994.         $data = $query->getQuery()->execute();
  1996.         return $data;
  1997.     }
  1999.     public function getFirstLesson(Course $course, ?LessonModule $lessonModule = null)
  2000.     {
  2001.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2003.         $permission = $userPermissionUtil->getPermission("course", "see");
  2004.         $user = $userPermissionUtil->getUser();
  2006.         $courseTeamRepository = $this->em->getRepository(CourseTeam::class);
  2007.         $isInTeam = $courseTeamRepository->userExistInCourseTeam($course, $user);
  2008.         
  2009.         $query = $this->createQueryBuilder('l');
  2010.         $query->innerJoin(
  2011.             'EADPlataforma:LessonModule', 
  2012.             'lm', 
  2013.             'WITH', 
  2014.             'lm.id = l.lessonModule AND lm.deleted = 0'
  2015.         );
  2017.         $query->innerJoin(
  2018.             'EADPlataforma:Course', 
  2019.             'c', 
  2020.             'WITH', 
  2021.             'c.id = l.course AND c.deleted = 0'
  2022.         );
  2024.         $query->andWhere('l.deleted = 0');
  2025.         $query->andWhere('l.course = :courseId');
  2026.         $query->setParameter('courseId', $course->getId());
  2028.         if($lessonModule){
  2029.             $query->andWhere('l.lessonModule = :lessonModuleId');
  2030.             $query->setParameter('lessonModuleId', $lessonModule->getId());
  2031.         }
  2033.         if(
  2034.             $userPermissionUtil->isLow($permission) || 
  2035.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  2036.         ){
  2037.             $query->andWhere('l.status = :lessonStatus');
  2038.             $query->andWhere('lm.status = :lessonModuleStatus');
  2039.             $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  2040.             $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  2041.         }
  2043.         $query->addOrderBy('lm.order', 'ASC');
  2044.         $query->addOrderBy('l.order', 'ASC');
  2046.         $query->setMaxResults(1);
  2048.         return $query->getQuery()->getOneOrNullResult();
  2049.     }
  2051.     public function getLastLesson(Course $course, ?LessonModule $lessonModule = null)
  2052.     {
  2053.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2055.         $permission = $userPermissionUtil->getPermission("course", "see");
  2056.         $user = $userPermissionUtil->getUser();
  2057.         $isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
  2058.             $course, 
  2059.             $user
  2060.         );
  2061.         
  2062.         $query = $this->createQueryBuilder('l');
  2063.         $query->innerJoin(
  2064.             'EADPlataforma:LessonModule', 
  2065.             'lm', 
  2066.             'WITH', 
  2067.             'lm.id = l.lessonModule AND lm.deleted = 0'
  2068.         );
  2070.         $query->innerJoin(
  2071.             'EADPlataforma:Course', 
  2072.             'c', 
  2073.             'WITH', 
  2074.             'c.id = l.course AND c.deleted = 0'
  2075.         );
  2077.         $query->andWhere('l.deleted = 0');
  2078.         $query->andWhere('l.course = :courseId');
  2079.         $query->setParameter('courseId', $course->getId());
  2081.         if($lessonModule){
  2082.             $query->andWhere('l.lessonModule = :lessonModuleId');
  2083.             $query->setParameter('lessonModuleId', $lessonModule->getId());
  2084.         }
  2086.         if(
  2087.             $userPermissionUtil->isLow($permission) || 
  2088.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  2089.         ){
  2090.             $query->andWhere('l.status = :lessonStatus');
  2091.             $query->andWhere('lm.status = :lessonModuleStatus');
  2092.             $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  2093.             $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  2094.         }
  2096.         $query->addOrderBy('lm.order', 'DESC');
  2097.         $query->addOrderBy('l.order', 'DESC');
  2099.         $query->setMaxResults(1);
  2101.         return $query->getQuery()->getOneOrNullResult();
  2102.     }
  2104.     public function getLessonByLessonModule(LessonModule $lessonModule)
  2105.     {   
  2107.         $query = $this->createQueryBuilder('l');
  2108.         $query->leftJoin(
  2109.             'EADPlataforma:Library', 
  2110.             'li', 
  2111.             'WITH', 
  2112.             'li.id = l.library AND li.deleted = 0'
  2113.         );
  2115.         $query->andWhere('l.deleted = 0');
  2116.         $query->andWhere('l.status = :status');
  2117.         $query->andWhere('l.course = :courseId');
  2118.         $query->andWhere('l.lessonModule = :lessonModule');
  2119.         $query->setParameter('courseId', $lessonModule->getCourse()->getId());
  2120.         $query->setParameter('lessonModule', $lessonModule->getId());
  2121.         $query->setParameter('status', LessonEnum::PUBLISHED);
  2123.         $query->addOrderBy('l.order', 'ASC');
  2125.         return $query->getQuery()->execute();
  2126.     }
  2128.     public function getNextLessonByLessonModule(
  2129.         int $order, 
  2130.         LessonModule $lessonModule, 
  2131.         int $limit = 3
  2132.     )
  2133.     {   
  2135.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2136.         $permission = $userPermissionUtil->getPermission("course", "see");
  2138.         $course = $lessonModule->getCourse();
  2139.         $user = $userPermissionUtil->getUser();
  2142.         $isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
  2143.             $course, 
  2144.             $user
  2145.         );
  2147.         $query = $this->createQueryBuilder('l');
  2149.         $query->select('
  2150.             l.id,
  2151.             l.order,
  2152.             l.title,
  2153.             l.status,
  2154.             l.controlRequirement,
  2155.             l.controlReleaseType,
  2156.             l.controlReleaseAfterType,
  2157.             l.controlDateRelease,
  2158.             l.controlReleasePeriod,
  2159.             l.controlClosePeriod,
  2160.             lm.id AS lessonModule,
  2161.             li.type AS libraryType,
  2162.             li.pagesNumber,
  2163.             li.duration
  2164.         ');
  2166.         $query->innerJoin(
  2167.             'EADPlataforma:LessonModule', 
  2168.             'lm', 
  2169.             'WITH', 
  2170.             'lm.id = l.lessonModule AND lm.deleted = 0'
  2171.         );
  2173.         $query->innerJoin(
  2174.             'EADPlataforma:Course', 
  2175.             'c', 
  2176.             'WITH', 
  2177.             'c.id = l.course AND c.deleted = 0'
  2178.         );
  2180.         $query->leftJoin(
  2181.             'EADPlataforma:Library', 
  2182.             'li', 
  2183.             'WITH', 
  2184.             'li.id = l.library AND li.deleted = 0'
  2185.         );
  2187.         if(
  2188.             $userPermissionUtil->isLow($permission) || 
  2189.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  2190.         ){
  2191.             $query->andWhere('l.status = :lessonStatus');
  2192.             $query->andWhere('lm.status = :lessonModuleStatus');
  2193.             $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  2194.             $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  2195.         }
  2197.         $query->andWhere('l.deleted = 0');
  2198.         $query->andWhere('l.course = :courseId');
  2199.         $query->andWhere('l.lessonModule = :lessonModule');
  2200.         $query->andWhere('l.order > :order');
  2202.         $query->setParameter('courseId', $course->getId());
  2203.         $query->setParameter('lessonModule', $lessonModule->getId());
  2204.         $query->setParameter('order', $order);
  2206.         $query->addOrderBy('l.order', 'ASC');
  2208.         $query->setMaxResults($limit);
  2210.         return $query->getQuery()->execute();
  2211.     }
  2213.     public function getLessonNotView($userId, $courseId, $lessonId = null)
  2214.     {
  2215.         $and = '';
  2217.         if(!empty($lessonId))
  2218.         {
  2219.             $and .= " AND l.id = :lessonId";
  2220.         }
  2222.         if(empty($courseId) || empty($userId))
  2223.         {
  2224.             return [];
  2225.         }
  2227.         $dql = "SELECT
  2228.                     l.id,
  2229.                     l.title,
  2230.                     lm.title AS titleModule,
  2231.                     '0' AS totalView,
  2232.                     '' AS lastAccess,
  2233.                     '--' AS timeWatch,
  2234.                     '0' AS completed,
  2235.                     '---' AS dateConclusion
  2236.                 FROM EADPlataforma:Lesson AS l
  2237.                 INNER JOIN EADPlataforma:LessonModule AS lm WITH (lm.id = l.lessonModule AND lm.deleted = 0)
  2238.                 WHERE l.deleted = 0
  2239.                 AND l.course = :courseId
  2240.                 {$and}
  2241.                 AND l.id NOT IN (
  2242.                     SELECT
  2243.                         IDENTITY (ll.lesson)
  2244.                     FROM EADPlataforma:LessonLogOrigin AS ll
  2245.                     WHERE ll.user != 1
  2246.                     AND ll.user = :userId
  2247.                     AND ll.course = :courseId
  2248.                 )
  2249.                 ORDER BY l.order ASC";
  2250.                 
  2251.         $query = $this->em->createQuery($dql);
  2252.         $query->setParameter('userId', $userId);
  2253.         $query->setParameter('courseId', $courseId);
  2254.       
  2255.         if(!empty($lessonId))
  2256.         {
  2257.             $query->setParameter('lessonId', $lessonId);
  2258.         }
  2260.         $data = $query->execute();
  2261.         
  2262.         $result = [];
  2263.         foreach ($data as $key => $value) {
  2264.             $result[] = [
  2265.                 $value["id"],
  2266.                 $value["title"],
  2267.                 $value["titleModule"],
  2268.                 $value["totalView"],
  2269.                 $value["lastAccess"],
  2270.                 $value["timeWatch"],
  2271.                 $value["completed"],
  2272.                 $value["dateConclusion"]
  2273.             ];
  2274.         }
  2276.         return $result;
  2277.     }
  2279.     public function isFirstCourseLesson(?Lesson $lesson)
  2280.     {
  2281.         if(!$lesson){
  2282.             return false;
  2283.         }
  2285.         $firstLesson = $this->getFirstLesson($lesson->getCourse());
  2286.         if($firstLesson){
  2287.             return $firstLesson->getId() == $lesson->getId();
  2288.         }
  2289.         return true;
  2290.     }
  2292.     public function isFirstModuleLesson(?Lesson $lesson)
  2293.     {
  2294.         if(!$lesson){
  2295.             return false;
  2296.         }
  2298.         $firstLesson = $this->getFirstLesson($lesson->getCourse(), $lesson->getLessonModule());
  2299.         if($firstLesson){
  2300.             return $firstLesson->getId() == $lesson->getId();
  2301.         }
  2302.         return true;
  2303.     }
  2305.     public function isLastCourseLesson(?Lesson $lesson)
  2306.     {
  2307.         if(!$lesson){
  2308.             return false;
  2309.         }
  2311.         $firstLesson = $this->getLastLesson($lesson->getCourse());
  2312.         if($firstLesson){
  2313.             return $firstLesson->getId() == $lesson->getId();
  2314.         }
  2315.         return true;
  2316.     }
  2318.     public function isLastModuleLesson(?Lesson $lesson)
  2319.     {
  2320.         if(!$lesson){
  2321.             return false;
  2322.         }
  2324.         $firstLesson = $this->getLastLesson(
  2325.             $lesson->getCourse(), 
  2326.             $lesson->getLessonModule()
  2327.         );
  2329.         if($firstLesson){
  2330.             return $firstLesson->getId() == $lesson->getId();
  2331.         }
  2332.         return true;
  2333.     }
  2335.     public function isLessonVisibleToStudent(
  2336.         Lesson $lesson, 
  2337.         ?bool $ignoreControlFunction = false
  2338.     ): bool
  2339.     {
  2340.         $info = $this->checkLessonVisibleToStudent($lesson, $ignoreControlFunction);
  2342.         return $info->visible;
  2343.     }
  2345.     public function checkLessonVisibleToStudent(
  2346.         Lesson $lesson, 
  2347.         ?bool $ignoreControlFunction = false
  2348.     ): object
  2349.     {
  2350.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2351.         $user = $userPermissionUtil->getUser();
  2353.         $info = (object)[
  2354.             "visible" => true,
  2355.             "message" => "",
  2356.         ];
  2358.         if(!$user){
  2360.             $info->visible = false;
  2362.             return $info;
  2363.         }
  2365.         $course = $lesson->getCourse();
  2366.         $lessonModule = $lesson->getLessonModule();
  2368.         if($lesson->isDeleted() || $lessonModule->isDeleted() || $course->isDeleted()){
  2369.             $info->visible = false;
  2371.             return $info;
  2372.         }
  2374.         $permission = $userPermissionUtil->getPermission("course", "see");
  2375.         
  2376.         $isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
  2377.             $course,
  2378.             $user
  2379.         );
  2381.         $enrollmentRepository = $this->em->getRepository(Enrollment::class);
  2382.         $isEnroll = $enrollmentRepository->isValidEnrollmentByUser(
  2383.             $user->getId(), 
  2384.             $course->getId()
  2385.         );
  2387.         $hasLessonControl = $this->configuration->checkModuleIsAbleOnPlan(
  2388.             'lessonControlFunction'
  2389.         );
  2391.         if(
  2392.             $userPermissionUtil->isLow($permission) || 
  2393.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  2394.         ){
  2395.             
  2396.             if($lesson->getStatus() == LessonEnum::DRAFT){
  2397.                 $info->visible = false;
  2399.                 return $info;
  2400.             }
  2402.             if($lessonModule->getStatus() == LessonModuleEnum::DRAFT){
  2403.                 $info->visible = false;
  2405.                 return $info;
  2406.             }
  2408.             if($course->getStatus() == CourseEnum::DRAFT){
  2409.                 $info->visible = false;
  2411.                 return $info;
  2412.             }
  2414.             if(!$isEnroll){
  2415.                 $info->visible = false;
  2417.                 return $info;
  2418.             }
  2419.             
  2420.             if(!$ignoreControlFunction){
  2421.                 if($lesson->getControlReleaseType() == LessonEnum::FIXED_DATE){
  2422.                     $todaySeconds = strtotime(date('Y-m-d H:i:s'));
  2423.                     if($hasLessonControl){
  2424.                         $controlClosePeriod = $lesson->getControlClosePeriod();
  2425.                         if(!empty($controlClosePeriod)){
  2426.                             $timeLog = strtotime(
  2427.                                 "{$lesson->getControlDateRelease()} + {$controlClosePeriod} day"
  2428.                             );
  2430.                             if($todaySeconds > $timeLog){
  2431.                                 $info->visible = false;
  2433.                                 return $info;
  2434.                             }
  2435.                         }
  2436.                     }
  2437.                 }else{
  2438.                     $lessonLogRepository = $this->emEadmin->getRepository(LessonLog::class);
  2439.                     $logId = "{$course->getId()}#{$user->getId()}#{$lesson->getId()}";
  2440.                     $lessonLog = $lessonLogRepository->find($logId);
  2442.                     //check lesson to user is closed
  2443.                     if($lessonLog){
  2444.                         $todaySeconds = strtotime(date('Y-m-d H:i:s'));
  2445.                         if($hasLessonControl){
  2446.                             $controlClosePeriod = $lesson->getControlClosePeriod();
  2447.                             if(
  2448.                                 !empty($controlClosePeriod) && 
  2449.                                 $lessonLog->getComplete() == LessonEnum::YES
  2450.                             ){
  2451.                                 $timeLog = strtotime(
  2452.                                     "{$lessonLog->getDateConclusion()} + {$controlClosePeriod} day"
  2453.                                 );
  2455.                                 if($todaySeconds > $timeLog){
  2456.                                     $info->visible = false;
  2458.                                     return $info;
  2459.                                 }
  2460.                             }
  2461.                         }
  2462.                     }
  2463.                 } 
  2464.             }
  2465.         }else if(!$isEnroll){
  2466.             $enrollmentService = $this->generalService->getService('EnrollmentService');
  2467.             $enrollmentService->enrollUser($user, $course);
  2468.         }
  2470.         return $info;
  2471.     }
  2473.     public function getLessonNumberByProduct(Product $product)
  2474.     {
  2475.         $query = $this->createQueryBuilder('l');
  2476.         $query->select("COUNT(l.id) AS total");
  2477.         $query->innerJoin('EADPlataforma:Course', 'c', 'WITH', 'l.course = c.id');
  2478.         $query->innerJoin('EADPlataforma:Product', 'p', 'WITH', 'l.course MEMBER OF p.course');
  2479.         $query->innerJoin('EADPlataforma:LessonModule', 'lm', 'WITH', 'l.lessonModule = lm.id');
  2481.         $query->andWhere('l.deleted = :deletedLesson');
  2482.         $query->andWhere('c.deleted = :deletedCourse');
  2483.         $query->andWhere('lm.deleted = :deletedLessonModule');
  2485.         $query->andWhere('l.status = :statusLesson');
  2486.         $query->andWhere('c.status = :statusCourse');
  2487.         $query->andWhere('lm.status = :statusLessonModule');
  2489.         $query->andWhere('p.id = :productId');
  2491.         $query->setParameter('deletedLesson', LessonEnum::ITEM_NO_DELETED);
  2492.         $query->setParameter('deletedCourse', CourseEnum::ITEM_NO_DELETED);
  2493.         $query->setParameter('deletedLessonModule', LessonModuleEnum::ITEM_NO_DELETED);
  2495.         $query->setParameter('statusLesson', LessonEnum::PUBLISHED);
  2496.         $query->setParameter('statusCourse', CourseEnum::PUBLISHED);
  2497.         $query->setParameter('statusLessonModule', LessonModuleEnum::PUBLISHED);
  2499.         $query->setParameter('productId', $product->getId());
  2501.         $result = (object)$query->getQuery()->getOneOrNullResult();
  2502.         return $result->total;
  2503.     }
  2505.     public function getLessonForExportPresence(Course $course, $lessonModuleId = null){
  2506.         $query = $this->createQueryBuilder('l');
  2508.         $query->select('
  2509.             l.id,
  2510.             lm.id AS lessonModuleId,
  2511.             l.order,
  2512.             lm.title,
  2513.             l.title AS lessonTitle
  2514.         ');
  2516.         $query->innerJoin(
  2517.             'EADPlataforma:LessonModule', 
  2518.             'lm', 
  2519.             'WITH', 
  2520.             'lm.id = l.lessonModule AND lm.deleted = 0'
  2521.         );
  2523.         if($lessonModuleId){
  2524.             $query->andWhere('lm.id = :lessonModuleId');
  2525.             $query->setParameter('lessonModuleId', $lessonModuleId);
  2526.         }
  2527.         
  2528.         $query->andWhere('l.status = :lessonStatus');
  2529.         $query->andWhere('lm.status = :lessonModuleStatus');
  2530.         $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  2531.         $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  2532.         
  2533.         $query->andWhere('l.deleted = 0');
  2534.         $query->andWhere('l.course = :courseId');
  2536.         $query->setParameter('courseId', $course->getId());
  2538.         $query->addOrderBy('lm.order', 'ASC');
  2539.         $query->addOrderBy('lm.id', 'ASC');
  2540.         $query->addOrderBy('l.order', 'ASC');
  2541.         $query->addOrderBy('l.id', 'ASC');
  2543.         return $query->getQuery()->execute();
  2544.     }
  2546.     public function restore(Lesson $lesson, $typeItem, $key)
  2547.     {
  2548.         $lessonId = $lesson->getId();
  2549.         $dateNow = date('Y-m-d H:i:s');
  2551.         $lastOrder = $this->count(
  2552.             [ 
  2553.                 "deleted" => LessonEnum::ITEM_NO_DELETED, 
  2554.                 "lessonModule" => $lesson->getLessonModule()->getId() 
  2555.             ]
  2556.         ) + ($key + 1);
  2558.         $lesson->setOrder($lastOrder);
  2560.         $courseRepository =  $this->em->getRepository(Course::class);
  2562.         $lesson->setUserDelete($this->getUser());
  2563.         $lesson->setDateDelete($dateNow);
  2564.         $lesson->restore();
  2565.         $deleted = LessonEnum::ITEM_NO_DELETED;
  2566.         $typeDelete = LessonEnum::CASCADE;
  2568.         $this->em->getRepository(Exam::class)->restoreByLesson(
  2569.             $lessonId, 
  2570.             $deleted, 
  2571.             $typeDelete, 
  2572.             $this->getUser(), 
  2573.             $dateNow
  2574.         );
  2576.         $this->em->getRepository(ExamUser::class)->restoreByLesson(
  2577.             $lessonId, 
  2578.             $deleted, 
  2579.             $typeDelete, 
  2580.             $this->getUser(), 
  2581.             $dateNow
  2582.         );
  2584.         $this->em->getRepository(LessonSupport::class)->restoreByLesson(
  2585.             $lessonId, 
  2586.             $deleted, 
  2587.             $typeDelete, 
  2588.             $this->getUser(), 
  2589.             $dateNow
  2590.         );
  2592.         $this->em->getRepository(LessonXLibrary::class)->restoreByLesson(
  2593.             $lessonId, 
  2594.             $deleted, 
  2595.             $typeDelete, 
  2596.             $this->getUser(), 
  2597.             $dateNow
  2598.         );
  2599.         $this->em->getRepository(Trash::class)->deleteTrash($lessonId, $typeItem);
  2600.     }
  2602.     public function delete(Lesson $lesson, $typeItem, $permission, $isTrash)
  2603.     {
  2604.         $lessonId = $lesson->getId();
  2605.         $dateNow = date('Y-m-d H:i:s');
  2606.         $typeDelete = LessonEnum::CASCADE;
  2608.         $notificationService = $this->generalService->getService('NotificationService');
  2609.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2611.         $lessonXLibrarys = $this->em->getRepository(LessonXLibrary::class)->findBy([
  2612.             "lesson" => $lesson->getId(),
  2613.         ]);
  2615.         $libraryRepository = $this->em->getRepository(Library::class);
  2616.         $libraryModule = $this->configuration->checkModuleIsAbleOnPlan('libraryModule');
  2618.         if($isTrash == LessonEnum::YES){
  2619.             $permission = $userPermissionUtil->getPermission("trash", "delete");
  2620.         }
  2622.         $isLessonTeacher = $this->isLessonTeacher($lesson, $this->getUser());
  2623.         if($isLessonTeacher || $userPermissionUtil->isHigh($permission)){
  2624.             $lesson->setUserDelete($this->getUser());
  2625.             $lesson->setDateDelete($dateNow);
  2626.             $lesson->individual();
  2627.             
  2628.             if($lesson->isOnTrash() || $lesson->isDeleted()){
  2629.                 
  2630.                 $lesson->delete();
  2631.                 $deleted = LessonEnum::ITEM_DELETED;
  2632.                 $this->em->getRepository(Trash::class)->deleteTrash($lessonId, $typeItem);
  2634.                 $this->em->flush();
  2636.                 foreach ($lessonXLibrarys as $key => $lessonXLibrary) {
  2637.                     $library = $lessonXLibrary->getLibrary();
  2638.                     if(!$libraryModule && $library){
  2639.                         $library->cascade();
  2640.                         $libraryRepository->deleteContent($library);
  2641.                     }
  2642.                     $lessonXLibrary->delete();
  2643.                 }
  2645.                 $library = $lesson->getLibrary();
  2647.                 if(!$libraryModule && $library){
  2648.                     $library->cascade();
  2649.                     $libraryRepository->deleteContent($library);
  2650.                 }
  2651.             }
  2653.             if(!$lesson->isOnTrash() && !$lesson->isDeleted()){
  2654.                 $order = $lesson->getOrder();
  2655.                 $this->refreshOrder(
  2656.                     $lesson->getCourse()->getId(), 
  2657.                     $lesson->getLessonModule()->getId(),
  2658.                     $order,
  2659.                     null,
  2660.                     true
  2661.                 );
  2663.                 $notificationService->delete(
  2664.                     NotificationEnum::ORIGIN_LESSON_SUPPORT_LIKE, 
  2665.                     $lessonId
  2666.                 );
  2668.                 $notificationService->delete(
  2669.                     NotificationEnum::ORIGIN_LESSON_SUPPORT_ANSWER_LIKE, 
  2670.                     $lessonId
  2671.                 );
  2672.                 $notificationService->delete(
  2673.                     NotificationEnum::ORIGIN_LESSON_SUPPORT_NEW, 
  2674.                     $lessonId
  2675.                 );
  2676.                 $notificationService->delete(
  2677.                     NotificationEnum::ORIGIN_LESSON_SUPPORT_ANSWER_NEW, 
  2678.                     $lessonId
  2679.                 );
  2680.                 $notificationService->delete(
  2681.                     NotificationEnum::ORIGIN_LESSON_NEW, 
  2682.                     $lessonId
  2683.                 );
  2684.                 $notificationService->delete(
  2685.                     NotificationEnum::ORIGIN_LESSON_CHANGE, 
  2686.                     $lessonId
  2687.                 );
  2689.                 $lesson->trash();
  2690.                 $deleted = LessonEnum::ITEM_ON_TRASH;
  2691.                 $this->em->getRepository(Trash::class)->insertTrash(
  2692.                     $lesson, 
  2693.                     $typeItem, 
  2694.                     "Aula: {$lesson->getTitle()} | Prof. {$lesson->getUser()->getName()}"
  2695.                 );
  2696.             }
  2697.         }
  2698.         
  2699.         $this->em->getRepository(Exam::class)->deleteByLesson(
  2700.             $lessonId, 
  2701.             $deleted, 
  2702.             $typeDelete, 
  2703.             $this->getUser(), 
  2704.             $dateNow
  2705.         );
  2707.         $this->em->getRepository(ExamUser::class)->deleteByLesson(
  2708.             $lessonId, 
  2709.             $deleted, 
  2710.             $typeDelete, 
  2711.             $this->getUser(), 
  2712.             $dateNow
  2713.         );
  2715.         $this->em->getRepository(LessonSupport::class)->deleteByLesson(
  2716.             $lessonId, 
  2717.             $deleted, 
  2718.             $typeDelete, 
  2719.             $this->getUser(), 
  2720.             $dateNow
  2721.         );
  2723.         $this->em->getRepository(LessonXLibrary::class)->deleteByLesson(
  2724.             $lessonId, 
  2725.             $deleted, 
  2726.             $typeDelete, 
  2727.             $this->getUser(), 
  2728.             $dateNow
  2729.         );
  2730.     }
  2732.     public function restoreByCourse($courseId, $deleted, $typeDelete){
  2734.         $typeItem = TrashEnum::LESSON;
  2736.         $lessons = $this->em->getRepository(Lesson::class)->findBy([
  2737.             "course" => $courseId,
  2738.             "deleted" => (1 - $deleted),
  2739.             "typeDelete" => $typeDelete
  2740.         ]);
  2742.         foreach ($lessons as $key => $lesson) {
  2743.             $this->restore($lesson, $typeItem, $key);
  2744.         }
  2745.     }
  2747.     public function deleteByCourse($courseId, $deleted){
  2749.         $typeItem = TrashEnum::LESSON;
  2750.         $isTrash = LessonEnum::NO;
  2752.         if($deleted == LessonEnum::ITEM_ON_TRASH){
  2753.             $isTrash = LessonEnum::YES;
  2754.         }
  2756.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2757.         $permission = $userPermissionUtil->getPermission(
  2758.             "course", 
  2759.             "lesson", 
  2760.             "delete"
  2761.         );
  2763.         $lessons = $this->em->getRepository(Lesson::class)->findBy([
  2764.             "course" => $courseId,
  2765.             "deleted" => ($deleted - 1)
  2766.         ]);
  2768.         foreach ($lessons as $key => $lesson) {
  2769.             $this->delete($lesson, $typeItem, $permission, $isTrash);
  2770.             $lesson->cascade();
  2771.         }
  2772.     }
  2774.     public function restoreByLessonModule($lessonModuleId, $deleted, $typeDelete){
  2776.         $typeItem = TrashEnum::LESSON;
  2778.         $lessons = $this->em->getRepository(Lesson::class)->findBy([
  2779.             "lessonModule" => $lessonModuleId,
  2780.             "deleted" => (1 - $deleted),
  2781.             "typeDelete" => $typeDelete
  2782.         ]);
  2784.         foreach ($lessons as $key => $lesson) {
  2785.             $this->restore($lesson, $typeItem, $key);
  2786.         }
  2787.     }
  2789.     public function deleteByLessonModule($lessonModuleId, $deleted){
  2791.         $typeItem = TrashEnum::LESSON;
  2792.         $isTrash = LessonEnum::NO;
  2794.         if($deleted == LessonEnum::ITEM_ON_TRASH){
  2795.             $isTrash = LessonEnum::YES;
  2796.         }
  2798.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2799.         $permission = $userPermissionUtil->getPermission(
  2800.             "course", 
  2801.             "lesson", 
  2802.             "delete"
  2803.         );
  2805.         $lessons = $this->em->getRepository(Lesson::class)->findBy([
  2806.             "lessonModule" => $lessonModuleId,
  2807.             "deleted" => ($deleted - 1)
  2808.         ]);
  2810.         foreach ($lessons as $key => $lesson) {
  2811.             $this->delete($lesson, $typeItem, $permission, $isTrash);
  2812.             $lesson->cascade();
  2813.         }
  2814.     }
  2816.     public function deleteTrashCron()
  2817.     {
  2818.         $sql = "UPDATE EADPlataforma:Lesson AS l SET l.deleted = 2 
  2819.                 WHERE l.dateDelete <= :date AND l.deleted = 1 ";
  2820.         $query = $this->em->createQuery($sql);
  2821.         $query->setParameter('date', date('Y-m-d H:i:s', strtotime('-90 days')));
  2822.         $query->execute();
  2823.     }
  2824. }