src/Repository/LessonRepository.php line 585

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 setLessonTag(
  54.         Lesson $lesson, 
  55.         User $user,
  56.         ?string $content = null,
  57.         ?string $link = null
  58.     ): object
  59.     {
  61.         $stringUtil = $this->generalService->getUtil('StringUtil');
  63.         $cityName = ( $user->getCity() ? $user->getCity()->getName() : '' );
  64.         $stateUf = ( $user->getCity() ? $user->getCity()->getState()->getName() : '' );
  65.         $stateUf = ( $stateUf ? $stringUtil->getFirstWordAll($stateUf) : '' );
  67.         $client = $this->configuration->getClient();
  69.         $schoolName = $client->getBrand();
  70.         $schoolDocument = $client->getDocument();
  71.         $schoolDomain = $this->configuration->getActiveDomain();
  73.         $course = $lesson->getCourse();
  74.         $module = $lesson->getLessonModule();
  76.         $dataReplace = [
  77.             "[[aluno_id]]" => $user->getId(),
  78.             "[[aluno_nome]]" => mb_strtoupper($user->getName()),
  79.             "[[aluno_email]]" => $user->getEmail(),
  80.             "[[aluno_cpf]]" => $user->getDocument(),
  81.             "[[aluno_telefone]]" => $user->getPhone(),
  82.             "[[aluno_data_nascimento]]" => $user->getBirthdate('d/m/Y'),
  83.             "[[aluno_cidade]]" => $cityName,
  84.             "[[aluno_uf]]" => $stateUf,
  85.             
  86.             "[[curso_titulo]]" => $course->getTitle(),
  87.             "[[curso_professor]]" => mb_strtoupper($course->getUser()->getName()),
  88.             
  89.             "[[modulo_titulo]]" => $module->getTitle(),
  90.             "[[modulo_descricao]]" => $module->getDescription(),
  91.             "[[modulo_professor]]" => mb_strtoupper($module->getUser()->getName()),
  92.             
  93.             "[[aula_titulo]]" => $lesson->getTitle(),
  94.             "[[aula_descricao]]" => $lesson->getDescription(),
  95.             "[[aula_professor]]" => mb_strtoupper($lesson->getUser()->getName()),
  97.             "[[ead_nome]]" => $schoolName,
  98.             "[[ead_cnpj]]" => $schoolDocument,
  99.             "[[ead_dominio]]" => $schoolDomain,
  100.         ];
  102.         foreach($dataReplace as $key => $value){
  103.             if(!empty($link)){
  104.                 $link = str_replace($key, $value, $link);
  105.             }
  107.             if(!empty($content)){
  108.                 $content = str_replace($key, $value, $content);
  109.             }
  110.         }
  112.         return (object)[
  113.             "content" => $content,
  114.             "link" => $link,
  115.         ];
  116.     }
  118.     public function getMeetCredentials(lesson $lesson, User $user)
  119.     {
  121.         $library = $lesson->getLibrary();
  123.         if(!$library){
  124.             return null;
  125.         }
  127.         $libraryType = $library->getType();
  128.         if($libraryType != LibraryEnum::CONTENT_CONFERENCE){
  129.             return null;
  130.         }
  132.         $info = $this->generalService->getServiceAccess(ServicesEnum::MEET);
  134.         $privateKey = $info->privateKey;
  135.         $publicKey = $info->publicKey;
  136.         $appId = $info->appId;
  138.         $fileService = $this->generalService->getService('FileService');
  139.         $photo = $fileService->getFilePathComplete(
  140.             $user->getPhoto(), 
  141.             UserEnum::PATH_PROFILES, 
  142.             true, 
  143.             true
  144.         );
  146.         $courseRepository = $this->em->getRepository(Course::class);
  147.         $isStudent = $courseRepository->isStudent($lesson->getCourse());
  148.         $isAdmin = ($isStudent ? false : true );
  150.         $client = $this->getConfiguration()->getClient();
  151.         $clientId = $client->getClientId();
  153.         $formatClientId = [
  154.             "1" => "00000{$clientId}",
  155.             "2" => "0000{$clientId}",
  156.             "3" => "000{$clientId}",
  157.             "4" => "00{$clientId}",
  158.             "5" => "0{$clientId}",
  159.         ];
  160.         
  161.         if(isset($formatClientId[strlen($clientId)])){
  162.             $clientId = $formatClientId[strlen($clientId)];
  163.         }
  164.         
  165.         $channelId = md5($clientId . $lesson->getId());
  166.         $userId = md5($clientId . $this->getUser()->getId());
  168.         $payload = [
  169.             'iss' => 'chat',
  170.             'aud' => 'jitsi',
  171.             'exp' => time() + 7200,
  172.             'nbf' => time() - 10,
  173.             'room'=> '*',
  174.             'sub' => $appId,
  175.             'context' => [
  176.                 'user' => [
  177.                     'moderator' => $isAdmin ? "true" : "false",
  178.                     'email' => $user->getEmail(),
  179.                     'name' => $user->getName(),
  180.                     'avatar' => $photo,
  181.                     'id' => $userId
  182.                 ],
  183.                 'features' => [
  184.                     'recording' => $isAdmin ? "true" : "false",
  185.                     'livestreaming' => "false",
  186.                     'transcription' => "false",
  187.                     'outbound-call' => "false"
  188.                 ]
  189.             ]
  190.         ];
  192.         $token = JWT::encode($payload, $privateKey, "RS256", $publicKey);
  194.         return (object)[
  195.             "token" => $token,
  196.             "room" => $channelId,
  197.             "appId" => $appId,
  198.         ];
  199.     }
  201.     public function getLessonChatCredentialsNew(Lesson $lesson)
  202.     {
  204.         $library = $lesson->getLibrary();
  206.         if(!$this->getUser()){
  207.             return;
  208.         }
  210.         if(!$library){
  211.             return;
  212.         }
  214.         if(
  215.             $library->getType() != LibraryEnum::CONTENT_LIVE && 
  216.             $library->getType() != LibraryEnum::CONTENT_EXTERNAL_LIVE
  217.         ){
  218.             return;
  219.         }
  221.         $courseRepository = $this->em->getRepository(Course::class);
  222.         $isStudent = $courseRepository->isStudent($lesson->getCourse());
  224.         if($lesson->getShowLiveChat() == LessonEnum::NO && $isStudent){
  225.             return;
  226.         }
  227.         
  228.         $today = date('Y-m-d H:i:s');
  229.         $todayDate = date('Y-m-d');
  230.         $timeToday = strtotime($today);
  232.         $showLiveChat = LessonEnum::NO;
  233.         $liveDateStart = $library->getLiveStart();
  234.         $timeLiveEnd = date('Y-m-d', strtotime($liveDateStart));
  235.         $timeLiveStart = strtotime($liveDateStart . ' - 1 hours'); 
  236.         
  237.         if($timeToday >= $timeLiveStart && $todayDate == $timeLiveEnd || !$isStudent){
  238.             $showLiveChat = LessonEnum::YES;
  239.         }
  241.         if($showLiveChat == LessonEnum::NO){
  242.             return;
  243.         }
  245.         $client = $this->getConfiguration()->getClient();
  246.         $clientId = $client->getClientId();
  248.         $formatClientId = [
  249.             "1" => "00000{$clientId}",
  250.             "2" => "0000{$clientId}",
  251.             "3" => "000{$clientId}",
  252.             "4" => "00{$clientId}",
  253.             "5" => "0{$clientId}",
  254.         ];
  255.         
  256.         if(isset($formatClientId[strlen($clientId)])){
  257.             $clientId = $formatClientId[strlen($clientId)];
  258.         }
  259.         
  260.         $channelId = md5($clientId . $lesson->getId());
  261.         $userId = md5($clientId . $this->getUser()->getId());
  262.         $isAdmin = ($isStudent ? false : true );
  264.         $fileService = $this->generalService->getService('FileService');
  265.         $photo = $fileService->getFilePathComplete(
  266.             $this->getUser()->getPhoto(), 
  267.             UserEnum::PATH_PROFILES, 
  268.             true, 
  269.             true
  270.         );
  272.         $tokenAuth = $this->generalService->getTokenCron();
  273.         $url = "https://chat.eadplataforma.app/api/users/token";
  275.         $ch = curl_init($url);
  277.         $dataPost = [
  278.             "isAdmin" => $isAdmin,
  279.             "id" => $userId,
  280.             "name" => $this->getUser()->getName(),
  281.             "roomId" => $channelId,
  282.             "photoSrc" => $photo,
  283.             "lessonId" => $lesson->getId(),
  284.             "clientId" => $clientId,
  285.         ];
  287.         curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
  288.         curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($dataPost));
  289.         curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  290.         curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
  291.         curl_setopt($ch, CURLOPT_HTTPHEADER, [ 
  292.             "Authorization: {$tokenAuth}",
  293.             "Content-Type: application/json"
  294.         ]);
  296.         $dataToken = curl_exec($ch);
  297.         $error = curl_error($ch);
  298.         $dataToken = json_decode($dataToken);
  299.         curl_close($ch);
  301.         return (object)[
  302.             "role" => ($isAdmin ? "admin" : "user"),
  303.             "userId" => $userId,
  304.             "userFoto" => $photo,
  305.             "userName" => $this->getUser()->getName(),
  306.             "channelId" => $channelId,
  307.             "channelLogo" => "",
  308.             "channelName" => $lesson->getTitle(),
  309.             "userToken" => (!empty($dataToken->token) ? $dataToken->token : null),
  310.             "clientId" => $clientId
  311.         ];
  312.     }
  314.     public function getLessonChatCredentials(Lesson $lesson)
  315.     {
  316.         $library = $lesson->getLibrary();
  318.         if(!$this->getUser()){
  319.             return;
  320.         }
  322.         if(!$library){
  323.             return;
  324.         }
  326.         if(
  327.             $library->getType() != LibraryEnum::CONTENT_LIVE && 
  328.             $library->getType() != LibraryEnum::CONTENT_EXTERNAL_LIVE
  329.         ){
  330.             return;
  331.         }
  333.         $courseRepository = $this->em->getRepository(Course::class);
  334.         $isStudent = $courseRepository->isStudent($lesson->getCourse());
  336.         if($lesson->getShowLiveChat() == LessonEnum::NO && $isStudent){
  337.             return;
  338.         }
  339.         
  340.         $today = date('Y-m-d H:i:s');
  341.         $todayDate = date('Y-m-d');
  342.         $timeToday = strtotime($today);
  344.         $showLiveChat = LessonEnum::NO;
  345.         $liveDateStart = $library->getLiveStart();
  346.         $timeLiveEnd = date('Y-m-d', strtotime($liveDateStart));
  347.         $timeLiveStart = strtotime($liveDateStart . ' - 1 hours'); 
  348.         
  349.         if($timeToday >= $timeLiveStart && $todayDate == $timeLiveEnd || !$isStudent){
  350.             $showLiveChat = LessonEnum::YES;
  351.         }
  353.         if($showLiveChat == LessonEnum::NO){
  354.             return;
  355.         }
  357.         $header = [ 
  358.             'typ' => 'JWT', 
  359.             'alg' => 'HS256'
  360.         ];
  362.         $info = $this->generalService->getServiceAccess(ServicesEnum::LIVECHAT);
  364.         $client = $this->getConfiguration()->getClient();
  365.         $clientId = $client->getClientId();
  367.         $formatClientId = [
  368.             "1" => "00000{$clientId}",
  369.             "2" => "0000{$clientId}",
  370.             "3" => "000{$clientId}",
  371.             "4" => "00{$clientId}",
  372.             "5" => "0{$clientId}",
  373.         ];
  374.         
  375.         if(isset($formatClientId[strlen($clientId)])){
  376.             $clientId = $formatClientId[strlen($clientId)];
  377.         }
  378.         
  379.         $channelId = md5($clientId . $lesson->getId());
  380.         $clientStream = new \GetStream\StreamChat\Client($info->client, $info->token);
  381.         $channel = $clientStream->Channel("livestream", $channelId);
  383.         $userId = md5($clientId . $this->getUser()->getId());
  384.         $role = ($isStudent ? 'user' : 'admin' );
  386.         $stringUtil = $this->generalService->getUtil('StringUtil');
  388.         $chatToken = $info->token;
  389.         $segments = [];
  390.         $segments[] = $stringUtil->urlSafeB64Encode(json_encode($header));
  391.         $segments[] = $stringUtil->urlSafeB64Encode(json_encode([ 
  392.             "user_id" => $userId 
  393.         ]));
  395.         $signingInput = implode('.', $segments);
  396.         $signature = hash_hmac('SHA256', $signingInput, $chatToken, true);
  397.         $segments[] = $stringUtil->urlSafeB64Encode($signature);
  398.         $userToken =  implode('.', $segments);
  400.         $fileService = $this->generalService->getService('FileService');
  401.         $photo = $fileService->getFilePathComplete(
  402.             $this->getUser()->getPhoto(), 
  403.             UserEnum::PATH_PROFILES, 
  404.             true, 
  405.             true
  406.         );
  408.         return (object)[
  409.             "role" => $role,
  410.             "userId" => $userId,
  411.             "userFoto" => $photo,
  412.             "userName" => $this->getUser()->getName(),
  413.             "channelId" => $channelId,
  414.             "channelLogo" => "",
  415.             "channelName" => $lesson->getTitle(),
  416.             "userToken" => $userToken,
  417.             "clientId" => $info->client
  418.         ];
  419.     }
  421.     public function getLessonTeacher(Lesson $lesson)
  422.     {
  423.         $userLesson = $lesson->getUser();
  424.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  425.         $fileService = $this->generalService->getService('FileService');
  427.         $dataImg = [
  428.             "fileName" => $userLesson->getPhoto(),
  429.             "pathConst" => LessonEnum::PATH_PROFILES,
  430.             "option" => "l-user-profile-teacher",
  431.             "addUpload" => true,
  432.             "addStream" => true,
  433.         ];
  435.         $request = $this->generalService->getRequest();
  437.         $teacher = (object)[
  438.             "id" => $userLesson->getId(),
  439.             "ip" => $request->getClientIp(),
  440.             "name" => $userLesson->getName(),
  441.             "canAccessAdm" => $userPermissionUtil->canAccessAdm(),
  442.             "document" => $userLesson->getDocument(),
  443.             "username" => $userLesson->getUsername(),
  444.             "photo" => $fileService->getFilePathObj($dataImg),
  445.             "permissionName" => (
  446.                 $userLesson->getUserProfile() ? 
  447.                 $userLesson->getUserProfile()->getName() 
  448.                 : null
  449.             ),
  450.         ];
  452.         return $teacher;
  453.     }
  455.     public function getLessonNextContent(Lesson $lesson, ?LessonLog $lessonLog = null)
  456.     {
  457.         $libraryRepository = $this->em->getRepository(Library::class);
  458.         $examRepository = $this->em->getRepository(Exam::class);
  459.         $nextExamLesson = $examRepository->getNextExamIdByLesson($lesson, true);
  460.         $lessonAfter = $this->getLessonIdAfterThat($lesson, true);
  462.         $course = $lesson->getCourse();
  463.         $courseId = $course->getId();
  465.         $isAccessible = false;
  466.         $acessMessage = null;
  468.         $lessonAfterClass = null;
  469.         $nextContent = null;
  470.         if($nextExamLesson || $lessonAfter){
  472.             $contentPagesNumber = null;
  473.             $contentDuration = null;
  474.             $contentType = null;
  475.             $contentThumb = null;
  477.             if($lessonAfter && empty($nextExamLesson)){
  478.                 $lessonAfterClass = $this->find($lessonAfter->id);
  480.                 if($lessonAfterClass){
  481.                     $library = $lessonAfterClass->getLibrary();
  482.                     if($library){
  483.                         $contentPagesNumber = $library->getPagesNumber();
  484.                         $contentDuration = $library->getDuration();
  485.                         $contentType = $library->getType();
  487.                         $libraryType = [
  488.                             LibraryEnum::CONTENT_EMBED, 
  489.                             LibraryEnum::CONTENT_CONFERENCE, 
  490.                             LibraryEnum::CONTENT_TEXT, 
  491.                             LibraryEnum::CONTENT_FILES
  492.                         ];
  493.                         if(!in_array($contentType, $libraryType)){
  494.                             $contentThumb = $libraryRepository->getCover($library);
  495.                         }
  496.                     }
  497.                 }
  498.             }
  500.             if($nextExamLesson){
  501.                 $nextExamLessonClass = $examRepository->find($nextExamLesson->id);
  502.                 $infoAccess = $examRepository->checkExamIsAccessible($nextExamLessonClass);
  503.                 $isAccessible = $infoAccess->isAccessible;
  504.                 $acessMessage = $infoAccess->message;
  505.             }else{
  506.                 $enrollmentRepository = $this->em->getRepository(Enrollment::class);
  507.                 $courseRepository = $this->em->getRepository(Course::class);
  509.                 $enrollment = $enrollmentRepository->findOneBy([
  510.                     "user" => $this->getUser()->getId(),
  511.                     "course" => $courseId,
  512.                 ]);
  514.                 if($enrollment){
  515.                     $isStudent = $courseRepository->isStudent($course);
  516.                     $infoAccess = $this->checkLessonIsAccessibleToUser(
  517.                         $lessonAfterClass, 
  518.                         $enrollment, 
  519.                         $lessonLog, 
  520.                         $isStudent,
  521.                         $lesson->getId()
  522.                     );
  524.                     $isAccessible = $infoAccess->isAccessible;
  525.                     $acessMessage = $infoAccess->message;
  526.                 }
  527.             }
  529.             $module = null;
  531.             if($lessonAfter){
  532.                 $module = (object)[
  533.                     "id" => (int)$lessonAfter->moduleId,
  534.                     "title" => $lessonAfter->moduleTitle,
  535.                 ];
  536.             }
  538.             if($nextExamLesson){
  539.                 $module = null;
  540.                 if(!empty($nextExamLesson->moduleId)){
  541.                     $module = (object)[
  542.                         "id" => (int)$nextExamLesson->moduleId,
  543.                         "title" => $nextExamLesson->moduleTitle,
  544.                     ];
  545.                 }
  546.             }
  548.             $timeUtil = $this->generalService->getUtil('DateTimeUtil');
  550.             $nextContent = (object)[
  551.                 "id" => (int)($nextExamLesson ? $nextExamLesson->id : $lessonAfter->id),
  552.                 "lessonId" => (
  553.                     $nextExamLesson ? 
  554.                     $nextExamLesson->lessonId : 
  555.                     (int)$lessonAfter->id
  556.                 ),
  557.                 "module" => $module,
  558.                 "courseId" => (
  559.                     $nextExamLesson ? 
  560.                     $nextExamLesson->courseId : 
  561.                     (int)$lessonAfter->courseId
  562.                 ),
  563.                 "title" => ($nextExamLesson ? $nextExamLesson->title : $lessonAfter->title),
  564.                 "type" => (
  565.                     $nextExamLesson ? 
  566.                     ($nextExamLesson->type == ExamEnum::QUIZ ? 'quiz' : 'exam') : 
  567.                     'lesson'
  568.                 ),
  569.                 "contentPagesNumber" => $contentPagesNumber,
  570.                 "contentDuration" => $contentDuration ? $timeUtil->timeToSec($contentDuration) : null,
  571.                 "contentType" => $contentType,
  572.                 "contentThumb" => $contentThumb,
  573.                 "isAccessible" => $isAccessible,
  574.                 "acessMessage" => $acessMessage,
  575.             ];
  576.         }
  578.         return $nextContent;
  579.     }
  581.     public function getLessonLastContent(Lesson $lesson)
  582.     {
  583.         $libraryRepository = $this->em->getRepository(Library::class);
  584.         $examRepository = $this->em->getRepository(Exam::class);
  585.         $lastExamLesson = $examRepository->getLastExamIdByLesson($lesson, true);
  586.         $lessonBefore = $this->getLessonIdBeforeThat($lesson, true);
  587.         $timeUtil = $this->generalService->getUtil('DateTimeUtil');
  589.         $lastContent = null;
  590.         if($lastExamLesson || $lessonBefore){
  592.             $contentPagesNumber = null;
  593.             $contentDuration = null;
  594.             $contentType = null;
  595.             $contentThumb = null;
  597.             if($lessonBefore && empty($lastExamLesson)){
  599.                 $lessonBeforeClass = $this->find($lessonBefore->id);
  601.                 if($lessonBeforeClass){
  602.                     $library = $lessonBeforeClass->getLibrary();
  603.                     if($library){
  604.                         $contentPagesNumber = $library->getPagesNumber();
  605.                         $contentDuration = $library->getDuration();
  606.                         $contentType = $library->getType();
  607.                         
  608.                         $libraryType = [
  609.                             LibraryEnum::CONTENT_EMBED, 
  610.                             LibraryEnum::CONTENT_CONFERENCE, 
  611.                             LibraryEnum::CONTENT_TEXT, 
  612.                             LibraryEnum::CONTENT_FILES
  613.                         ];
  614.                         if(!in_array($contentType, $libraryType)){
  615.                             $contentThumb = $libraryRepository->getCover($library);
  616.                         }
  617.                     }
  618.                 }
  619.             }
  621.             $module = (object)[
  622.                 "id" => (int)$lessonBefore->moduleId,
  623.                 "title" => $lessonBefore->moduleTitle,
  624.             ];
  626.             if($lastExamLesson){
  627.                 $module = null;
  628.                 if(!empty($lastExamLesson->moduleId)){
  629.                     $module = (object)[
  630.                         "id" => (int)$lastExamLesson->moduleId,
  631.                         "title" => $lastExamLesson->moduleTitle,
  632.                     ];
  633.                 }
  634.             }
  636.             $lastContent = (object)[
  637.                 "id" => (int)($lastExamLesson ? $lastExamLesson->id : $lessonBefore->id),
  638.                 "lessonId" => (
  639.                     $lastExamLesson ? 
  640.                     $lastExamLesson->lessonId : 
  641.                     (int)$lessonBefore->id
  642.                 ),
  643.                 "module" => $module,
  644.                 "courseId" => (
  645.                     $lastExamLesson ? 
  646.                     $lastExamLesson->courseId : 
  647.                     (int)$lessonBefore->courseId
  648.                 ),
  649.                 "title" => ($lastExamLesson ? $lastExamLesson->title : $lessonBefore->title),
  650.                 "type" => (
  651.                     $lastExamLesson ? 
  652.                     ($lastExamLesson->type == ExamEnum::QUIZ ? 'quiz' : 'exam') : 
  653.                     'lesson'
  654.                 ),
  655.                 "contentPagesNumber" => $contentPagesNumber,
  656.                 "contentDuration" => $contentDuration ? $timeUtil->timeToSec($contentDuration) : null,
  657.                 "contentType" => $contentType,
  658.                 "contentThumb" => $contentThumb,
  659.                 "isAccessible" => true,
  660.                 "acessMessage" => null,
  661.             ];
  662.         }
  664.         return $lastContent;
  665.     }
  667.     public function getShowLiveChat(Lesson $lesson, ?bool $isStudent = true)
  668.     {   
  669.         $library = $lesson->getLibrary();
  671.         if(!$library){
  672.             return LessonEnum::NO;
  673.         }
  675.         if($library->getType() == LibraryEnum::CONTENT_LIVE){
  676.             if($this->configuration->checkModuleIsAbleOnPlan('liveContentFunction')){
  677.                 if($lesson->getShowLiveChat() == LessonEnum::YES){
  678.                     $liveDateStart = $library->getLiveStart();
  680.                     $timeLiveEnd = date('Y-m-d', strtotime($liveDateStart));
  681.                     $timeLiveStart = strtotime($liveDateStart . ' - 1 hours'); 
  682.                     $todayDate = date('Y-m-d');
  683.                     $timeToday = strtotime($todayDate);
  685.                     if(
  686.                         $timeToday >= $timeLiveStart && 
  687.                         $todayDate == $timeLiveEnd || !$isStudent
  688.                     ){
  689.                         return LessonEnum::YES;
  690.                     }
  691.                 }
  692.             }
  693.         }
  695.         return LessonEnum::NO;
  696.     }
  698.     public function findItems(?Course $course)
  699.     {
  700.         $query = $this->createQueryBuilder('l');
  702.         if($course){
  703.             $query->andWhere('l.course = :courseId');
  704.             $query->setParameter('courseId', $course->getId());
  705.         }
  707.         return $query->orderBy('l.order', 'ASC')->getQuery()->getResult();
  708.     }
  710.     public function countLessons()
  711.     {
  712.         $query = $this->createQueryBuilder('l');
  713.         $query->select("COUNT(l.id) AS total");
  714.         $query->andWhere('l.deleted != :deleted');
  715.         $query->setParameter('deleted', LessonEnum::ITEM_DELETED);
  717.         $result = (object)$query->getQuery()->getOneOrNullResult();
  718.         return $result->total;
  719.     }
  721.     public function countLessonByLibrary(int $libraryId, ?Lesson $lesson = null)
  722.     {
  723.         
  724.         $query = $this->createQueryBuilder('l');
  725.         $query->select("COUNT(l.id) AS total");
  727.         $query->andWhere('l.library = :library');
  728.         $query->andWhere('l.deleted != :deleted');
  729.         
  730.         $query->setParameter('deleted', LessonEnum::ITEM_DELETED);
  731.         $query->setParameter('library', $libraryId);
  733.         if(!empty($lesson)){
  734.             $query->andWhere('l.id =! :lessonId');
  735.             $query->setParameter('lessonId', $lesson->getId());
  736.         }
  738.         $result = (object)$query->getQuery()->getOneOrNullResult();
  739.         return $result->total;
  740.     }
  742.     public function countAllLessonByLibraryType(?int $status = null, ?int $type = null)
  743.     {
  744.         $query = $this->createQueryBuilder('l');
  745.         $query->select("COUNT(l.id) AS total");
  747.         if(!is_null($type)){
  748.             $query->innerJoin('EADPlataforma:Library', 'lb', 'WITH', 'lb.id = l.library');
  749.             $query->andWhere('lb.type = :type');
  750.             $query->andWhere('lb.deleted = :deleted');
  752.             $query->setParameter('type', $type);
  753.             $query->setParameter('deleted', LibraryEnum::ITEM_NO_DELETED);
  754.         }
  756.         if(!empty($status)){
  757.             $query->andWhere('l.status = :status');
  758.             $query->setParameter('status', $status);
  759.         }
  761.         $query->andWhere('l.deleted = :deleted');
  762.         $query->setParameter('deleted', LessonEnum::ITEM_NO_DELETED);
  764.         $result = (object)$query->getQuery()->getOneOrNullResult();
  765.         return $result->total;
  766.     }
  768.     public function getAllLessonByLibraryLive(?int $user = null)
  769.     {
  770.         $query = $this->createQueryBuilder('l');
  772.         $query->innerJoin('EADPlataforma:Course', 'c', 'WITH', 'l.course = c.id');
  773.         $query->innerJoin('EADPlataforma:LessonModule', 'lm', 'WITH', 'l.lessonModule = lm.id');
  774.         $query->innerJoin('EADPlataforma:Library', 'lb', 'WITH', 'lb.id = l.library');
  776.         $query->andWhere('(lb.type = :type OR lb.type = :typeExternalLive)');
  777.         $query->setParameter('type', LibraryEnum::CONTENT_LIVE);
  778.         $query->setParameter('typeExternalLive', LibraryEnum::CONTENT_EXTERNAL_LIVE);
  779.         
  781.         if(!empty($user)){
  782.             
  783.             $query->andWhere('(
  784.                 l.user = :user OR 
  785.                 lm.user = :user OR 
  786.                 c.user = :user
  787.             )');
  789.             $query->setParameter('user', $user);
  790.         }
  792.         $query->andWhere('c.deleted = :deletedCourse');
  793.         $query->andWhere('lm.deleted = :deletedLessonModule');
  794.         $query->andWhere('lb.deleted = :deletedLibrary');
  795.         $query->andWhere('l.deleted = :deleted');
  797.         $query->setParameter('deletedCourse', CourseEnum::ITEM_NO_DELETED);
  798.         $query->setParameter('deletedLessonModule', LessonModuleEnum::ITEM_NO_DELETED);
  799.         $query->setParameter('deletedLibrary', LibraryEnum::ITEM_NO_DELETED);
  800.         $query->setParameter('deleted', LessonEnum::ITEM_NO_DELETED);
  802.         $data = $query->getQuery()->getResult();
  804.         return $data;
  805.     }
  807.     public function getAllLessons()
  808.     {
  809.         $query = $this->createQueryBuilder('l');
  811.         $query->select('
  812.             l.id AS lessonId,
  813.             c.id AS courseId,
  814.             lm.id AS lessonModuleId,
  815.             l.title AS lessonTitle,
  816.             c.title AS courseTitle,
  817.             lm.title AS lessonModuleTitle
  818.         ');
  820.         $query->innerJoin(
  821.             'EADPlataforma:Course', 
  822.             'c', 
  823.             'WITH', 
  824.             'c.id = l.course AND c.deleted = :courseDeleted'
  825.         );
  827.         $query->innerJoin(
  828.             'EADPlataforma:LessonModule', 
  829.             'lm', 
  830.             'WITH', 
  831.             'lm.id = l.lessonModule AND lm.deleted = :lessonModuleDeleted'
  832.         );
  834.         $query->andWhere('l.deleted = :lessonDeleted');
  836.         $query->setParameter('courseDeleted', CourseEnum::ITEM_NO_DELETED);
  837.         $query->setParameter('lessonModuleDeleted', LessonModuleEnum::ITEM_NO_DELETED);
  838.         $query->setParameter('lessonDeleted', LessonEnum::ITEM_NO_DELETED);
  840.         $query->addOrderBy('c.order', 'ASC');
  841.         $query->addOrderBy('lm.order', 'ASC');
  842.         $query->addOrderBy('l.order', 'ASC');
  844.         $data = $query->getQuery()->getResult();
  846.         return $data;
  847.     }
  849.     public function getLessonPublicDemoById(int $lessonId)
  850.     {
  851.         $query = $this->createQueryBuilder('l');
  852.         $query->innerJoin(
  853.             'EADPlataforma:LessonModule', 
  854.             'lm', 
  855.             'WITH', 
  856.             'lm.id = l.lessonModule AND lm.deleted = 0'
  857.         );
  859.         $query->innerJoin(
  860.             'EADPlataforma:Course', 
  861.             'c', 
  862.             'WITH', 
  863.             'c.id = l.course AND c.deleted = 0'
  864.         );
  866.         $query->andWhere('l.deleted = 0');
  867.         $query->andWhere('l.id = :lessonId');
  868.         $query->andWhere('l.demonstration = :demonstration');
  869.         $query->andWhere('c.status = :courseStatus');
  870.         $query->andWhere('l.status = :lessonStatus');
  871.         $query->andWhere('lm.status = :lessonModuleStatus');
  873.         $query->setParameter('lessonId', $lessonId);
  874.         $query->setParameter('demonstration', LessonEnum::YES);
  875.         $query->setParameter('courseStatus', CourseEnum::PUBLISHED);
  876.         $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  877.         $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  879.         $data = $query->getQuery()->getOneOrNullResult();
  880.         return $data;
  881.     }
  883.     public function isLessonTeacher(Lesson $lesson, User $user)
  884.     {
  885.         if(!$lesson->getCourse()){
  886.             return false;
  887.         }
  889.         if(!$lesson->getLessonModule()){
  890.             return false;
  891.         }
  893.         $courseTeacherId = $lesson->getCourse()->getUser()->getId();
  894.         $lessonModuleTeacherId = $lesson->getLessonModule()->getUser()->getId();
  895.         $lessonTeacherId = $lesson->getUser()->getId();
  897.         if(
  898.             $courseTeacherId == $user->getId() || 
  899.             $lessonModuleTeacherId == $user->getId() || 
  900.             $lessonTeacherId == $user->getId()
  901.         ){
  902.             return true;
  903.         }
  905.         return false;
  906.     }
  908.     public function checkLessonIsAccessibleToUser(
  909.         Lesson $lesson, 
  910.         Enrollment $enrollment, 
  911.         ?LessonLog $log = null, 
  912.         ?bool $isStudent = true,
  913.         ?int $lessonIdBefore = null,
  914.         ?bool $blockIsNotAccess = false
  915.     )
  916.     {
  917.         $info = (object)[
  918.             "isAccessible" => false,
  919.             "isAccessPeriodExpired" => false,
  920.             "message" => null,
  921.         ];
  923.         if(!$this->getUser()){
  925.             $info->message = $this->configuration->getLanguage('error_auth', 'lesson_view_error');
  927.             return $info;
  928.         }
  930.         $user = $enrollment->getUser();
  931.         $course = $lesson->getCourse();
  932.         $lessonModule = $lesson->getLessonModule();
  934.         $today = strtotime('now');
  935.         if(!$isStudent){
  937.             $info->isAccessible = true;
  939.             return $info;
  940.         }
  942.         if(!$enrollment){
  944.             $info->message = $this->configuration->getLanguage(
  945.                 'error_enrollment_not_found',
  946.                 'lesson_view'
  947.             );
  949.             return $info;
  950.         }
  952.         if(
  953.             $lesson->getStatus() == LessonEnum::DRAFT ||
  954.             $lessonModule->getStatus() == LessonModuleEnum::DRAFT ||
  955.             $course->getStatus() == CourseEnum::DRAFT
  956.         ){
  957.             $info->message = $this->configuration->getLanguage(
  958.                 'error_unavailable',
  959.                 'lesson_view'
  960.             );
  962.             return $info;
  963.         }
  965.         if($enrollment->getStatus(false, true) == EnrollmentEnum::STATUS_EXPIRED){
  966.             
  967.             $info->message = $this->configuration->getLanguage(
  968.                 'error_enrollment_expired', 
  969.                 'lesson_view_error'
  970.             );
  972.             return $info;
  973.         }
  975.         $courseDateRelease = strtotime($course->getDateRelease());
  976.         if($courseDateRelease >= $today){
  978.             $info->message = "{$this->configuration->getLanguage(
  979.                 'error_date_release', 
  980.                 'lesson_view_error'
  981.             )} {$course->getDateRelease('d/m/Y')}";
  983.             return $info;
  984.         }
  986.         $lessonModuleRepository = $this->em->getRepository(LessonModule::class);
  987.         $moduleInfo = $lessonModuleRepository->checkLessonModuleIsAccessibleToUser(
  988.             $lessonModule, 
  989.             $enrollment, 
  990.             $isStudent,
  991.             $lessonIdBefore
  992.         );
  993.         
  994.         if(!$moduleInfo->isAccessible) {
  996.             return $moduleInfo;
  997.         }
  999.         $unlimitedexamFunction = $this->configuration->checkModuleIsAbleOnPlan(
  1000.             'unlimitedExamFunction'
  1001.         );
  1003.         $hasLessonControl = $this->configuration->checkModuleIsAbleOnPlan(
  1004.             'lessonControlFunction'
  1005.         );
  1007.         $examModule = $this->configuration->isModuleActive("exam_module");
  1009.         if(!$hasLessonControl){
  1010.             $info->isAccessible = true;
  1012.             return $info;
  1013.         }
  1015.         $lessonLogRepository = $this->emEadmin->getRepository(LessonLog::class);
  1016.         if(empty($log)){
  1017.             $logLessonId = "{$course->getId()}#{$user->getId()}#{$lesson->getId()}";
  1018.             $log = $lessonLogRepository->find($logLessonId);
  1019.         }
  1021.         if($log && !empty($log->getDateConclusion())){
  1022.             $info->isAccessible = true;
  1024.             $periodEnd = $lesson->getControlClosePeriod();
  1025.             if(!empty($periodEnd)){
  1026.                 $dateEnd = strtotime("{$log->getDateConclusion()} + {$periodEnd} days");
  1027.                 if($dateEnd < $today){                    
  1028.                     $info->isAccessible = false;
  1029.                     $info->isAccessPeriodExpired = true;
  1030.                 }
  1031.             }
  1033.             return $info;
  1034.         }
  1036.         if($blockIsNotAccess){
  1037.             $info->message = $this->configuration->getLanguage(
  1038.                 'error_required_incomplete', 
  1039.                 'lesson_view_error'
  1040.             );
  1042.             return $info;
  1043.         }
  1045.         if($examModule){
  1046.             if($log && empty($log->getDateConclusion()) || !$log){
  1048.                 $examUserRepository = $this->em->getRepository(ExamUser::class);
  1049.                 $currentExam = $examUserRepository->getCurrentExamOnCourseToUserByLesson(
  1050.                     $lesson, 
  1051.                     $user
  1052.                 );
  1053.                 if($currentExam){
  1054.                     if($unlimitedexamFunction){
  1055.                         //check the exam type
  1056.                         if($currentExam->getType() == ExamEnum::LESSON){
  1057.                             $lessonExam = $currentExam->getLesson();
  1058.                             $lessonModuleExam = $lessonExam->getLessonModule();
  1060.                             //if exam is from this lesson redirect to exam
  1061.                             if($lessonExam->getId() != $lesson->getId()){
  1062.                                 //if the exam is from a module before that redirect to exam
  1063.                                 if($lessonModuleExam->getOrder() < $lessonModule->getOrder()){
  1064.                                     $info->message = $this->configuration->getLanguage(
  1065.                                         'error_required_incomplete', 
  1066.                                         'lesson_view_error'
  1067.                                     );
  1069.                                     return $info;
  1070.                                 }else if(
  1071.                                     $lessonExam->getOrder() < $lesson->getOrder() && 
  1072.                                     $lessonModuleExam->getId() == $lessonModule->getId()
  1073.                                 ){ //if is the same module but the lesson is before that rediret to exam
  1074.                                     $info->message = $this->configuration->getLanguage(
  1075.                                         'error_required_incomplete', 
  1076.                                         'lesson_view_error'
  1077.                                     );
  1079.                                     return $info;
  1080.                                 }
  1081.                             }
  1082.                         }else if($currentExam->getType() == ExamEnum::MODULE){
  1083.                             $lessonModuleExam = $currentExam->getLessonModule();
  1084.                             
  1085.                             if(
  1086.                                 $lessonModuleExam->getId() != $lessonModule->getId() && 
  1087.                                 $lessonModuleExam->getOrder() < $lessonModule->getOrder()
  1088.                             ){ //if is not the same module and the module is before that rediret to exam
  1089.                                 $info->message = $this->configuration->getLanguage(
  1090.                                     'error_required_incomplete', 
  1091.                                     'lesson_view_error'
  1092.                                 );
  1094.                                 return $info;
  1095.                             }
  1096.                         }
  1097.                     }
  1099.                     if($currentExam->getType() == ExamEnum::COURSE){
  1100.                         $info->message = $this->configuration->getLanguage(
  1101.                             'error_required_incomplete', 
  1102.                             'lesson_view_error'
  1103.                         );
  1105.                         return $info;
  1106.                     }
  1107.                 }
  1109.                 if($unlimitedexamFunction){
  1110.                     $examRepository = $this->em->getRepository(Exam::class);
  1111.                     $exam = $examRepository->getCurrentNotStartedExamUser(
  1112.                         $lesson, 
  1113.                         $user
  1114.                     );
  1116.                     if($exam){
  1117.                         $lessonExam = $exam->getLesson();
  1118.                         if(!$lessonExam || $lessonExam->getId() != $lesson->getId()){
  1120.                             $info->message = $this->configuration->getLanguage(
  1121.                                 'error_required_incomplete', 
  1122.                                 'lesson_view_error'
  1123.                             );
  1125.                             return $info;
  1126.                         }
  1127.                     }
  1128.                 }
  1129.             }
  1130.         }
  1132.         //if exist a lesson with requirement before that redirect to there
  1133.         $currentLesson = $this->getCurrentLesson($lesson, $user);
  1134.         if(!empty($currentLesson)){
  1135.             if($currentLesson->getId() != $lesson->getId()){
  1136.                 $logId = "{$course->getId()}#{$user->getId()}#{$currentLesson->getId()}";
  1137.                 $logCurrent = $lessonLogRepository->find($logId);
  1139.                 if(empty($logCurrent)){
  1140.                     $info->message = $this->configuration->getLanguage(
  1141.                         'error_required_incomplete', 
  1142.                         'lesson_view_error'
  1143.                     );
  1145.                     return $info;
  1146.                 }else if(empty($logCurrent->getDateConclusion())){
  1147.                     $info->message = $this->configuration->getLanguage(
  1148.                         'error_required_incomplete', 
  1149.                         'lesson_view_error'
  1150.                     );
  1152.                     return $info;
  1153.                 }
  1154.             }
  1155.         }
  1157.         if($lesson->getControlReleaseType() == LessonEnum::RELEASED){
  1158.             $info->isAccessible = true;
  1160.             return $info;
  1161.         }else if($lesson->getControlReleaseType() == LessonEnum::FIXED_DATE){
  1162.             $controlDateRelease = $lesson->getControlDateRelease();
  1163.             $time = strtotime($controlDateRelease);
  1165.             $todaySeconds = strtotime(date('Y-m-d H:i:s'));
  1166.            
  1167.             $controlClosePeriod = $lesson->getControlClosePeriod();
  1168.             if(!empty($controlClosePeriod)){
  1169.                 $timeLog = strtotime(
  1170.                     "{$controlDateRelease} + {$controlClosePeriod} day"
  1171.                 );
  1173.                 if($todaySeconds > $timeLog){
  1175.                     $timeLogText = date('d/m/Y H:i:s', $timeLog);
  1177.                     $info->message = "{$this->configuration->getLanguage(
  1178.                         'error_date_end', 
  1179.                         'lesson_view_error'
  1180.                     )} {$timeLogText}";
  1182.                     return $info;
  1183.                 }
  1184.             }
  1185.            
  1186.             if($today >= $time){
  1187.                 $info->isAccessible = true;
  1189.                 return $info;
  1190.             }
  1192.             $timeText = date('d/m/Y H:i:s', $time);
  1193.                         
  1194.             $info->message = "{$this->configuration->getLanguage(
  1195.                 'error_date_release', 
  1196.                 'lesson_view_error'
  1197.             )} {$timeText}";
  1199.             return $info;
  1201.         }else if($lesson->getControlReleaseType() == LessonEnum::FLEXIBLE_DATE){
  1202.             $controlReleasePeriod = $lesson->getControlReleasePeriod();
  1203.             if($lesson->getControlReleaseAfterType() == LessonEnum::ENROLLMENT){
  1204.                 $time = strtotime(
  1205.                     "{$enrollment->getDateRegister()} + {$controlReleasePeriod} day"
  1206.                 );
  1207.                 
  1208.                 $todaySeconds = strtotime(date('Y-m-d H:i:s'));
  1209.                 $controlClosePeriod = $lesson->getControlClosePeriod();
  1210.                 if(!empty($controlClosePeriod)){
  1211.                     
  1212.                     /*
  1213.                     if($log && empty($log->getDateConclusion()) || !$log){
  1214.                         return false;
  1215.                     }
  1216.                     
  1217.                     if($log->getComplete() == LessonEnum::NO){
  1218.                         return false;
  1219.                     }*/
  1221.                     if($log && !empty($log->getDateConclusion())){
  1222.                         $timeLog = strtotime(
  1223.                             "{$log->getDateConclusion()} + {$controlClosePeriod} day"
  1224.                         );
  1226.                         if($todaySeconds > $timeLog){
  1227.                             $timeLogText = date('d/m/Y H:i:s', $timeLog);
  1229.                             $info->message = "{$this->configuration->getLanguage(
  1230.                                 'error_date_end', 
  1231.                                 'lesson_view_error'
  1232.                             )} {$timeLogText}";
  1234.                             return $info;
  1235.                         }
  1236.                     }
  1237.                 }
  1238.                 
  1239.                 if($today >= $time){
  1240.                     $info->isAccessible = true;
  1242.                     return $info;
  1243.                 }
  1245.                 $timeText = date('d/m/Y H:i:s', $time);
  1246.                         
  1247.                 $info->message = "{$this->configuration->getLanguage(
  1248.                     'error_date_release', 
  1249.                     'lesson_view_error'
  1250.                 )} {$timeText}";
  1252.                 return $info;
  1253.             }else if(
  1254.                 $lesson->getControlReleaseAfterType() == LessonEnum::LAST_LESSON && 
  1255.                 !empty($lessonIdBefore)
  1256.             ){
  1257.                 $logId = "{$course->getId()}#{$user->getId()}#{$lessonIdBefore}";
  1258.                 $logLast = $lessonLogRepository->find($logId);
  1259.                 
  1260.                 if($logLast && !empty($logLast->getDateConclusion())){
  1261.                     $time = strtotime(
  1262.                         "{$logLast->getDateConclusion()} + {$controlReleasePeriod} day"
  1263.                     );
  1264.                     if($today >= $time){
  1265.                         $info->isAccessible = true;
  1267.                         return $info;
  1268.                     }
  1269.                 }
  1270.             }
  1271.         }
  1273.         $info->message = $this->configuration->getLanguage('error_unavailable', 'lesson_view_error');
  1275.         return $info;
  1276.     }
  1278.     public function getLessonDateReleaseAccess(
  1279.         Lesson $lesson, 
  1280.         Enrollment $enrollment, 
  1281.         ?bool $isStudent = true, 
  1282.         ?int $lessonIdBefore = null
  1283.     )
  1284.     {
  1285.         $date = date('Y-m-d H:i:s');
  1287.         if(!$this->getUser()){
  1288.             return $date;
  1289.         }
  1291.         $user = $enrollment->getUser();
  1292.         $course = $lesson->getCourse();
  1293.         $today = strtotime('now');
  1295.         if(!$isStudent){
  1296.             return $date;
  1297.         }
  1299.         if(!$enrollment){
  1300.             return $date;
  1301.         }
  1303.         $lessonLogRepository = $this->emEadmin->getRepository(LessonLog::class);
  1304.         if($lesson->getStatus() == LessonEnum::PUBLISHED){
  1305.             if($lesson->getControlReleaseType() == LessonEnum::RELEASED){
  1306.                 return $date;
  1307.             }else if($lesson->getControlReleaseType() == LessonEnum::FIXED_DATE){
  1308.                 return $lesson->getControlDateRelease();
  1309.             }else if($lesson->getControlReleaseType() == LessonEnum::FLEXIBLE_DATE){
  1310.                 $controlReleasePeriod = $lesson->getControlReleasePeriod();
  1311.                 if($lesson->getControlReleaseAfterType() == LessonEnum::ENROLLMENT){
  1312.                     $time = strtotime(
  1313.                         "{$enrollment->getDateRegister()} + {$controlReleasePeriod} day"
  1314.                     );
  1315.                     return date('Y-m-d H:i:s', $time);
  1316.                 }else if(
  1317.                     $lesson->getControlReleaseAfterType() == LessonEnum::LAST_LESSON && 
  1318.                     !empty($lessonIdBefore)
  1319.                 ){
  1320.                     $logId = "{$course->getId()}#{$user->getId()}#{$lessonIdBefore}";
  1321.                     $logLast = $lessonLogRepository->find($logId);
  1323.                     if($logLast){
  1324.                         $time = strtotime(
  1325.                             "{$logLast->getDateConclusion()} + {$controlReleasePeriod} day"
  1326.                         );
  1327.                         return date('Y-m-d H:i:s', $time);
  1328.                     }
  1329.                 }
  1330.             }
  1331.         }
  1333.         return $date;
  1334.     }
  1336.     public function getCurrentLessonLogOrigin(Lesson $lessonBase)
  1337.     {
  1339.         $course = $lessonBase->getCourse();
  1340.         $lessonModule = $lessonBase->getLessonModule();
  1342.         $query = $this->createQueryBuilder('l');
  1343.         $query->select('l.id');
  1344.         $query->innerJoin(
  1345.             'EADPlataforma:LessonModule', 
  1346.             'lm', 
  1347.             'WITH', 
  1348.             'lm.id = l.lessonModule'
  1349.         );
  1351.         $query->leftJoin(
  1352.             'EADPlataforma:LessonLogOrigin', 
  1353.             'lg', 
  1354.             'WITH', 
  1355.             'lg.lesson = l.id AND lg.user = :user'
  1356.         );
  1358.         $query->andWhere('l.deleted = 0');
  1359.         $query->andWhere('lm.deleted = 0');
  1360.         $query->andWhere('l.controlRequirement = :requirement');
  1361.         $query->andWhere('l.status = :lessonStatus');
  1362.         $query->andWhere('lm.status = :lessonModuleStatus');
  1363.         $query->andWhere('l.course = :course');
  1365.         if($lessonBase->getOrder() == LessonEnum::YES){
  1366.             $query->andWhere('(
  1367.                 ( l.order <= :orderL AND lm.order = :orderLM ) OR ( lm.order < :orderLM )
  1368.             )');
  1369.         }else{
  1370.             $query->andWhere('(
  1371.                 ( l.order < :orderL AND lm.order = :orderLM ) OR ( lm.order < :orderLM )
  1372.             )');
  1373.         }
  1375.         $query->andWhere('lg.dateConclusion IS NULL');
  1377.         $query->setParameter('user', $this->getUser()->getId());
  1378.         $query->setParameter('course', $lessonBase->getCourse()->getId());
  1379.         $query->setParameter('requirement', LessonEnum::YES);
  1380.         $query->setParameter('orderL', $lessonBase->getOrder());
  1381.         $query->setParameter('orderLM', $lessonModule->getOrder());
  1382.         $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  1383.         $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  1385.         $query->addOrderBy('lm.order', 'ASC');
  1386.         $query->addOrderBy('l.order', 'ASC');
  1388.         $query->setMaxResults(1);
  1390.         $lesson = (object)$query->getQuery()->getOneOrNullResult();
  1392.         if(!empty($lesson->id)){
  1393.             return $this->findOneBy([ "id" => $lesson->id ]);
  1394.         }
  1396.         return;
  1397.     }
  1399.     public function getCurrentLesson(Lesson $lessonBase, User $user)
  1400.     {
  1401.         $course = $lessonBase->getCourse();
  1402.         $lessonModule = $lessonBase->getLessonModule();
  1404.         $query = $this->createQueryBuilder('l');
  1405.         $query->select('l.id');
  1407.         $query->innerJoin('EADPlataforma:Course', 'c', 'WITH', 'c.id = l.course');
  1409.         $query->innerJoin(
  1410.             'EADPlataforma:LessonModule', 'lm', 'WITH', 'lm.id = l.lessonModule'
  1411.         );
  1413.         $query->innerJoin('EADPlataforma:Library', 'lb', 'WITH', 'lb.id = l.library');
  1414.         
  1415.         $query->andWhere('c.deleted = 0');
  1416.         $query->andWhere('l.deleted = 0');
  1417.         $query->andWhere('lm.deleted = 0');
  1418.         $query->andWhere('lb.deleted = 0');
  1420.         $query->andWhere('l.controlRequirement = :requirement');
  1421.         $query->andWhere('l.status = :lessonStatus');
  1422.         $query->andWhere('lm.status = :lessonModuleStatus');
  1423.         $query->andWhere('l.course = :course');
  1424.         $query->andWhere('l.id != :lessonBase');
  1426.         if($lessonBase->getOrder() == LessonEnum::YES){
  1427.             $query->andWhere('(
  1428.                 ( l.order <= :orderL AND lm.order = :orderLM ) OR ( lm.order < :orderLM )
  1429.             )');
  1430.         }else{
  1431.             $query->andWhere('(
  1432.                 ( l.order < :orderL AND lm.order = :orderLM ) OR ( lm.order < :orderLM )
  1433.             )');
  1434.         }
  1436.         $query->setParameter('course', $lessonBase->getCourse()->getId());
  1437.         $query->setParameter('requirement', LessonEnum::YES);
  1438.         $query->setParameter('orderL', $lessonBase->getOrder());
  1439.         $query->setParameter('orderLM', $lessonModule->getOrder());
  1440.         $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  1441.         $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  1442.         $query->setParameter('lessonBase', $lessonBase->getId());
  1444.         $query->addOrderBy('lm.order', 'DESC');
  1445.         $query->addOrderBy('l.order', 'DESC');
  1447.         $query->setMaxResults(1);
  1449.         $lesson = (object)$query->getQuery()->getOneOrNullResult();
  1451.         if(!empty($lesson->id)){
  1452.             $logId = "{$course->getId()}#{$user->getId()}#{$lesson->id}";
  1453.             $log = $this->emEadmin->getRepository(LessonLog::class)->find($logId);
  1455.             if(!$log || ($log && empty($log->getDateConclusion()))){
  1456.                 return $this->findOneBy([ "id" => $lesson->id ]);
  1457.             }
  1458.         }
  1460.         return;
  1461.     }
  1463.     public function getCourseLessonsIds(
  1464.         Course $course, 
  1465.         ?LessonModule $lessonModule = null, 
  1466.         ?string $searchText = null
  1467.     )
  1468.     {
  1469.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  1470.         $permission = $userPermissionUtil->getPermission("course", "see");
  1471.         $user = $userPermissionUtil->getUser();
  1472.         $lessonModuleId = ($lessonModule ? $lessonModule->getId() : null);
  1474.         $keyCache = md5(
  1475.             "getCourseLessonsIds{$course->getId()}-{$user->getId()}-{$lessonModuleId}"
  1476.         );
  1478.         if(isset($this->lessonIdsCourse[$keyCache])){
  1479.             return $this->lessonIdsCourse[$keyCache];
  1480.         }
  1482.         $isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
  1483.             $course, 
  1484.             $user
  1485.         );
  1486.         
  1487.         $query = $this->createQueryBuilder('l');
  1489.         $query->select('
  1490.             l.id, 
  1491.             l.title,
  1492.             IDENTITY(l.course) AS courseId,
  1493.             IDENTITY(l.lessonModule) AS moduleId,
  1494.             lm.title AS moduleTitle
  1495.         ');
  1497.         $query->innerJoin(
  1498.             'EADPlataforma:LessonModule', 'lm', 'WITH', 'lm.id = l.lessonModule'
  1499.         );
  1501.         if(!empty($searchText)){
  1502.             $query->andWhere('l.title LIKE :searchText');
  1503.             $query->setParameter('searchText', "%{$searchText}%");
  1504.         }
  1506.         $query->andWhere('l.deleted = 0');
  1507.         $query->andWhere('lm.deleted = 0');
  1509.         $query->andWhere('l.course = :courseId');
  1510.         $query->setParameter('courseId', $course->getId());
  1512.         if($lessonModule){
  1513.             $query->andWhere('l.lessonModule = :lessonModuleId');
  1514.             $query->setParameter('lessonModuleId', $lessonModule->getId());
  1515.         }
  1517.         if(
  1518.             $userPermissionUtil->isLow($permission) || 
  1519.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  1520.         ){
  1522.             $query->andWhere('l.status = :lessonStatus');
  1523.             $query->andWhere('lm.status = :lessonModuleStatus');
  1524.             $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  1525.             $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  1526.         }
  1527.         
  1528.         $query->addOrderBy('lm.order', 'ASC');
  1529.         $query->addOrderBy('l.order', 'ASC');
  1530.         
  1531.         $data = $query->getQuery()->execute();
  1533.         $this->lessonIdsCourse[$keyCache] = $data;
  1535.         return $this->lessonIdsCourse[$keyCache];
  1536.     }
  1538.     public function getLessonIdBeforeThat(Lesson $lessonBase, bool $complete = false)
  1539.     {
  1540.         $lessons = $this->getCourseLessonsIds($lessonBase->getCourse());
  1542.         foreach ($lessons as $key => $lesson) {
  1543.             $lesson = (object)$lesson;
  1544.             if($lesson->id == $lessonBase->getId()){
  1545.                 if($key == 0){
  1546.                     return;
  1547.                 }else{
  1548.                     $obj = (object)$lessons[$key-1];
  1550.                     if($complete){
  1551.                         return $obj;
  1552.                     }
  1553.                     
  1554.                     return $obj->id;
  1555.                 }
  1556.             }
  1557.         }
  1558.         return;
  1559.     }
  1561.     public function getLessonIdAfterThat(Lesson $lessonBase, bool $complete = false)
  1562.     {
  1563.         $lessons = $this->getCourseLessonsIds($lessonBase->getCourse());
  1564.         $maxPosition = count($lessons) - 1;
  1566.         foreach ($lessons as $key => $lesson) {
  1567.             $lesson = (object)$lesson;
  1568.             if($lesson->id == $lessonBase->getId()){
  1569.                 if($key == $maxPosition){
  1570.                     return;
  1571.                 }else{
  1572.                     $obj = (object)$lessons[$key+1];
  1574.                     if($complete){
  1575.                         return $obj;
  1576.                     }
  1578.                     return $obj->id;
  1579.                 }
  1580.             }
  1581.         }
  1582.         return;
  1583.     }
  1585.     public function refreshOrder(
  1586.         $courseId, 
  1587.         $lessonModuleId, 
  1588.         $oldOrder, 
  1589.         $newOrder, 
  1590.         $isDelete = false
  1591.     )
  1592.     {
  1593.         $sql = "UPDATE EADPlataforma:Lesson AS l 
  1594.                 SET l.order = l.order - 1 
  1595.                 WHERE l.order > :oldOrder
  1596.                 AND l.deleted = 0
  1597.                 AND l.course = :courseId
  1598.                 AND l.lessonModule = :lessonModuleId ";
  1599.         
  1600.         $query = $this->em->createQuery($sql);
  1602.         $query->setParameter('oldOrder', $oldOrder);
  1603.         $query->setParameter('courseId', $courseId);
  1604.         $query->setParameter('lessonModuleId', $lessonModuleId);
  1605.         
  1606.         $query->execute();
  1608.         if(!$isDelete){
  1609.             $sql = "UPDATE EADPlataforma:Lesson AS l 
  1610.                     SET l.order = l.order + 1 
  1611.                     WHERE l.order >= :newOrder
  1612.                     AND l.deleted = 0
  1613.                     AND l.course = :courseId
  1614.                     AND l.lessonModule = :lessonModuleId ";
  1615.             $query = $this->em->createQuery($sql);
  1616.             
  1617.             $query->setParameter('newOrder', $newOrder);
  1618.             $query->setParameter('courseId', $courseId);
  1619.             $query->setParameter('lessonModuleId', $lessonModuleId);
  1621.             $query->execute();
  1622.         }
  1623.     }
  1625.     public function copyLesson(
  1626.         LessonModule $newModule, 
  1627.         Lesson $lesson, 
  1628.         $isPartial = false,
  1629.         $isModulePartial = false, 
  1630.         $copyType = null
  1631.     )
  1632.     {
  1633.         $course = $newModule->getCourse();
  1634.         $courseId = $course->getId();
  1635.     
  1636.         $newLesson = clone $lesson;
  1637.         $newLesson->setLessonModule($newModule);
  1638.         $newLesson->setCourse($course);
  1640.         if($copyType == LessonEnum::COPY_PUBLISHED){
  1641.             $newLesson->setStatus(LessonEnum::PUBLISHED);
  1642.         }else if($copyType == LessonEnum::COPY_DRAFT){
  1643.             $newLesson->setStatus(LessonEnum::DRAFT);
  1644.         }
  1645.         
  1646.         if($isPartial){
  1647.             $lastOrder = $this->count([ 
  1648.                 "course" => $courseId,
  1649.                 "lessonModule" => $newModule->getId(),
  1650.                 "deleted" => LessonEnum::ITEM_NO_DELETED 
  1651.             ]);
  1652.             $newLesson->setOrder($lastOrder + 1);
  1653.         }
  1655.         $this->em->persist($newLesson);
  1656.         $this->em->flush();
  1658.         if($isPartial || $isModulePartial){
  1659.             $userLessonId = $newLesson->getUser()->getId();
  1660.             $courseTeam = $this->em->getRepository(CourseTeam::class)->findOneBy([
  1661.                 "course" => $courseId, 
  1662.                 "user" => $userLessonId,
  1663.                 "deleted" => LessonEnum::ITEM_NO_DELETED
  1664.             ]);
  1665.             
  1666.             if(!$courseTeam){
  1667.                 $newCourseTeam = new CourseTeam();
  1668.                 $newCourseTeam->setCourse($course);
  1669.                 $newCourseTeam->setUser($newLesson->getUser());
  1671.                 $this->em->persist($newCourseTeam);
  1672.                 $this->em->flush();
  1673.             }
  1674.         }
  1675.         
  1676.         $files = $this->em->getRepository(LessonXLibrary::class)->findBy([
  1677.             "lesson"=> $lesson->getId(),
  1678.             "deleted"=> LessonXLibraryEnum::ITEM_NO_DELETED
  1679.         ]);
  1680.         
  1681.         if($files){
  1682.             foreach ($files as $key => $file) {
  1683.                 $newFile = clone $file;
  1684.                 $newFile->setLesson($newLesson);
  1685.                 
  1686.                 $this->em->persist($newFile);
  1687.                 $this->em->flush();
  1688.             }
  1689.         }
  1690.         
  1691.         $this->em->getRepository(Exam::class)->copyExamByLesson($lesson, $newLesson);
  1692.         $this->em->getRepository(Exam::class)->copyQuizByLesson($lesson, $newLesson);
  1693.     }
  1695.     public function notifyStudentsLesson(Lesson $lesson, $type)
  1696.     {   
  1697.         if(!$this->configuration->checkModuleIsAbleOnPlan('notificationFunction')){
  1698.             return;
  1699.         }
  1701.         $today = date('Y-m-d');
  1702.         $dateLastNotify = $lesson->getDateLastNotify('Y-m-d');
  1704.         if($today != $dateLastNotify && $lesson->getStatus() == LessonEnum::PUBLISHED){
  1705.             $course = $lesson->getCourse();
  1706.             $lessonModule = $lesson->getLessonModule();
  1708.             if(
  1709.                 $course->getStatus() == CourseEnum::PUBLISHED && 
  1710.                 $lessonModule->getStatus() == LessonModuleEnum::PUBLISHED
  1711.             ){
  1712.                 $taskQueueService = $this->generalService->getService('TaskQueueService');
  1713.                 $enrollmentRepository = $this->em->getRepository(Enrollment::class);
  1714.                 
  1715.                 $enrollments = $enrollmentRepository->getEnrollmentsByCourse(
  1716.                     $course->getId(), 
  1717.                     EnrollmentEnum::STATUS_ACTIVE
  1718.                 );
  1720.                 foreach ($enrollments as $key => $enrollment) {
  1721.                     $taskQueueService->insert($type, $enrollment->getUser(), $lesson->getId());
  1722.                 }
  1724.                 $lesson->setDateLastNotify(date('Y-m-d H:i:s'));
  1725.                 $this->em->flush();
  1726.             }
  1727.         }
  1728.     }
  1730.     public function lessonUpdateOrder($modules)
  1731.     {
  1732.         $dqlModule = "UPDATE EADPlataforma:LessonModule AS lm SET lm.order = CASE";
  1733.         $idModules = "";
  1735.         $dqlExam = "";
  1736.         $newModuleId = "";
  1737.         $whereExam = "";
  1739.         $caseLesson1 = " l.order = CASE ";
  1740.         $caseLesson2 = " l.lessonModule = CASE ";
  1741.         $caseLesson3 = " e.lessonModule = CASE ";
  1743.         $idsLesson = "";
  1745.         foreach ($modules as $key => $value) {
  1746.             
  1747.             $orderNew = $key + 1;
  1748.             $dqlModule .= " WHEN lm.id = {$value->moduleId} THEN {$orderNew}";
  1750.             if(empty($idModules)){
  1751.                 $idModules .= "{$value->moduleId}";
  1752.             }else{
  1753.                 $idModules .= ", {$value->moduleId}";
  1754.             }
  1756.             foreach ($value->lessons as $key_lesson => $valLesson) {
  1757.                 if(!empty($valLesson->lessonId)){
  1758.                     $ordemNewLesson = $key_lesson + 1;
  1759.                 
  1760.                     $caseLesson1 .= " WHEN l.id = {$valLesson->lessonId} THEN {$ordemNewLesson}";
  1761.                     $caseLesson2 .= " WHEN l.id = {$valLesson->lessonId} THEN {$value->moduleId}";
  1762.                     $caseLesson3 .= " WHEN e.lesson = {$valLesson->lessonId} THEN {$value->moduleId}";
  1763.                 
  1764.                     if(empty($idsLesson)){
  1765.                         $idsLesson .= " {$valLesson->lessonId} ";
  1766.                     }else{
  1767.                         $idsLesson .= ", {$valLesson->lessonId} ";
  1768.                     }
  1769.                 }
  1770.             }
  1771.         }
  1772.         
  1773.         $dqlModule .= " ELSE lm.order END WHERE lm.id IN ({$idModules}) ";
  1775.         $dqlLesson = "UPDATE EADPlataforma:Lesson AS l 
  1776.                       SET {$caseLesson1} ELSE l.order END, 
  1777.                           {$caseLesson2} ELSE IDENTITY(l.lessonModule) END 
  1778.                      WHERE l.id IN ({$idsLesson}) ";
  1780.         $dqlExam = "UPDATE EADPlataforma:Exam AS e
  1781.                     SET {$caseLesson3} ELSE IDENTITY(e.lessonModule) END 
  1782.                     WHERE e.lesson IN ({$idsLesson}) ";
  1784.         $query = $this->em->createQuery($dqlModule);
  1785.         $queryLesson = $this->em->createQuery($dqlLesson);
  1786.         $queryExam = $this->em->createQuery($dqlExam);
  1788.         $query->execute();
  1789.         $queryLesson->execute();
  1790.         $queryExam->execute();
  1791.     }
  1793.     public function getLessonPublicNumber(
  1794.         Course $course, 
  1795.         ?LessonModule $lessonModule = null,
  1796.         ?bool $required = false, 
  1797.         ?bool $filterModule = false
  1798.     )
  1799.     {
  1800.         $query = $this->createQueryBuilder('l');
  1801.         $query->select('COUNT(l.id) AS total');
  1802.         $query->innerJoin(
  1803.             'EADPlataforma:LessonModule', 
  1804.             'lm', 
  1805.             'WITH', 
  1806.             'lm.id = l.lessonModule AND lm.deleted = :deleted'
  1807.         );
  1809.         $query->innerJoin(
  1810.             'EADPlataforma:Course', 
  1811.             'c', 
  1812.             'WITH', 
  1813.             'c.id = l.course AND c.deleted = :deleted'
  1814.         );
  1816.         if($lessonModule){
  1817.             $query->andWhere('lm.order <= :lessonModuleOrder');
  1818.             $query->setParameter('lessonModuleOrder', $lessonModule->getOrder());
  1820.             if($filterModule){
  1821.                 $query->andWhere('lm.id = :lessonModule');
  1822.                 $query->setParameter('lessonModule', $lessonModule->getId());
  1823.             }
  1824.         }
  1826.         if($required){
  1827.             $query->andWhere('l.controlRequirement = :required');
  1828.             $query->setParameter('required', LessonEnum::YES);
  1829.         }
  1831.         $query->andWhere('l.deleted = :deleted');
  1832.         $query->andWhere('l.course = :courseId');
  1833.         $query->andWhere('l.status = :lessonStatus');
  1834.         $query->andWhere('lm.status = :lessonModuleStatus');
  1835.         
  1836.         $query->setParameter('courseId', $course->getId());
  1837.         $query->setParameter('deleted', LessonEnum::ITEM_NO_DELETED);
  1838.         $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  1839.         $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  1840.         $query->setMaxResults(1);
  1842.         $result = (object)$query->getQuery()->getOneOrNullResult();
  1843.         return $result->total;
  1844.     }
  1846.     public function countCourseLessons(
  1847.         Course $course,
  1848.         int $userId,
  1849.         ?LessonModule $lessonModule = null, 
  1850.         $isHistory = false
  1851.     )
  1852.     {
  1853.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  1855.         $permission = $userPermissionUtil->getPermission("course", "see");
  1856.         $user = $userPermissionUtil->getUser();
  1857.         $isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
  1858.             $course, 
  1859.             $user
  1860.         );
  1862.         $sqlDateConclusion = "
  1863.             SELECT
  1864.                 (
  1865.                     CASE 
  1866.                         WHEN ll.complete = :yes THEN ll.date_conclusion 
  1867.                         ELSE CURDATE() 
  1868.                     END
  1869.                 ) AS date_conclusion
  1870.             FROM lesson_log AS ll
  1871.             WHERE ll.lesson_id = l.id
  1872.             AND ll.course_id = l.course_id
  1873.             AND ll.user_id = :userId
  1874.             ORDER BY ll.id DESC
  1875.             LIMIT 1
  1876.         ";
  1878.         $sqlDateRegisterEnrollement = "
  1879.             SELECT
  1880.                 e.date_register
  1881.             FROM enrollment AS e
  1882.             WHERE e.deleted = :deletedEnrollment
  1883.             AND e.course_id = l.course_id
  1884.             AND e.user_id = :userId
  1885.             ORDER BY e.id DESC
  1886.             LIMIT 1
  1887.         ";
  1889.         $sql = "
  1890.             SELECT
  1891.                 COUNT(l.id) AS total
  1892.             FROM lesson AS l
  1893.             INNER JOIN course AS c ON (c.id = l.course_id AND c.deleted = :deletedCourse)
  1894.             INNER JOIN lesson_module AS lm ON (
  1895.                 lm.id = l.lesson_module_id AND lm.deleted = :deletedModule
  1896.             )
  1897.             LEFT JOIN library AS lb ON (lb.id = l.library_id AND lb.deleted = :deletedLibrary)
  1898.             WHERE l.deleted = :deleted
  1899.             AND l.course_id = :courseId
  1900.             /* AND  CASO FOSSE CONSIDERADA DATA DE LIBERAÇÃO DA AULA PARA ENCERRAR O ACESSO
  1901.             (
  1902.                 (
  1903.                     l.control_close_period = 0 OR 
  1904.                     l.control_close_period IS NULL
  1905.                 )
  1906.                 OR
  1907.                 (
  1908.                     l.control_close_period > 0
  1909.                     AND l.control_release_type = 0
  1910.                     AND DATEDIFF(CURDATE(), (DATE(
  1911.                         (
  1912.                             CASE 
  1913.                                 WHEN ({$sqlDateConclusion}) IS NOT NULL THEN ({$sqlDateConclusion})
  1914.                                 ELSE CURDATE()
  1915.                             END
  1916.                         )
  1917.                     ) + INTERVAL l.control_close_period DAY)) < 0
  1918.                 )
  1919.                 OR
  1920.                 (
  1921.                     l.control_close_period > 0
  1922.                     AND l.control_release_type = 1
  1923.                     AND DATEDIFF(CURDATE(), (DATE(
  1924.                         (l.control_date_release)
  1925.                     ) + INTERVAL l.control_close_period DAY)) < 0
  1926.                 )
  1927.                 OR
  1928.                 (
  1929.                     l.control_close_period > 0
  1930.                     AND l.control_release_type = 2
  1931.                     AND l.control_release_after_type = 1
  1932.                     AND DATEDIFF(CURDATE(), (DATE(
  1933.                         ({$sqlDateRegisterEnrollement})
  1934.                     ) + INTERVAL l.control_close_period DAY)) < 0
  1935.                 )
  1936.                 OR
  1937.                 (
  1938.                     l.control_close_period > 0
  1939.                     AND l.control_release_type = 2
  1940.                     AND l.control_release_after_type = 2
  1941.                 )
  1942.             )*/
  1943.         ";
  1946.         if($lessonModule){
  1947.             $sql .= " AND l.lesson_module_id = :lessonModuleId ";
  1948.         }
  1950.         if(
  1951.             $isHistory ||
  1952.             $userPermissionUtil->isLow($permission) || 
  1953.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  1954.         ){
  1955.             $sql .= " AND l.status = :lessonStatus ";
  1956.             $sql .= " AND lm.status = :lessonModuleStatus ";
  1957.         }
  1959.         $stmt = $this->em->getConnection()->prepare($sql);
  1961.         //$stmt->bindValue(':deletedEnrollment', EnrollmentEnum::ITEM_NO_DELETED, PDO::PARAM_INT);
  1962.         $stmt->bindValue(':deletedCourse', CourseEnum::ITEM_NO_DELETED, PDO::PARAM_INT);
  1963.         $stmt->bindValue(':deletedModule', LessonModuleEnum::ITEM_NO_DELETED, PDO::PARAM_INT);
  1964.         $stmt->bindValue(':deletedLibrary', LibraryEnum::ITEM_NO_DELETED, PDO::PARAM_INT);
  1965.         $stmt->bindValue(':deleted', LessonEnum::ITEM_NO_DELETED, PDO::PARAM_INT);
  1966.         $stmt->bindValue(':courseId', $course->getId(), PDO::PARAM_INT);
  1967.         //$stmt->bindValue(':yes', LessonEnum::YES, PDO::PARAM_INT);
  1968.         //$stmt->bindValue(':userId', $userId, PDO::PARAM_INT);
  1970.         if($lessonModule){
  1971.             $stmt->bindValue(':lessonModuleId', $lessonModule->getId(), PDO::PARAM_INT);
  1972.         }
  1974.         if(
  1975.             $isHistory ||
  1976.             $userPermissionUtil->isLow($permission) ||
  1977.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  1978.         ){
  1979.             $stmt->bindValue(':lessonStatus', LessonEnum::PUBLISHED, PDO::PARAM_INT);
  1980.             $stmt->bindValue(':lessonModuleStatus', LessonModuleEnum::PUBLISHED, PDO::PARAM_INT);
  1981.         }
  1982.         
  1983.         $stmt->execute();
  1985.         $result = $stmt->fetchAll(PDO::FETCH_CLASS);
  1987.         return $result[0]->total;
  1988.     }
  1990.     public function getCourseLessons(
  1991.         Course $course, 
  1992.         ?LessonModule $lessonModule = null, 
  1993.         ?array $lessonIds = null, 
  1994.         ?string $searchText = null
  1995.     )
  1996.     {
  1997.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  1999.         $permission = $userPermissionUtil->getPermission("course", "see");
  2000.         $user = $userPermissionUtil->getUser();
  2001.         $isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
  2002.             $course, 
  2003.             $user
  2004.         );
  2005.         
  2006.         $query = $this->createQueryBuilder('l');
  2007.         $query->innerJoin(
  2008.             'EADPlataforma:LessonModule', 
  2009.             'lm', 
  2010.             'WITH', 
  2011.             'lm.id = l.lessonModule AND lm.deleted = 0'
  2012.         );
  2014.         $query->innerJoin(
  2015.             'EADPlataforma:Course', 
  2016.             'c', 
  2017.             'WITH', 
  2018.             'c.id = l.course AND c.deleted = 0'
  2019.         );
  2021.         $query->leftJoin(
  2022.             'EADPlataforma:Library', 
  2023.             'lb', 
  2024.             'WITH', 
  2025.             'lb.id = l.library AND lb.deleted = 0'
  2026.         );
  2028.         $query->andWhere('l.deleted = 0');
  2029.         $query->andWhere('l.course = :courseId');
  2030.         $query->setParameter('courseId', $course->getId());
  2032.         if(!empty($searchText)){
  2033.             $query->andWhere('(l.title LIKE :searchText OR lm.title LIKE :searchText)');
  2034.             $query->setParameter('searchText', "%{$searchText}%");
  2035.         }
  2037.         if($lessonModule){
  2038.             $query->andWhere('l.lessonModule = :lessonModuleId');
  2039.             $query->setParameter('lessonModuleId', $lessonModule->getId());
  2040.         }
  2042.         if(is_array($lessonIds) && !empty($lessonIds)){
  2043.             $query->andWhere($query->expr()->in('l.id', $lessonIds));
  2044.         }
  2046.         if(
  2047.             $userPermissionUtil->isLow($permission) || 
  2048.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  2049.         ){
  2050.             $query->andWhere('l.status = :lessonStatus');
  2051.             $query->andWhere('lm.status = :lessonModuleStatus');
  2052.             $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  2053.             $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  2054.         }
  2056.         $query->addOrderBy('l.order', 'ASC');
  2057.         $query->addOrderBy('l.lessonModule', 'ASC');
  2059.         $data = $query->getQuery()->execute();
  2061.         return $data;
  2062.     }
  2064.     public function getFirstLesson(Course $course, ?LessonModule $lessonModule = null)
  2065.     {
  2066.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2068.         $permission = $userPermissionUtil->getPermission("course", "see");
  2069.         $user = $userPermissionUtil->getUser();
  2071.         $courseTeamRepository = $this->em->getRepository(CourseTeam::class);
  2072.         $isInTeam = $courseTeamRepository->userExistInCourseTeam($course, $user);
  2073.         
  2074.         $query = $this->createQueryBuilder('l');
  2075.         $query->innerJoin(
  2076.             'EADPlataforma:LessonModule', 
  2077.             'lm', 
  2078.             'WITH', 
  2079.             'lm.id = l.lessonModule AND lm.deleted = 0'
  2080.         );
  2082.         $query->innerJoin(
  2083.             'EADPlataforma:Course', 
  2084.             'c', 
  2085.             'WITH', 
  2086.             'c.id = l.course AND c.deleted = 0'
  2087.         );
  2089.         $query->andWhere('l.deleted = 0');
  2090.         $query->andWhere('l.course = :courseId');
  2091.         $query->setParameter('courseId', $course->getId());
  2093.         if($lessonModule){
  2094.             $query->andWhere('l.lessonModule = :lessonModuleId');
  2095.             $query->setParameter('lessonModuleId', $lessonModule->getId());
  2096.         }
  2098.         if(
  2099.             $userPermissionUtil->isLow($permission) || 
  2100.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  2101.         ){
  2102.             $query->andWhere('l.status = :lessonStatus');
  2103.             $query->andWhere('lm.status = :lessonModuleStatus');
  2104.             $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  2105.             $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  2106.         }
  2108.         $query->addOrderBy('lm.order', 'ASC');
  2109.         $query->addOrderBy('l.order', 'ASC');
  2111.         $query->setMaxResults(1);
  2113.         return $query->getQuery()->getOneOrNullResult();
  2114.     }
  2116.     public function getLastLesson(Course $course, ?LessonModule $lessonModule = null)
  2117.     {
  2118.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2120.         $permission = $userPermissionUtil->getPermission("course", "see");
  2121.         $user = $userPermissionUtil->getUser();
  2122.         $isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
  2123.             $course, 
  2124.             $user
  2125.         );
  2126.         
  2127.         $query = $this->createQueryBuilder('l');
  2128.         $query->innerJoin(
  2129.             'EADPlataforma:LessonModule', 
  2130.             'lm', 
  2131.             'WITH', 
  2132.             'lm.id = l.lessonModule AND lm.deleted = 0'
  2133.         );
  2135.         $query->innerJoin(
  2136.             'EADPlataforma:Course', 
  2137.             'c', 
  2138.             'WITH', 
  2139.             'c.id = l.course AND c.deleted = 0'
  2140.         );
  2142.         $query->andWhere('l.deleted = 0');
  2143.         $query->andWhere('l.course = :courseId');
  2144.         $query->setParameter('courseId', $course->getId());
  2146.         if($lessonModule){
  2147.             $query->andWhere('l.lessonModule = :lessonModuleId');
  2148.             $query->setParameter('lessonModuleId', $lessonModule->getId());
  2149.         }
  2151.         if(
  2152.             $userPermissionUtil->isLow($permission) || 
  2153.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  2154.         ){
  2155.             $query->andWhere('l.status = :lessonStatus');
  2156.             $query->andWhere('lm.status = :lessonModuleStatus');
  2157.             $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  2158.             $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  2159.         }
  2161.         $query->addOrderBy('lm.order', 'DESC');
  2162.         $query->addOrderBy('l.order', 'DESC');
  2164.         $query->setMaxResults(1);
  2166.         return $query->getQuery()->getOneOrNullResult();
  2167.     }
  2169.     public function getLessonByLessonModule(LessonModule $lessonModule)
  2170.     {   
  2172.         $query = $this->createQueryBuilder('l');
  2173.         $query->leftJoin(
  2174.             'EADPlataforma:Library', 
  2175.             'li', 
  2176.             'WITH', 
  2177.             'li.id = l.library AND li.deleted = 0'
  2178.         );
  2180.         $query->andWhere('l.deleted = 0');
  2181.         $query->andWhere('l.status = :status');
  2182.         $query->andWhere('l.course = :courseId');
  2183.         $query->andWhere('l.lessonModule = :lessonModule');
  2184.         $query->setParameter('courseId', $lessonModule->getCourse()->getId());
  2185.         $query->setParameter('lessonModule', $lessonModule->getId());
  2186.         $query->setParameter('status', LessonEnum::PUBLISHED);
  2188.         $query->addOrderBy('l.order', 'ASC');
  2190.         return $query->getQuery()->execute();
  2191.     }
  2193.     public function getNextLessonByLessonModule(
  2194.         int $order, 
  2195.         LessonModule $lessonModule, 
  2196.         int $limit = 3
  2197.     )
  2198.     {   
  2200.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2201.         $permission = $userPermissionUtil->getPermission("course", "see");
  2203.         $course = $lessonModule->getCourse();
  2204.         $user = $userPermissionUtil->getUser();
  2207.         $isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
  2208.             $course, 
  2209.             $user
  2210.         );
  2212.         $query = $this->createQueryBuilder('l');
  2214.         $query->select('
  2215.             l.id,
  2216.             l.order,
  2217.             l.title,
  2218.             l.status,
  2219.             l.controlRequirement,
  2220.             l.controlReleaseType,
  2221.             l.controlReleaseAfterType,
  2222.             l.controlDateRelease,
  2223.             l.controlReleasePeriod,
  2224.             l.controlClosePeriod,
  2225.             lm.id AS lessonModule,
  2226.             li.type AS libraryType,
  2227.             li.pagesNumber,
  2228.             li.duration
  2229.         ');
  2231.         $query->innerJoin(
  2232.             'EADPlataforma:LessonModule', 
  2233.             'lm', 
  2234.             'WITH', 
  2235.             'lm.id = l.lessonModule AND lm.deleted = 0'
  2236.         );
  2238.         $query->innerJoin(
  2239.             'EADPlataforma:Course', 
  2240.             'c', 
  2241.             'WITH', 
  2242.             'c.id = l.course AND c.deleted = 0'
  2243.         );
  2245.         $query->leftJoin(
  2246.             'EADPlataforma:Library', 
  2247.             'li', 
  2248.             'WITH', 
  2249.             'li.id = l.library AND li.deleted = 0'
  2250.         );
  2252.         if(
  2253.             $userPermissionUtil->isLow($permission) || 
  2254.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  2255.         ){
  2256.             $query->andWhere('l.status = :lessonStatus');
  2257.             $query->andWhere('lm.status = :lessonModuleStatus');
  2258.             $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  2259.             $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  2260.         }
  2262.         $query->andWhere('l.deleted = 0');
  2263.         $query->andWhere('l.course = :courseId');
  2264.         $query->andWhere('l.lessonModule = :lessonModule');
  2265.         $query->andWhere('l.order > :order');
  2267.         $query->setParameter('courseId', $course->getId());
  2268.         $query->setParameter('lessonModule', $lessonModule->getId());
  2269.         $query->setParameter('order', $order);
  2271.         $query->addOrderBy('l.order', 'ASC');
  2273.         $query->setMaxResults($limit);
  2275.         return $query->getQuery()->execute();
  2276.     }
  2278.     public function getLessonNotView($userId, $courseId, $lessonId = null)
  2279.     {
  2280.         $and = '';
  2282.         if(!empty($lessonId))
  2283.         {
  2284.             $and .= " AND l.id = :lessonId";
  2285.         }
  2287.         if(empty($courseId) || empty($userId))
  2288.         {
  2289.             return [];
  2290.         }
  2292.         $dql = "SELECT
  2293.                     l.id,
  2294.                     l.title,
  2295.                     lm.title AS titleModule,
  2296.                     '0' AS totalView,
  2297.                     '' AS lastAccess,
  2298.                     '--' AS timeWatch,
  2299.                     '0' AS completed,
  2300.                     '---' AS dateConclusion
  2301.                 FROM EADPlataforma:Lesson AS l
  2302.                 INNER JOIN EADPlataforma:LessonModule AS lm WITH (lm.id = l.lessonModule AND lm.deleted = 0)
  2303.                 WHERE l.deleted = 0
  2304.                 AND l.course = :courseId
  2305.                 {$and}
  2306.                 AND l.id NOT IN (
  2307.                     SELECT
  2308.                         IDENTITY (ll.lesson)
  2309.                     FROM EADPlataforma:LessonLogOrigin AS ll
  2310.                     WHERE ll.user != 1
  2311.                     AND ll.user = :userId
  2312.                     AND ll.course = :courseId
  2313.                 )
  2314.                 ORDER BY l.order ASC";
  2315.                 
  2316.         $query = $this->em->createQuery($dql);
  2317.         $query->setParameter('userId', $userId);
  2318.         $query->setParameter('courseId', $courseId);
  2319.       
  2320.         if(!empty($lessonId))
  2321.         {
  2322.             $query->setParameter('lessonId', $lessonId);
  2323.         }
  2325.         $data = $query->execute();
  2326.         
  2327.         $result = [];
  2328.         foreach ($data as $key => $value) {
  2329.             $result[] = [
  2330.                 $value["id"],
  2331.                 $value["title"],
  2332.                 $value["titleModule"],
  2333.                 $value["totalView"],
  2334.                 $value["lastAccess"],
  2335.                 $value["timeWatch"],
  2336.                 $value["completed"],
  2337.                 $value["dateConclusion"]
  2338.             ];
  2339.         }
  2341.         return $result;
  2342.     }
  2344.     public function isFirstCourseLesson(?Lesson $lesson)
  2345.     {
  2346.         if(!$lesson){
  2347.             return false;
  2348.         }
  2350.         $firstLesson = $this->getFirstLesson($lesson->getCourse());
  2351.         if($firstLesson){
  2352.             return $firstLesson->getId() == $lesson->getId();
  2353.         }
  2354.         return true;
  2355.     }
  2357.     public function isFirstModuleLesson(?Lesson $lesson)
  2358.     {
  2359.         if(!$lesson){
  2360.             return false;
  2361.         }
  2363.         $firstLesson = $this->getFirstLesson($lesson->getCourse(), $lesson->getLessonModule());
  2364.         if($firstLesson){
  2365.             return $firstLesson->getId() == $lesson->getId();
  2366.         }
  2367.         return true;
  2368.     }
  2370.     public function isLastCourseLesson(?Lesson $lesson)
  2371.     {
  2372.         if(!$lesson){
  2373.             return false;
  2374.         }
  2376.         $firstLesson = $this->getLastLesson($lesson->getCourse());
  2377.         if($firstLesson){
  2378.             return $firstLesson->getId() == $lesson->getId();
  2379.         }
  2380.         return true;
  2381.     }
  2383.     public function isLastModuleLesson(?Lesson $lesson)
  2384.     {
  2385.         if(!$lesson){
  2386.             return false;
  2387.         }
  2389.         $firstLesson = $this->getLastLesson(
  2390.             $lesson->getCourse(), 
  2391.             $lesson->getLessonModule()
  2392.         );
  2394.         if($firstLesson){
  2395.             return $firstLesson->getId() == $lesson->getId();
  2396.         }
  2397.         return true;
  2398.     }
  2400.     public function isLessonVisibleToStudent(
  2401.         Lesson $lesson, 
  2402.         ?bool $ignoreControlFunction = false
  2403.     ): bool
  2404.     {
  2405.         $info = $this->checkLessonVisibleToStudent($lesson, $ignoreControlFunction);
  2407.         return $info->visible;
  2408.     }
  2410.     public function checkLessonVisibleToStudent(
  2411.         Lesson $lesson, 
  2412.         ?bool $ignoreControlFunction = false
  2413.     ): object
  2414.     {
  2415.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2416.         $user = $userPermissionUtil->getUser();
  2418.         $info = (object)[
  2419.             "visible" => true,
  2420.             "message" => "",
  2421.         ];
  2423.         if(!$user){
  2425.             $info->visible = false;
  2427.             return $info;
  2428.         }
  2430.         $course = $lesson->getCourse();
  2431.         $lessonModule = $lesson->getLessonModule();
  2433.         if($lesson->isDeleted() || $lessonModule->isDeleted() || $course->isDeleted()){
  2434.             $info->visible = false;
  2436.             return $info;
  2437.         }
  2439.         $permission = $userPermissionUtil->getPermission("course", "see");
  2440.         
  2441.         $isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
  2442.             $course,
  2443.             $user
  2444.         );
  2446.         $enrollmentRepository = $this->em->getRepository(Enrollment::class);
  2447.         $isEnroll = $enrollmentRepository->isValidEnrollmentByUser(
  2448.             $user->getId(), 
  2449.             $course->getId()
  2450.         );
  2452.         $hasLessonControl = $this->configuration->checkModuleIsAbleOnPlan(
  2453.             'lessonControlFunction'
  2454.         );
  2456.         if(
  2457.             $userPermissionUtil->isLow($permission) || 
  2458.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  2459.         ){
  2460.             
  2461.             if($lesson->getStatus() == LessonEnum::DRAFT){
  2462.                 $info->visible = false;
  2464.                 return $info;
  2465.             }
  2467.             if($lessonModule->getStatus() == LessonModuleEnum::DRAFT){
  2468.                 $info->visible = false;
  2470.                 return $info;
  2471.             }
  2473.             if($course->getStatus() == CourseEnum::DRAFT){
  2474.                 $info->visible = false;
  2476.                 return $info;
  2477.             }
  2479.             if(!$isEnroll){
  2480.                 $info->visible = false;
  2482.                 return $info;
  2483.             }
  2484.             
  2485.             if(!$ignoreControlFunction){
  2486.                 if($lesson->getControlReleaseType() == LessonEnum::FIXED_DATE){
  2487.                     $todaySeconds = strtotime(date('Y-m-d H:i:s'));
  2488.                     if($hasLessonControl){
  2489.                         $controlClosePeriod = $lesson->getControlClosePeriod();
  2490.                         if(!empty($controlClosePeriod)){
  2491.                             $timeLog = strtotime(
  2492.                                 "{$lesson->getControlDateRelease()} + {$controlClosePeriod} day"
  2493.                             );
  2495.                             if($todaySeconds > $timeLog){
  2496.                                 $info->visible = false;
  2498.                                 return $info;
  2499.                             }
  2500.                         }
  2501.                     }
  2502.                 }else{
  2503.                     $lessonLogRepository = $this->emEadmin->getRepository(LessonLog::class);
  2504.                     $logId = "{$course->getId()}#{$user->getId()}#{$lesson->getId()}";
  2505.                     $lessonLog = $lessonLogRepository->find($logId);
  2507.                     //check lesson to user is closed
  2508.                     if($lessonLog){
  2509.                         $todaySeconds = strtotime(date('Y-m-d H:i:s'));
  2510.                         if($hasLessonControl){
  2511.                             $controlClosePeriod = $lesson->getControlClosePeriod();
  2512.                             if(
  2513.                                 !empty($controlClosePeriod) && 
  2514.                                 $lessonLog->getComplete() == LessonEnum::YES
  2515.                             ){
  2516.                                 $timeLog = strtotime(
  2517.                                     "{$lessonLog->getDateConclusion()} + {$controlClosePeriod} day"
  2518.                                 );
  2520.                                 if($todaySeconds > $timeLog){
  2521.                                     $info->visible = false;
  2523.                                     return $info;
  2524.                                 }
  2525.                             }
  2526.                         }
  2527.                     }
  2528.                 } 
  2529.             }
  2530.         }else if(!$isEnroll){
  2531.             $enrollmentService = $this->generalService->getService('EnrollmentService');
  2532.             $enrollmentService->enrollUser($user, $course);
  2533.         }
  2535.         return $info;
  2536.     }
  2538.     public function getLessonNumberByProduct(Product $product)
  2539.     {
  2540.         $query = $this->createQueryBuilder('l');
  2541.         $query->select("COUNT(l.id) AS total");
  2542.         $query->innerJoin('EADPlataforma:Course', 'c', 'WITH', 'l.course = c.id');
  2543.         $query->innerJoin('EADPlataforma:Product', 'p', 'WITH', 'l.course MEMBER OF p.course');
  2544.         $query->innerJoin('EADPlataforma:LessonModule', 'lm', 'WITH', 'l.lessonModule = lm.id');
  2546.         $query->andWhere('l.deleted = :deletedLesson');
  2547.         $query->andWhere('c.deleted = :deletedCourse');
  2548.         $query->andWhere('lm.deleted = :deletedLessonModule');
  2550.         $query->andWhere('l.status = :statusLesson');
  2551.         $query->andWhere('c.status = :statusCourse');
  2552.         $query->andWhere('lm.status = :statusLessonModule');
  2554.         $query->andWhere('p.id = :productId');
  2556.         $query->setParameter('deletedLesson', LessonEnum::ITEM_NO_DELETED);
  2557.         $query->setParameter('deletedCourse', CourseEnum::ITEM_NO_DELETED);
  2558.         $query->setParameter('deletedLessonModule', LessonModuleEnum::ITEM_NO_DELETED);
  2560.         $query->setParameter('statusLesson', LessonEnum::PUBLISHED);
  2561.         $query->setParameter('statusCourse', CourseEnum::PUBLISHED);
  2562.         $query->setParameter('statusLessonModule', LessonModuleEnum::PUBLISHED);
  2564.         $query->setParameter('productId', $product->getId());
  2566.         $result = (object)$query->getQuery()->getOneOrNullResult();
  2567.         return $result->total;
  2568.     }
  2570.     public function getLessonForExportPresence(Course $course, $lessonModuleId = null){
  2571.         $query = $this->createQueryBuilder('l');
  2573.         $query->select('
  2574.             l.id,
  2575.             lm.id AS lessonModuleId,
  2576.             l.order,
  2577.             lm.title,
  2578.             l.title AS lessonTitle
  2579.         ');
  2581.         $query->innerJoin(
  2582.             'EADPlataforma:LessonModule', 
  2583.             'lm', 
  2584.             'WITH', 
  2585.             'lm.id = l.lessonModule AND lm.deleted = 0'
  2586.         );
  2588.         if($lessonModuleId){
  2589.             $query->andWhere('lm.id = :lessonModuleId');
  2590.             $query->setParameter('lessonModuleId', $lessonModuleId);
  2591.         }
  2592.         
  2593.         $query->andWhere('l.status = :lessonStatus');
  2594.         $query->andWhere('lm.status = :lessonModuleStatus');
  2595.         $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  2596.         $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  2597.         
  2598.         $query->andWhere('l.deleted = 0');
  2599.         $query->andWhere('l.course = :courseId');
  2601.         $query->setParameter('courseId', $course->getId());
  2603.         $query->addOrderBy('lm.order', 'ASC');
  2604.         $query->addOrderBy('lm.id', 'ASC');
  2605.         $query->addOrderBy('l.order', 'ASC');
  2606.         $query->addOrderBy('l.id', 'ASC');
  2608.         return $query->getQuery()->execute();
  2609.     }
  2611.     public function restore(Lesson $lesson, $typeItem, $key)
  2612.     {
  2613.         $lessonId = $lesson->getId();
  2614.         $dateNow = date('Y-m-d H:i:s');
  2616.         $lastOrder = $this->count(
  2617.             [ 
  2618.                 "deleted" => LessonEnum::ITEM_NO_DELETED, 
  2619.                 "lessonModule" => $lesson->getLessonModule()->getId() 
  2620.             ]
  2621.         ) + ($key + 1);
  2623.         $lesson->setOrder($lastOrder);
  2625.         $courseRepository =  $this->em->getRepository(Course::class);
  2627.         $lesson->setUserDelete($this->getUser());
  2628.         $lesson->setDateDelete($dateNow);
  2629.         $lesson->restore();
  2630.         $deleted = LessonEnum::ITEM_NO_DELETED;
  2631.         $typeDelete = LessonEnum::CASCADE;
  2633.         $this->em->getRepository(Exam::class)->restoreByLesson(
  2634.             $lessonId, 
  2635.             $deleted, 
  2636.             $typeDelete, 
  2637.             $this->getUser(), 
  2638.             $dateNow
  2639.         );
  2641.         $this->em->getRepository(ExamUser::class)->restoreByLesson(
  2642.             $lessonId, 
  2643.             $deleted, 
  2644.             $typeDelete, 
  2645.             $this->getUser(), 
  2646.             $dateNow
  2647.         );
  2649.         $this->em->getRepository(LessonSupport::class)->restoreByLesson(
  2650.             $lessonId, 
  2651.             $deleted, 
  2652.             $typeDelete, 
  2653.             $this->getUser(), 
  2654.             $dateNow
  2655.         );
  2657.         $this->em->getRepository(LessonXLibrary::class)->restoreByLesson(
  2658.             $lessonId, 
  2659.             $deleted, 
  2660.             $typeDelete, 
  2661.             $this->getUser(), 
  2662.             $dateNow
  2663.         );
  2664.         $this->em->getRepository(Trash::class)->deleteTrash($lessonId, $typeItem);
  2665.     }
  2667.     public function delete(Lesson $lesson, $typeItem, $permission, $isTrash)
  2668.     {
  2669.         $lessonId = $lesson->getId();
  2670.         $dateNow = date('Y-m-d H:i:s');
  2671.         $typeDelete = LessonEnum::CASCADE;
  2673.         $notificationService = $this->generalService->getService('NotificationService');
  2674.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2676.         $lessonXLibrarys = $this->em->getRepository(LessonXLibrary::class)->findBy([
  2677.             "lesson" => $lesson->getId(),
  2678.         ]);
  2680.         $libraryRepository = $this->em->getRepository(Library::class);
  2681.         $libraryModule = $this->configuration->checkModuleIsAbleOnPlan('libraryModule');
  2683.         if($isTrash == LessonEnum::YES){
  2684.             $permission = $userPermissionUtil->getPermission("trash", "delete");
  2685.         }
  2687.         $isLessonTeacher = $this->isLessonTeacher($lesson, $this->getUser());
  2688.         if($isLessonTeacher || $userPermissionUtil->isHigh($permission)){
  2689.             $lesson->setUserDelete($this->getUser());
  2690.             $lesson->setDateDelete($dateNow);
  2691.             $lesson->individual();
  2692.             
  2693.             if($lesson->isOnTrash() || $lesson->isDeleted()){
  2694.                 
  2695.                 $lesson->delete();
  2696.                 $deleted = LessonEnum::ITEM_DELETED;
  2697.                 $this->em->getRepository(Trash::class)->deleteTrash($lessonId, $typeItem);
  2699.                 $this->em->flush();
  2701.                 foreach ($lessonXLibrarys as $key => $lessonXLibrary) {
  2702.                     $library = $lessonXLibrary->getLibrary();
  2703.                     if(!$libraryModule && $library){
  2704.                         $library->cascade();
  2705.                         $libraryRepository->deleteContent($library);
  2706.                     }
  2707.                     $lessonXLibrary->delete();
  2708.                 }
  2710.                 $library = $lesson->getLibrary();
  2712.                 if(!$libraryModule && $library){
  2713.                     $library->cascade();
  2714.                     $libraryRepository->deleteContent($library);
  2715.                 }
  2716.             }
  2718.             if(!$lesson->isOnTrash() && !$lesson->isDeleted()){
  2719.                 $order = $lesson->getOrder();
  2720.                 $this->refreshOrder(
  2721.                     $lesson->getCourse()->getId(), 
  2722.                     $lesson->getLessonModule()->getId(),
  2723.                     $order,
  2724.                     null,
  2725.                     true
  2726.                 );
  2728.                 $notificationService->delete(
  2729.                     NotificationEnum::ORIGIN_LESSON_SUPPORT_LIKE, 
  2730.                     $lessonId
  2731.                 );
  2733.                 $notificationService->delete(
  2734.                     NotificationEnum::ORIGIN_LESSON_SUPPORT_ANSWER_LIKE, 
  2735.                     $lessonId
  2736.                 );
  2737.                 $notificationService->delete(
  2738.                     NotificationEnum::ORIGIN_LESSON_SUPPORT_NEW, 
  2739.                     $lessonId
  2740.                 );
  2741.                 $notificationService->delete(
  2742.                     NotificationEnum::ORIGIN_LESSON_SUPPORT_ANSWER_NEW, 
  2743.                     $lessonId
  2744.                 );
  2745.                 $notificationService->delete(
  2746.                     NotificationEnum::ORIGIN_LESSON_NEW, 
  2747.                     $lessonId
  2748.                 );
  2749.                 $notificationService->delete(
  2750.                     NotificationEnum::ORIGIN_LESSON_CHANGE, 
  2751.                     $lessonId
  2752.                 );
  2754.                 $lesson->trash();
  2755.                 $deleted = LessonEnum::ITEM_ON_TRASH;
  2756.                 $this->em->getRepository(Trash::class)->insertTrash(
  2757.                     $lesson, 
  2758.                     $typeItem, 
  2759.                     "Aula: {$lesson->getTitle()} | Prof. {$lesson->getUser()->getName()}"
  2760.                 );
  2761.             }
  2762.         }
  2763.         
  2764.         $this->em->getRepository(Exam::class)->deleteByLesson(
  2765.             $lessonId, 
  2766.             $deleted, 
  2767.             $typeDelete, 
  2768.             $this->getUser(), 
  2769.             $dateNow
  2770.         );
  2772.         $this->em->getRepository(ExamUser::class)->deleteByLesson(
  2773.             $lessonId, 
  2774.             $deleted, 
  2775.             $typeDelete, 
  2776.             $this->getUser(), 
  2777.             $dateNow
  2778.         );
  2780.         $this->em->getRepository(LessonSupport::class)->deleteByLesson(
  2781.             $lessonId, 
  2782.             $deleted, 
  2783.             $typeDelete, 
  2784.             $this->getUser(), 
  2785.             $dateNow
  2786.         );
  2788.         $this->em->getRepository(LessonXLibrary::class)->deleteByLesson(
  2789.             $lessonId, 
  2790.             $deleted, 
  2791.             $typeDelete, 
  2792.             $this->getUser(), 
  2793.             $dateNow
  2794.         );
  2795.     }
  2797.     public function restoreByCourse($courseId, $deleted, $typeDelete){
  2799.         $typeItem = TrashEnum::LESSON;
  2801.         $lessons = $this->em->getRepository(Lesson::class)->findBy([
  2802.             "course" => $courseId,
  2803.             "deleted" => (1 - $deleted),
  2804.             "typeDelete" => $typeDelete
  2805.         ]);
  2807.         foreach ($lessons as $key => $lesson) {
  2808.             $this->restore($lesson, $typeItem, $key);
  2809.         }
  2810.     }
  2812.     public function deleteByCourse($courseId, $deleted){
  2814.         $typeItem = TrashEnum::LESSON;
  2815.         $isTrash = LessonEnum::NO;
  2817.         if($deleted == LessonEnum::ITEM_ON_TRASH){
  2818.             $isTrash = LessonEnum::YES;
  2819.         }
  2821.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2822.         $permission = $userPermissionUtil->getPermission(
  2823.             "course", 
  2824.             "lesson", 
  2825.             "delete"
  2826.         );
  2828.         $lessons = $this->em->getRepository(Lesson::class)->findBy([
  2829.             "course" => $courseId,
  2830.             "deleted" => ($deleted - 1)
  2831.         ]);
  2833.         foreach ($lessons as $key => $lesson) {
  2834.             $this->delete($lesson, $typeItem, $permission, $isTrash);
  2835.             $lesson->cascade();
  2836.         }
  2837.     }
  2839.     public function restoreByLessonModule($lessonModuleId, $deleted, $typeDelete){
  2841.         $typeItem = TrashEnum::LESSON;
  2843.         $lessons = $this->em->getRepository(Lesson::class)->findBy([
  2844.             "lessonModule" => $lessonModuleId,
  2845.             "deleted" => (1 - $deleted),
  2846.             "typeDelete" => $typeDelete
  2847.         ]);
  2849.         foreach ($lessons as $key => $lesson) {
  2850.             $this->restore($lesson, $typeItem, $key);
  2851.         }
  2852.     }
  2854.     public function deleteByLessonModule($lessonModuleId, $deleted){
  2856.         $typeItem = TrashEnum::LESSON;
  2857.         $isTrash = LessonEnum::NO;
  2859.         if($deleted == LessonEnum::ITEM_ON_TRASH){
  2860.             $isTrash = LessonEnum::YES;
  2861.         }
  2863.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2864.         $permission = $userPermissionUtil->getPermission(
  2865.             "course", 
  2866.             "lesson", 
  2867.             "delete"
  2868.         );
  2870.         $lessons = $this->em->getRepository(Lesson::class)->findBy([
  2871.             "lessonModule" => $lessonModuleId,
  2872.             "deleted" => ($deleted - 1)
  2873.         ]);
  2875.         foreach ($lessons as $key => $lesson) {
  2876.             $this->delete($lesson, $typeItem, $permission, $isTrash);
  2877.             $lesson->cascade();
  2878.         }
  2879.     }
  2881.     public function deleteTrashCron()
  2882.     {
  2883.         $sql = "UPDATE EADPlataforma:Lesson AS l SET l.deleted = 2 
  2884.                 WHERE l.dateDelete <= :date AND l.deleted = 1 ";
  2885.         $query = $this->em->createQuery($sql);
  2886.         $query->setParameter('date', date('Y-m-d H:i:s', strtotime('-90 days')));
  2887.         $query->execute();
  2888.     }
  2889. }