src/Repository/LessonRepository.php line 584

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]]" => $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 = "{$clientId}-{$lesson->getId()}";
  166.         $userId = "{$clientId}-{$user->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.                     "custom" => [
  183.                         "clientId" => $clientId,
  184.                     ],
  185.                 ],
  186.                 'features' => [
  187.                     'recording' => $isAdmin ? "true" : "false",
  188.                     'livestreaming' => "false",
  189.                     'transcription' => "false",
  190.                     'outbound-call' => "false"
  191.                 ]
  192.             ]
  193.         ];
  195.         $token = JWT::encode($payload, $privateKey, "RS256", $publicKey);
  197.         return (object)[
  198.             "token" => $token,
  199.             "room" => $channelId,
  200.             "appId" => $appId,
  201.         ];
  202.     }
  204.     public function getLessonChatCredentialsNew(Lesson $lesson)
  205.     {
  207.         $library = $lesson->getLibrary();
  209.         if(!$this->getUser()){
  210.             return;
  211.         }
  213.         if(!$library){
  214.             return;
  215.         }
  217.         if(
  218.             $library->getType() != LibraryEnum::CONTENT_LIVE && 
  219.             $library->getType() != LibraryEnum::CONTENT_EXTERNAL_LIVE &&
  220.             $library->getType() != LibraryEnum::CONTENT_NEW_LIVE
  221.         ){
  222.             return;
  223.         }
  225.         $courseRepository = $this->em->getRepository(Course::class);
  226.         $isStudent = $courseRepository->isStudent($lesson->getCourse());
  228.         if($lesson->getShowLiveChat() == LessonEnum::NO && $isStudent){
  229.             return;
  230.         }
  231.         
  232.         $today = date('Y-m-d H:i:s');
  233.         $todayDate = date('Y-m-d');
  234.         $timeToday = strtotime($today);
  236.         $showLiveChat = LessonEnum::NO;
  237.         $liveDateStart = $library->getLiveStart();
  238.         $timeLiveEnd = date('Y-m-d', strtotime($liveDateStart));
  239.         $timeLiveStart = strtotime($liveDateStart . ' - 1 hours'); 
  240.         
  241.         if($timeToday >= $timeLiveStart && $todayDate == $timeLiveEnd || !$isStudent){
  242.             $showLiveChat = LessonEnum::YES;
  243.         }
  245.         if($showLiveChat == LessonEnum::NO){
  246.             return;
  247.         }
  249.         $client = $this->getConfiguration()->getClient();
  250.         $clientId = $client->getClientId();
  252.         $formatClientId = [
  253.             "1" => "00000{$clientId}",
  254.             "2" => "0000{$clientId}",
  255.             "3" => "000{$clientId}",
  256.             "4" => "00{$clientId}",
  257.             "5" => "0{$clientId}",
  258.         ];
  259.         
  260.         if(isset($formatClientId[strlen($clientId)])){
  261.             $clientId = $formatClientId[strlen($clientId)];
  262.         }
  263.         
  264.         $channelId = md5($clientId . $lesson->getId());
  265.         $userId = md5($clientId . $this->getUser()->getId());
  266.         $isAdmin = ($isStudent ? false : true );
  268.         $fileService = $this->generalService->getService('FileService');
  269.         $photo = $fileService->getFilePathComplete(
  270.             $this->getUser()->getPhoto(), 
  271.             UserEnum::PATH_PROFILES, 
  272.             true, 
  273.             true
  274.         );
  276.         $tokenAuth = $this->generalService->getTokenCron();
  277.         $url = "https://chat.eadplataforma.app/api/users/token";
  279.         $ch = curl_init($url);
  281.         $dataPost = [
  282.             "isAdmin" => $isAdmin,
  283.             "id" => $userId,
  284.             "name" => $this->getUser()->getName(),
  285.             "roomId" => $channelId,
  286.             "photoSrc" => $photo,
  287.             "lessonId" => $lesson->getId(),
  288.             "clientId" => $clientId,
  289.         ];
  291.         curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
  292.         curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($dataPost));
  293.         curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  294.         curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
  295.         curl_setopt($ch, CURLOPT_HTTPHEADER, [ 
  296.             "Authorization: {$tokenAuth}",
  297.             "Content-Type: application/json"
  298.         ]);
  300.         $dataToken = curl_exec($ch);
  301.         $error = curl_error($ch);
  302.         $dataToken = json_decode($dataToken);
  303.         curl_close($ch);
  305.         return (object)[
  306.             "role" => ($isAdmin ? "admin" : "user"),
  307.             "userId" => $userId,
  308.             "userFoto" => $photo,
  309.             "userName" => $this->getUser()->getName(),
  310.             "channelId" => $channelId,
  311.             "channelLogo" => "",
  312.             "channelName" => $lesson->getTitle(),
  313.             "userToken" => (!empty($dataToken->token) ? $dataToken->token : null),
  314.             "clientId" => $clientId
  315.         ];
  316.     }
  318.     public function getLessonChatCredentials(Lesson $lesson)
  319.     {
  320.         $library = $lesson->getLibrary();
  322.         if(!$this->getUser()){
  323.             return;
  324.         }
  326.         if(!$library){
  327.             return;
  328.         }
  330.         if(
  331.             $library->getType() != LibraryEnum::CONTENT_LIVE && 
  332.             $library->getType() != LibraryEnum::CONTENT_EXTERNAL_LIVE &&
  333.             $library->getType() != LibraryEnum::CONTENT_NEW_LIVE
  334.         ){
  335.             return;
  336.         }
  338.         $courseRepository = $this->em->getRepository(Course::class);
  339.         $isStudent = $courseRepository->isStudent($lesson->getCourse());
  341.         if($lesson->getShowLiveChat() == LessonEnum::NO && $isStudent){
  342.             return;
  343.         }
  344.         
  345.         $today = date('Y-m-d H:i:s');
  346.         $todayDate = date('Y-m-d');
  347.         $timeToday = strtotime($today);
  349.         $showLiveChat = LessonEnum::NO;
  350.         $liveDateStart = $library->getLiveStart();
  351.         $timeLiveEnd = date('Y-m-d', strtotime($liveDateStart));
  352.         $timeLiveStart = strtotime($liveDateStart . ' - 1 hours'); 
  353.         
  354.         if($timeToday >= $timeLiveStart && $todayDate == $timeLiveEnd || !$isStudent){
  355.             $showLiveChat = LessonEnum::YES;
  356.         }
  358.         if($showLiveChat == LessonEnum::NO){
  359.             return;
  360.         }
  362.         $header = [ 
  363.             'typ' => 'JWT', 
  364.             'alg' => 'HS256'
  365.         ];
  367.         $info = $this->generalService->getServiceAccess(ServicesEnum::LIVECHAT);
  369.         $client = $this->getConfiguration()->getClient();
  370.         $clientId = $client->getClientId();
  372.         $formatClientId = [
  373.             "1" => "00000{$clientId}",
  374.             "2" => "0000{$clientId}",
  375.             "3" => "000{$clientId}",
  376.             "4" => "00{$clientId}",
  377.             "5" => "0{$clientId}",
  378.         ];
  379.         
  380.         if(isset($formatClientId[strlen($clientId)])){
  381.             $clientId = $formatClientId[strlen($clientId)];
  382.         }
  383.         
  384.         $channelId = md5($clientId . $lesson->getId());
  385.         $clientStream = new \GetStream\StreamChat\Client($info->client, $info->token);
  386.         $channel = $clientStream->Channel("livestream", $channelId);
  388.         $userId = md5($clientId . $this->getUser()->getId());
  389.         $role = ($isStudent ? 'user' : 'admin' );
  391.         $stringUtil = $this->generalService->getUtil('StringUtil');
  393.         $chatToken = $info->token;
  394.         $segments = [];
  395.         $segments[] = $stringUtil->urlSafeB64Encode(json_encode($header));
  396.         $segments[] = $stringUtil->urlSafeB64Encode(json_encode([ 
  397.             "user_id" => $userId 
  398.         ]));
  400.         $signingInput = implode('.', $segments);
  401.         $signature = hash_hmac('SHA256', $signingInput, $chatToken, true);
  402.         $segments[] = $stringUtil->urlSafeB64Encode($signature);
  403.         $userToken =  implode('.', $segments);
  405.         $fileService = $this->generalService->getService('FileService');
  406.         $photo = $fileService->getFilePathComplete(
  407.             $this->getUser()->getPhoto(), 
  408.             UserEnum::PATH_PROFILES, 
  409.             true, 
  410.             true
  411.         );
  413.         return (object)[
  414.             "role" => $role,
  415.             "userId" => $userId,
  416.             "userFoto" => $photo,
  417.             "userName" => $this->getUser()->getName(),
  418.             "channelId" => $channelId,
  419.             "channelLogo" => "",
  420.             "channelName" => $lesson->getTitle(),
  421.             "userToken" => $userToken,
  422.             "clientId" => $info->client
  423.         ];
  424.     }
  426.     public function getLessonTeacher(Lesson $lesson)
  427.     {
  428.         $userLesson = $lesson->getUser();
  429.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  430.         $fileService = $this->generalService->getService('FileService');
  432.         $dataImg = [
  433.             "fileName" => $userLesson->getPhoto(),
  434.             "pathConst" => LessonEnum::PATH_PROFILES,
  435.             "option" => "l-user-profile-teacher",
  436.             "addUpload" => true,
  437.             "addStream" => true,
  438.         ];
  440.         $request = $this->generalService->getRequest();
  442.         $teacher = (object)[
  443.             "id" => $userLesson->getId(),
  444.             "name" => $userLesson->getName(),
  445.             "canAccessAdm" => $userPermissionUtil->canAccessAdm(),
  446.             "username" => $userLesson->getUsername(),
  447.             "photo" => $fileService->getFilePathObj($dataImg),
  448.             "permissionName" => (
  449.                 $userLesson->getUserProfile() ? 
  450.                 $userLesson->getUserProfile()->getName() 
  451.                 : null
  452.             ),
  453.         ];
  455.         return $teacher;
  456.     }
  458.     public function getLessonNextContent(Lesson $lesson, ?LessonLog $lessonLog = null)
  459.     {
  460.         $libraryRepository = $this->em->getRepository(Library::class);
  461.         $examRepository = $this->em->getRepository(Exam::class);
  462.         $nextExamLesson = $examRepository->getNextExamIdByLesson($lesson, true);
  463.         $lessonAfter = $this->getLessonIdAfterThat($lesson, true);
  465.         $course = $lesson->getCourse();
  466.         $courseId = $course->getId();
  468.         $isAccessible = false;
  469.         $acessMessage = null;
  471.         $lessonAfterClass = null;
  472.         $nextContent = null;
  473.         if($nextExamLesson || $lessonAfter){
  475.             $contentPagesNumber = null;
  476.             $contentDuration = null;
  477.             $contentType = null;
  478.             $contentThumb = null;
  480.             if($lessonAfter && empty($nextExamLesson)){
  481.                 $lessonAfterClass = $this->find($lessonAfter->id);
  483.                 if($lessonAfterClass){
  484.                     $library = $lessonAfterClass->getLibrary();
  485.                     if($library){
  486.                         $contentPagesNumber = $library->getPagesNumber();
  487.                         $contentDuration = $library->getDuration();
  488.                         $contentType = $library->getType();
  490.                         $libraryType = [
  491.                             LibraryEnum::CONTENT_EMBED, 
  492.                             LibraryEnum::CONTENT_CONFERENCE, 
  493.                             LibraryEnum::CONTENT_TEXT, 
  494.                             LibraryEnum::CONTENT_FILES
  495.                         ];
  496.                         if(!in_array($contentType, $libraryType)){
  497.                             $contentThumb = $libraryRepository->getCover($library);
  498.                         }
  499.                     }
  500.                 }
  501.             }
  503.             if($nextExamLesson){
  504.                 $nextExamLessonClass = $examRepository->find($nextExamLesson->id);
  505.                 $infoAccess = $examRepository->checkExamIsAccessible($nextExamLessonClass);
  506.                 $isAccessible = $infoAccess->isAccessible;
  507.                 $acessMessage = $infoAccess->message;
  508.             }else{
  509.                 $enrollmentRepository = $this->em->getRepository(Enrollment::class);
  510.                 $courseRepository = $this->em->getRepository(Course::class);
  512.                 $enrollment = $enrollmentRepository->findOneBy([
  513.                     "user" => $this->getUser()->getId(),
  514.                     "course" => $courseId,
  515.                 ]);
  517.                 if($enrollment){
  518.                     $isStudent = $courseRepository->isStudent($course);
  519.                     $infoAccess = $this->checkLessonIsAccessibleToUser(
  520.                         $lessonAfterClass, 
  521.                         $enrollment, 
  522.                         $lessonLog, 
  523.                         $isStudent,
  524.                         $lesson->getId()
  525.                     );
  527.                     $isAccessible = $infoAccess->isAccessible;
  528.                     $acessMessage = $infoAccess->message;
  529.                 }
  530.             }
  532.             $module = null;
  534.             if($lessonAfter){
  535.                 $module = (object)[
  536.                     "id" => (int)$lessonAfter->moduleId,
  537.                     "title" => $lessonAfter->moduleTitle,
  538.                 ];
  539.             }
  541.             if($nextExamLesson){
  542.                 $module = null;
  543.                 if(!empty($nextExamLesson->moduleId)){
  544.                     $module = (object)[
  545.                         "id" => (int)$nextExamLesson->moduleId,
  546.                         "title" => $nextExamLesson->moduleTitle,
  547.                     ];
  548.                 }
  549.             }
  551.             $timeUtil = $this->generalService->getUtil('DateTimeUtil');
  553.             $nextContent = (object)[
  554.                 "id" => (int)($nextExamLesson ? $nextExamLesson->id : $lessonAfter->id),
  555.                 "lessonId" => (
  556.                     $nextExamLesson ? 
  557.                     $nextExamLesson->lessonId : 
  558.                     (int)$lessonAfter->id
  559.                 ),
  560.                 "module" => $module,
  561.                 "courseId" => (
  562.                     $nextExamLesson ? 
  563.                     $nextExamLesson->courseId : 
  564.                     (int)$lessonAfter->courseId
  565.                 ),
  566.                 "title" => ($nextExamLesson ? $nextExamLesson->title : $lessonAfter->title),
  567.                 "type" => (
  568.                     $nextExamLesson ? 
  569.                     ($nextExamLesson->type == ExamEnum::QUIZ ? 'quiz' : 'exam') : 
  570.                     'lesson'
  571.                 ),
  572.                 "contentPagesNumber" => $contentPagesNumber,
  573.                 "contentDuration" => $contentDuration ? $timeUtil->timeToSec($contentDuration) : null,
  574.                 "contentType" => $contentType,
  575.                 "contentThumb" => $contentThumb,
  576.                 "isAccessible" => $isAccessible,
  577.                 "acessMessage" => $acessMessage,
  578.             ];
  579.         }
  581.         return $nextContent;
  582.     }
  584.     public function getLessonLastContent(Lesson $lesson)
  585.     {
  586.         $libraryRepository = $this->em->getRepository(Library::class);
  587.         $examRepository = $this->em->getRepository(Exam::class);
  588.         $lastExamLesson = $examRepository->getLastExamIdByLesson($lesson, true);
  589.         $lessonBefore = $this->getLessonIdBeforeThat($lesson, true);
  590.         $timeUtil = $this->generalService->getUtil('DateTimeUtil');
  592.         $lastContent = null;
  593.         if($lastExamLesson || $lessonBefore){
  595.             $contentPagesNumber = null;
  596.             $contentDuration = null;
  597.             $contentType = null;
  598.             $contentThumb = null;
  600.             if($lessonBefore && empty($lastExamLesson)){
  602.                 $lessonBeforeClass = $this->find($lessonBefore->id);
  604.                 if($lessonBeforeClass){
  605.                     $library = $lessonBeforeClass->getLibrary();
  606.                     if($library){
  607.                         $contentPagesNumber = $library->getPagesNumber();
  608.                         $contentDuration = $library->getDuration();
  609.                         $contentType = $library->getType();
  610.                         
  611.                         $libraryType = [
  612.                             LibraryEnum::CONTENT_EMBED, 
  613.                             LibraryEnum::CONTENT_CONFERENCE, 
  614.                             LibraryEnum::CONTENT_TEXT, 
  615.                             LibraryEnum::CONTENT_FILES
  616.                         ];
  617.                         if(!in_array($contentType, $libraryType)){
  618.                             $contentThumb = $libraryRepository->getCover($library);
  619.                         }
  620.                     }
  621.                 }
  622.             }
  624.             $module = (object)[
  625.                 "id" => (int)$lessonBefore->moduleId,
  626.                 "title" => $lessonBefore->moduleTitle,
  627.             ];
  629.             if($lastExamLesson){
  630.                 $module = null;
  631.                 if(!empty($lastExamLesson->moduleId)){
  632.                     $module = (object)[
  633.                         "id" => (int)$lastExamLesson->moduleId,
  634.                         "title" => $lastExamLesson->moduleTitle,
  635.                     ];
  636.                 }
  637.             }
  639.             $lastContent = (object)[
  640.                 "id" => (int)($lastExamLesson ? $lastExamLesson->id : $lessonBefore->id),
  641.                 "lessonId" => (
  642.                     $lastExamLesson ? 
  643.                     $lastExamLesson->lessonId : 
  644.                     (int)$lessonBefore->id
  645.                 ),
  646.                 "module" => $module,
  647.                 "courseId" => (
  648.                     $lastExamLesson ? 
  649.                     $lastExamLesson->courseId : 
  650.                     (int)$lessonBefore->courseId
  651.                 ),
  652.                 "title" => ($lastExamLesson ? $lastExamLesson->title : $lessonBefore->title),
  653.                 "type" => (
  654.                     $lastExamLesson ? 
  655.                     ($lastExamLesson->type == ExamEnum::QUIZ ? 'quiz' : 'exam') : 
  656.                     'lesson'
  657.                 ),
  658.                 "contentPagesNumber" => $contentPagesNumber,
  659.                 "contentDuration" => $contentDuration ? $timeUtil->timeToSec($contentDuration) : null,
  660.                 "contentType" => $contentType,
  661.                 "contentThumb" => $contentThumb,
  662.                 "isAccessible" => true,
  663.                 "acessMessage" => null,
  664.             ];
  665.         }
  667.         return $lastContent;
  668.     }
  670.     public function getShowLiveChat(Lesson $lesson, ?bool $isStudent = true)
  671.     {   
  672.         $library = $lesson->getLibrary();
  674.         if(!$library){
  675.             return LessonEnum::NO;
  676.         }
  678.         if(
  679.             $library->getType() == LibraryEnum::CONTENT_LIVE ||
  680.             $library->getType() == LibraryEnum::CONTENT_NEW_LIVE
  681.         ){
  682.             if($this->configuration->checkModuleIsAbleOnPlan('liveContentFunction')){
  683.                 if($lesson->getShowLiveChat() == LessonEnum::YES){
  684.                     $liveDateStart = $library->getLiveStart();
  686.                     $timeLiveEnd = date('Y-m-d', strtotime($liveDateStart));
  687.                     $timeLiveStart = strtotime($liveDateStart . ' - 1 hours'); 
  688.                     $todayDate = date('Y-m-d');
  689.                     $timeToday = strtotime($todayDate);
  691.                     if(
  692.                         $timeToday >= $timeLiveStart && 
  693.                         $todayDate == $timeLiveEnd || !$isStudent
  694.                     ){
  695.                         return LessonEnum::YES;
  696.                     }
  697.                 }
  698.             }
  699.         }
  701.         return LessonEnum::NO;
  702.     }
  704.     public function findItems(?Course $course)
  705.     {
  706.         $query = $this->createQueryBuilder('l');
  708.         if($course){
  709.             $query->andWhere('l.course = :courseId');
  710.             $query->setParameter('courseId', $course->getId());
  711.         }
  713.         return $query->orderBy('l.order', 'ASC')->getQuery()->getResult();
  714.     }
  716.     public function countLessons()
  717.     {
  718.         $query = $this->createQueryBuilder('l');
  719.         $query->select("COUNT(l.id) AS total");
  720.         $query->andWhere('l.deleted != :deleted');
  721.         $query->setParameter('deleted', LessonEnum::ITEM_DELETED);
  723.         $result = (object)$query->getQuery()->getOneOrNullResult();
  724.         return $result->total;
  725.     }
  727.     public function countLessonByLibrary(int $libraryId, ?Lesson $lesson = null)
  728.     {
  729.         
  730.         $query = $this->createQueryBuilder('l');
  731.         $query->select("COUNT(l.id) AS total");
  733.         $query->andWhere('l.library = :library');
  734.         $query->andWhere('l.deleted != :deleted');
  735.         
  736.         $query->setParameter('deleted', LessonEnum::ITEM_DELETED);
  737.         $query->setParameter('library', $libraryId);
  739.         if(!empty($lesson)){
  740.             $query->andWhere('l.id =! :lessonId');
  741.             $query->setParameter('lessonId', $lesson->getId());
  742.         }
  744.         $result = (object)$query->getQuery()->getOneOrNullResult();
  745.         return $result->total;
  746.     }
  748.     public function countAllLessonByLibraryType(?int $status = null, ?int $type = null)
  749.     {
  750.         $query = $this->createQueryBuilder('l');
  751.         $query->select("COUNT(l.id) AS total");
  753.         if(!is_null($type)){
  754.             $query->innerJoin('EADPlataforma:Library', 'lb', 'WITH', 'lb.id = l.library');
  755.             $query->andWhere('lb.type = :type');
  756.             $query->andWhere('lb.deleted = :deleted');
  758.             $query->setParameter('type', $type);
  759.             $query->setParameter('deleted', LibraryEnum::ITEM_NO_DELETED);
  760.         }
  762.         if(!empty($status)){
  763.             $query->andWhere('l.status = :status');
  764.             $query->setParameter('status', $status);
  765.         }
  767.         $query->andWhere('l.deleted = :deleted');
  768.         $query->setParameter('deleted', LessonEnum::ITEM_NO_DELETED);
  770.         $result = (object)$query->getQuery()->getOneOrNullResult();
  771.         return $result->total;
  772.     }
  774.     public function getAllLessonByLibraryLive(?int $user = null)
  775.     {
  776.         $query = $this->createQueryBuilder('l');
  778.         $query->innerJoin('EADPlataforma:Course', 'c', 'WITH', 'l.course = c.id');
  779.         $query->innerJoin('EADPlataforma:LessonModule', 'lm', 'WITH', 'l.lessonModule = lm.id');
  780.         $query->innerJoin('EADPlataforma:Library', 'lb', 'WITH', 'lb.id = l.library');
  782.         $query->andWhere('(
  783.             lb.type = :type OR 
  784.             lb.type = :typeExternalLive OR 
  785.             lb.type = :typeNewLive
  786.         )');
  787.         
  788.         $query->setParameter('type', LibraryEnum::CONTENT_LIVE);
  789.         $query->setParameter('typeExternalLive', LibraryEnum::CONTENT_EXTERNAL_LIVE);
  790.         $query->setParameter('typeNewLive', LibraryEnum::CONTENT_NEW_LIVE);
  791.         
  793.         if(!empty($user)){
  794.             
  795.             $query->andWhere('(
  796.                 l.user = :user OR 
  797.                 lm.user = :user OR 
  798.                 c.user = :user
  799.             )');
  801.             $query->setParameter('user', $user);
  802.         }
  804.         $query->andWhere('c.deleted = :deletedCourse');
  805.         $query->andWhere('lm.deleted = :deletedLessonModule');
  806.         $query->andWhere('lb.deleted = :deletedLibrary');
  807.         $query->andWhere('l.deleted = :deleted');
  809.         $query->setParameter('deletedCourse', CourseEnum::ITEM_NO_DELETED);
  810.         $query->setParameter('deletedLessonModule', LessonModuleEnum::ITEM_NO_DELETED);
  811.         $query->setParameter('deletedLibrary', LibraryEnum::ITEM_NO_DELETED);
  812.         $query->setParameter('deleted', LessonEnum::ITEM_NO_DELETED);
  814.         $data = $query->getQuery()->getResult();
  816.         return $data;
  817.     }
  819.     public function getAllLessons()
  820.     {
  821.         $query = $this->createQueryBuilder('l');
  823.         $query->select('
  824.             l.id AS lessonId,
  825.             c.id AS courseId,
  826.             lm.id AS lessonModuleId,
  827.             l.title AS lessonTitle,
  828.             c.title AS courseTitle,
  829.             lm.title AS lessonModuleTitle
  830.         ');
  832.         $query->innerJoin(
  833.             'EADPlataforma:Course', 
  834.             'c', 
  835.             'WITH', 
  836.             'c.id = l.course AND c.deleted = :courseDeleted'
  837.         );
  839.         $query->innerJoin(
  840.             'EADPlataforma:LessonModule', 
  841.             'lm', 
  842.             'WITH', 
  843.             'lm.id = l.lessonModule AND lm.deleted = :lessonModuleDeleted'
  844.         );
  846.         $query->andWhere('l.deleted = :lessonDeleted');
  848.         $query->setParameter('courseDeleted', CourseEnum::ITEM_NO_DELETED);
  849.         $query->setParameter('lessonModuleDeleted', LessonModuleEnum::ITEM_NO_DELETED);
  850.         $query->setParameter('lessonDeleted', LessonEnum::ITEM_NO_DELETED);
  852.         $query->addOrderBy('c.order', 'ASC');
  853.         $query->addOrderBy('lm.order', 'ASC');
  854.         $query->addOrderBy('l.order', 'ASC');
  856.         $data = $query->getQuery()->getResult();
  858.         return $data;
  859.     }
  861.     public function getLessonPublicDemoById(int $lessonId)
  862.     {
  863.         $query = $this->createQueryBuilder('l');
  864.         $query->innerJoin(
  865.             'EADPlataforma:LessonModule', 
  866.             'lm', 
  867.             'WITH', 
  868.             'lm.id = l.lessonModule AND lm.deleted = 0'
  869.         );
  871.         $query->innerJoin(
  872.             'EADPlataforma:Course', 
  873.             'c', 
  874.             'WITH', 
  875.             'c.id = l.course AND c.deleted = 0'
  876.         );
  878.         $query->andWhere('l.deleted = 0');
  879.         $query->andWhere('l.id = :lessonId');
  880.         $query->andWhere('l.demonstration = :demonstration');
  881.         $query->andWhere('c.status = :courseStatus');
  882.         $query->andWhere('l.status = :lessonStatus');
  883.         $query->andWhere('lm.status = :lessonModuleStatus');
  885.         $query->setParameter('lessonId', $lessonId);
  886.         $query->setParameter('demonstration', LessonEnum::YES);
  887.         $query->setParameter('courseStatus', CourseEnum::PUBLISHED);
  888.         $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  889.         $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  891.         $data = $query->getQuery()->getOneOrNullResult();
  892.         return $data;
  893.     }
  895.     public function isLessonTeacher(Lesson $lesson, User $user)
  896.     {
  897.         if(!$lesson->getCourse()){
  898.             return false;
  899.         }
  901.         if(!$lesson->getLessonModule()){
  902.             return false;
  903.         }
  905.         $courseTeacherId = $lesson->getCourse()->getUser()->getId();
  906.         $lessonModuleTeacherId = $lesson->getLessonModule()->getUser()->getId();
  907.         $lessonTeacherId = $lesson->getUser()->getId();
  909.         if(
  910.             $courseTeacherId == $user->getId() || 
  911.             $lessonModuleTeacherId == $user->getId() || 
  912.             $lessonTeacherId == $user->getId()
  913.         ){
  914.             return true;
  915.         }
  917.         return false;
  918.     }
  920.     public function checkLessonIsAccessibleToUser(
  921.         Lesson $lesson, 
  922.         Enrollment $enrollment, 
  923.         ?LessonLog $log = null, 
  924.         ?bool $isStudent = true,
  925.         ?int $lessonIdBefore = null,
  926.         ?bool $blockIsNotAccess = false
  927.     )
  928.     {
  929.         $info = (object)[
  930.             "isAccessible" => false,
  931.             "isAccessPeriodExpired" => false,
  932.             "message" => null,
  933.         ];
  935.         if(!$this->getUser()){
  937.             $info->message = $this->configuration->getLanguage('error_auth', 'lesson_view_error');
  939.             return $info;
  940.         }
  942.         $user = $enrollment->getUser();
  943.         $course = $lesson->getCourse();
  944.         $lessonModule = $lesson->getLessonModule();
  946.         $today = strtotime('now');
  947.         if(!$isStudent){
  949.             $info->isAccessible = true;
  951.             return $info;
  952.         }
  954.         if(!$enrollment){
  956.             $info->message = $this->configuration->getLanguage(
  957.                 'error_enrollment_not_found',
  958.                 'lesson_view'
  959.             );
  961.             return $info;
  962.         }
  964.         if(
  965.             $lesson->getStatus() == LessonEnum::DRAFT ||
  966.             $lessonModule->getStatus() == LessonModuleEnum::DRAFT ||
  967.             $course->getStatus() == CourseEnum::DRAFT
  968.         ){
  969.             $info->message = $this->configuration->getLanguage(
  970.                 'error_unavailable',
  971.                 'lesson_view'
  972.             );
  974.             return $info;
  975.         }
  977.         if($enrollment->getStatus(false, true) == EnrollmentEnum::STATUS_EXPIRED){
  978.         
  979.             $info->message = $this->configuration->getLanguage(
  980.                 'error_enrollment_expired', 
  981.                 'lesson_view_error'
  982.             );
  984.             return $info;
  985.         }
  987.         $courseDateRelease = strtotime($course->getDateRelease());
  988.         if($courseDateRelease >= $today){
  990.             $info->message = "{$this->configuration->getLanguage(
  991.                 'error_date_release', 
  992.                 'lesson_view_error'
  993.             )} {$course->getDateRelease('d/m/Y')}";
  995.             return $info;
  996.         }
  998.         $lessonModuleRepository = $this->em->getRepository(LessonModule::class);
  999.         $moduleInfo = $lessonModuleRepository->checkLessonModuleIsAccessibleToUser(
  1000.             $lessonModule, 
  1001.             $enrollment, 
  1002.             $isStudent,
  1003.             $lessonIdBefore
  1004.         );
  1005.         
  1006.         if(!$moduleInfo->isAccessible) {
  1008.             return $moduleInfo;
  1009.         }
  1011.         $unlimitedexamFunction = $this->configuration->checkModuleIsAbleOnPlan(
  1012.             'unlimitedExamFunction'
  1013.         );
  1015.         $hasLessonControl = $this->configuration->checkModuleIsAbleOnPlan(
  1016.             'lessonControlFunction'
  1017.         );
  1019.         $examModule = $this->configuration->isModuleActive("exam_module");
  1021.         if(!$hasLessonControl){
  1022.             $info->isAccessible = true;
  1024.             return $info;
  1025.         }
  1027.         $lessonLogRepository = $this->emEadmin->getRepository(LessonLog::class);
  1028.         if(empty($log)){
  1029.             $logLessonId = "{$course->getId()}#{$user->getId()}#{$lesson->getId()}";
  1030.             $log = $lessonLogRepository->find($logLessonId);
  1031.         }
  1033.         if($log && !empty($log->getDateConclusion())){
  1034.             $info->isAccessible = true;
  1036.             $periodEnd = $lesson->getControlClosePeriod();
  1037.             if(!empty($periodEnd)){
  1038.                 $dateEnd = strtotime("{$log->getDateConclusion()} + {$periodEnd} days");
  1039.                 if($dateEnd < $today){                    
  1040.                     $info->isAccessible = false;
  1041.                     $info->isAccessPeriodExpired = true;
  1042.                 }
  1043.             }
  1045.             return $info;
  1046.         }
  1048.         if($blockIsNotAccess){
  1049.             $info->message = $this->configuration->getLanguage(
  1050.                 'error_required_incomplete', 
  1051.                 'lesson_view_error'
  1052.             );
  1054.             return $info;
  1055.         }
  1057.         if($examModule){
  1058.             if($log && empty($log->getDateConclusion()) || !$log){
  1060.                 $examUserRepository = $this->em->getRepository(ExamUser::class);
  1061.                 $currentExam = $examUserRepository->getCurrentExamOnCourseToUserByLesson(
  1062.                     $lesson, 
  1063.                     $user
  1064.                 );
  1065.                 if($currentExam){
  1066.                     if($unlimitedexamFunction){
  1067.                         //check the exam type
  1068.                         if($currentExam->getType() == ExamEnum::LESSON){
  1069.                             $lessonExam = $currentExam->getLesson();
  1070.                             $lessonModuleExam = $lessonExam->getLessonModule();
  1072.                             //if exam is from this lesson redirect to exam
  1073.                             if($lessonExam->getId() != $lesson->getId()){
  1074.                                 //if the exam is from a module before that redirect to exam
  1075.                                 if($lessonModuleExam->getOrder() < $lessonModule->getOrder()){
  1076.                                     $info->message = $this->configuration->getLanguage(
  1077.                                         'error_required_incomplete', 
  1078.                                         'lesson_view_error'
  1079.                                     );
  1081.                                     return $info;
  1082.                                 }else if(
  1083.                                     $lessonExam->getOrder() < $lesson->getOrder() && 
  1084.                                     $lessonModuleExam->getId() == $lessonModule->getId()
  1085.                                 ){ //if is the same module but the lesson is before that rediret to exam
  1086.                                     $info->message = $this->configuration->getLanguage(
  1087.                                         'error_required_incomplete', 
  1088.                                         'lesson_view_error'
  1089.                                     );
  1091.                                     return $info;
  1092.                                 }
  1093.                             }
  1094.                         }else if($currentExam->getType() == ExamEnum::MODULE){
  1095.                             $lessonModuleExam = $currentExam->getLessonModule();
  1096.                             
  1097.                             if(
  1098.                                 $lessonModuleExam->getId() != $lessonModule->getId() && 
  1099.                                 $lessonModuleExam->getOrder() < $lessonModule->getOrder()
  1100.                             ){ //if is not the same module and the module is before that rediret to exam
  1101.                                 $info->message = $this->configuration->getLanguage(
  1102.                                     'error_required_incomplete', 
  1103.                                     'lesson_view_error'
  1104.                                 );
  1106.                                 return $info;
  1107.                             }
  1108.                         }
  1109.                     }
  1111.                     if($currentExam->getType() == ExamEnum::COURSE){
  1112.                         $info->message = $this->configuration->getLanguage(
  1113.                             'error_required_incomplete', 
  1114.                             'lesson_view_error'
  1115.                         );
  1117.                         return $info;
  1118.                     }
  1119.                 }
  1121.                 if($unlimitedexamFunction){
  1122.                     $examRepository = $this->em->getRepository(Exam::class);
  1123.                     $exam = $examRepository->getCurrentNotStartedExamUser(
  1124.                         $lesson, 
  1125.                         $user
  1126.                     );
  1128.                     if($exam){
  1129.                         $lessonExam = $exam->getLesson();
  1130.                         if(!$lessonExam || $lessonExam->getId() != $lesson->getId()){
  1132.                             $info->message = $this->configuration->getLanguage(
  1133.                                 'error_required_incomplete', 
  1134.                                 'lesson_view_error'
  1135.                             );
  1137.                             return $info;
  1138.                         }
  1139.                     }
  1140.                 }
  1141.             }
  1142.         }
  1144.         //if exist a lesson with requirement before that redirect to there
  1145.         $currentLesson = $this->getCurrentLesson($lesson, $user);
  1146.         if(!empty($currentLesson)){
  1147.             if($currentLesson->getId() != $lesson->getId()){
  1148.                 $logId = "{$course->getId()}#{$user->getId()}#{$currentLesson->getId()}";
  1149.                 $logCurrent = $lessonLogRepository->find($logId);
  1151.                 if(empty($logCurrent)){
  1152.                     $info->message = $this->configuration->getLanguage(
  1153.                         'error_required_incomplete', 
  1154.                         'lesson_view_error'
  1155.                     );
  1157.                     return $info;
  1158.                 }else if(empty($logCurrent->getDateConclusion())){
  1159.                     $info->message = $this->configuration->getLanguage(
  1160.                         'error_required_incomplete', 
  1161.                         'lesson_view_error'
  1162.                     );
  1164.                     return $info;
  1165.                 }
  1166.             }
  1167.         }
  1169.         if($lesson->getControlReleaseType() == LessonEnum::RELEASED){
  1170.             $info->isAccessible = true;
  1172.             return $info;
  1173.         }else if($lesson->getControlReleaseType() == LessonEnum::FIXED_DATE){
  1174.             $controlDateRelease = $lesson->getControlDateRelease();
  1175.             $time = strtotime($controlDateRelease);
  1177.             $todaySeconds = strtotime(date('Y-m-d H:i:s'));
  1178.            
  1179.             $controlClosePeriod = $lesson->getControlClosePeriod();
  1180.             if(!empty($controlClosePeriod)){
  1181.                 $timeLog = strtotime(
  1182.                     "{$controlDateRelease} + {$controlClosePeriod} day"
  1183.                 );
  1185.                 if($todaySeconds > $timeLog){
  1187.                     $timeLogText = date('d/m/Y H:i:s', $timeLog);
  1189.                     $info->message = "{$this->configuration->getLanguage(
  1190.                         'error_date_end', 
  1191.                         'lesson_view_error'
  1192.                     )} {$timeLogText}";
  1194.                     return $info;
  1195.                 }
  1196.             }
  1197.            
  1198.             if($today >= $time){
  1199.                 $info->isAccessible = true;
  1201.                 return $info;
  1202.             }
  1204.             $timeText = date('d/m/Y H:i:s', $time);
  1205.                         
  1206.             $info->message = "{$this->configuration->getLanguage(
  1207.                 'error_date_release', 
  1208.                 'lesson_view_error'
  1209.             )} {$timeText}";
  1211.             return $info;
  1213.         }else if($lesson->getControlReleaseType() == LessonEnum::FLEXIBLE_DATE){
  1214.             $controlReleasePeriod = $lesson->getControlReleasePeriod();
  1215.             if($lesson->getControlReleaseAfterType() == LessonEnum::ENROLLMENT){
  1216.                 $time = strtotime(
  1217.                     "{$enrollment->getDateRegister()} + {$controlReleasePeriod} day"
  1218.                 );
  1219.                 
  1220.                 $todaySeconds = strtotime(date('Y-m-d H:i:s'));
  1221.                 $controlClosePeriod = $lesson->getControlClosePeriod();
  1222.                 if(!empty($controlClosePeriod)){
  1223.                     
  1224.                     /*
  1225.                     if($log && empty($log->getDateConclusion()) || !$log){
  1226.                         return false;
  1227.                     }
  1228.                     
  1229.                     if($log->getComplete() == LessonEnum::NO){
  1230.                         return false;
  1231.                     }*/
  1233.                     if($log && !empty($log->getDateConclusion())){
  1234.                         $timeLog = strtotime(
  1235.                             "{$log->getDateConclusion()} + {$controlClosePeriod} day"
  1236.                         );
  1238.                         if($todaySeconds > $timeLog){
  1239.                             $timeLogText = date('d/m/Y H:i:s', $timeLog);
  1241.                             $info->message = "{$this->configuration->getLanguage(
  1242.                                 'error_date_end', 
  1243.                                 'lesson_view_error'
  1244.                             )} {$timeLogText}";
  1246.                             return $info;
  1247.                         }
  1248.                     }
  1249.                 }
  1250.                 
  1251.                 if($today >= $time){
  1252.                     $info->isAccessible = true;
  1254.                     return $info;
  1255.                 }
  1257.                 $timeText = date('d/m/Y H:i:s', $time);
  1258.                         
  1259.                 $info->message = "{$this->configuration->getLanguage(
  1260.                     'error_date_release', 
  1261.                     'lesson_view_error'
  1262.                 )} {$timeText}";
  1264.                 return $info;
  1265.             }else if(
  1266.                 $lesson->getControlReleaseAfterType() == LessonEnum::LAST_LESSON && 
  1267.                 !empty($lessonIdBefore)
  1268.             ){
  1269.                 $logId = "{$course->getId()}#{$user->getId()}#{$lessonIdBefore}";
  1270.                 $logLast = $lessonLogRepository->find($logId);
  1271.                 
  1272.                 if($logLast && !empty($logLast->getDateConclusion())){
  1273.                     $time = strtotime(
  1274.                         "{$logLast->getDateConclusion()} + {$controlReleasePeriod} day"
  1275.                     );
  1276.                     if($today >= $time){
  1277.                         $info->isAccessible = true;
  1279.                         return $info;
  1280.                     }
  1281.                 }
  1282.             }
  1283.         }
  1285.         $info->message = $this->configuration->getLanguage('error_unavailable', 'lesson_view_error');
  1287.         return $info;
  1288.     }
  1290.     public function getLessonDateReleaseAccess(
  1291.         Lesson $lesson, 
  1292.         Enrollment $enrollment, 
  1293.         ?bool $isStudent = true, 
  1294.         ?int $lessonIdBefore = null
  1295.     )
  1296.     {
  1297.         $date = date('Y-m-d H:i:s');
  1299.         if(!$this->getUser()){
  1300.             return $date;
  1301.         }
  1303.         $user = $enrollment->getUser();
  1304.         $course = $lesson->getCourse();
  1305.         $today = strtotime('now');
  1307.         if(!$isStudent){
  1308.             return $date;
  1309.         }
  1311.         if(!$enrollment){
  1312.             return $date;
  1313.         }
  1315.         $lessonLogRepository = $this->emEadmin->getRepository(LessonLog::class);
  1316.         if($lesson->getStatus() == LessonEnum::PUBLISHED){
  1317.             if($lesson->getControlReleaseType() == LessonEnum::RELEASED){
  1318.                 return $date;
  1319.             }else if($lesson->getControlReleaseType() == LessonEnum::FIXED_DATE){
  1320.                 return $lesson->getControlDateRelease();
  1321.             }else if($lesson->getControlReleaseType() == LessonEnum::FLEXIBLE_DATE){
  1322.                 $controlReleasePeriod = $lesson->getControlReleasePeriod();
  1323.                 if($lesson->getControlReleaseAfterType() == LessonEnum::ENROLLMENT){
  1324.                     $time = strtotime(
  1325.                         "{$enrollment->getDateRegister()} + {$controlReleasePeriod} day"
  1326.                     );
  1327.                     return date('Y-m-d H:i:s', $time);
  1328.                 }else if(
  1329.                     $lesson->getControlReleaseAfterType() == LessonEnum::LAST_LESSON && 
  1330.                     !empty($lessonIdBefore)
  1331.                 ){
  1332.                     $logId = "{$course->getId()}#{$user->getId()}#{$lessonIdBefore}";
  1333.                     $logLast = $lessonLogRepository->find($logId);
  1335.                     if($logLast){
  1336.                         $time = strtotime(
  1337.                             "{$logLast->getDateConclusion()} + {$controlReleasePeriod} day"
  1338.                         );
  1339.                         return date('Y-m-d H:i:s', $time);
  1340.                     }
  1341.                 }
  1342.             }
  1343.         }
  1345.         return $date;
  1346.     }
  1348.     public function getCurrentLessonLogOrigin(Lesson $lessonBase)
  1349.     {
  1351.         $course = $lessonBase->getCourse();
  1352.         $lessonModule = $lessonBase->getLessonModule();
  1354.         $query = $this->createQueryBuilder('l');
  1355.         $query->select('l.id');
  1356.         $query->innerJoin(
  1357.             'EADPlataforma:LessonModule', 
  1358.             'lm', 
  1359.             'WITH', 
  1360.             'lm.id = l.lessonModule'
  1361.         );
  1363.         $query->leftJoin(
  1364.             'EADPlataforma:LessonLogOrigin', 
  1365.             'lg', 
  1366.             'WITH', 
  1367.             'lg.lesson = l.id AND lg.user = :user'
  1368.         );
  1370.         $query->andWhere('l.deleted = 0');
  1371.         $query->andWhere('lm.deleted = 0');
  1372.         $query->andWhere('l.controlRequirement = :requirement');
  1373.         $query->andWhere('l.status = :lessonStatus');
  1374.         $query->andWhere('lm.status = :lessonModuleStatus');
  1375.         $query->andWhere('l.course = :course');
  1377.         if($lessonBase->getOrder() == LessonEnum::YES){
  1378.             $query->andWhere('(
  1379.                 ( l.order <= :orderL AND lm.order = :orderLM ) OR ( lm.order < :orderLM )
  1380.             )');
  1381.         }else{
  1382.             $query->andWhere('(
  1383.                 ( l.order < :orderL AND lm.order = :orderLM ) OR ( lm.order < :orderLM )
  1384.             )');
  1385.         }
  1387.         $query->andWhere('lg.dateConclusion IS NULL');
  1389.         $query->setParameter('user', $this->getUser()->getId());
  1390.         $query->setParameter('course', $lessonBase->getCourse()->getId());
  1391.         $query->setParameter('requirement', LessonEnum::YES);
  1392.         $query->setParameter('orderL', $lessonBase->getOrder());
  1393.         $query->setParameter('orderLM', $lessonModule->getOrder());
  1394.         $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  1395.         $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  1397.         $query->addOrderBy('lm.order', 'ASC');
  1398.         $query->addOrderBy('l.order', 'ASC');
  1400.         $query->setMaxResults(1);
  1402.         $lesson = (object)$query->getQuery()->getOneOrNullResult();
  1404.         if(!empty($lesson->id)){
  1405.             return $this->findOneBy([ "id" => $lesson->id ]);
  1406.         }
  1408.         return;
  1409.     }
  1411.     public function getCurrentLesson(Lesson $lessonBase, User $user)
  1412.     {
  1413.         $course = $lessonBase->getCourse();
  1414.         $lessonModule = $lessonBase->getLessonModule();
  1416.         $query = $this->createQueryBuilder('l');
  1417.         $query->select('l.id');
  1419.         $query->innerJoin('EADPlataforma:Course', 'c', 'WITH', 'c.id = l.course');
  1421.         $query->innerJoin(
  1422.             'EADPlataforma:LessonModule', 'lm', 'WITH', 'lm.id = l.lessonModule'
  1423.         );
  1425.         $query->innerJoin('EADPlataforma:Library', 'lb', 'WITH', 'lb.id = l.library');
  1426.         
  1427.         $query->andWhere('c.deleted = 0');
  1428.         $query->andWhere('l.deleted = 0');
  1429.         $query->andWhere('lm.deleted = 0');
  1430.         $query->andWhere('lb.deleted = 0');
  1432.         $query->andWhere('l.controlRequirement = :requirement');
  1433.         $query->andWhere('l.status = :lessonStatus');
  1434.         $query->andWhere('lm.status = :lessonModuleStatus');
  1435.         $query->andWhere('l.course = :course');
  1436.         $query->andWhere('l.id != :lessonBase');
  1438.         if($lessonBase->getOrder() == LessonEnum::YES){
  1439.             $query->andWhere('(
  1440.                 ( l.order <= :orderL AND lm.order = :orderLM ) OR ( lm.order < :orderLM )
  1441.             )');
  1442.         }else{
  1443.             $query->andWhere('(
  1444.                 ( l.order < :orderL AND lm.order = :orderLM ) OR ( lm.order < :orderLM )
  1445.             )');
  1446.         }
  1448.         $query->setParameter('course', $lessonBase->getCourse()->getId());
  1449.         $query->setParameter('requirement', LessonEnum::YES);
  1450.         $query->setParameter('orderL', $lessonBase->getOrder());
  1451.         $query->setParameter('orderLM', $lessonModule->getOrder());
  1452.         $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  1453.         $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  1454.         $query->setParameter('lessonBase', $lessonBase->getId());
  1456.         $query->addOrderBy('lm.order', 'DESC');
  1457.         $query->addOrderBy('l.order', 'DESC');
  1459.         $query->setMaxResults(1);
  1461.         $lesson = (object)$query->getQuery()->getOneOrNullResult();
  1463.         if(!empty($lesson->id)){
  1464.             $logId = "{$course->getId()}#{$user->getId()}#{$lesson->id}";
  1465.             $log = $this->emEadmin->getRepository(LessonLog::class)->find($logId);
  1467.             if(!$log || ($log && empty($log->getDateConclusion()))){
  1468.                 return $this->findOneBy([ "id" => $lesson->id ]);
  1469.             }
  1470.         }
  1472.         return;
  1473.     }
  1475.     public function getCourseLessonsIds(
  1476.         Course $course, 
  1477.         ?LessonModule $lessonModule = null, 
  1478.         ?string $searchText = null
  1479.     )
  1480.     {
  1481.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  1482.         $permission = $userPermissionUtil->getPermission("course", "see");
  1483.         $user = $userPermissionUtil->getUser();
  1484.         $lessonModuleId = ($lessonModule ? $lessonModule->getId() : null);
  1486.         $keyCache = md5(
  1487.             "getCourseLessonsIds{$course->getId()}-{$user->getId()}-{$lessonModuleId}"
  1488.         );
  1490.         if(isset($this->lessonIdsCourse[$keyCache])){
  1491.             return $this->lessonIdsCourse[$keyCache];
  1492.         }
  1494.         $isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
  1495.             $course, 
  1496.             $user
  1497.         );
  1498.         
  1499.         $query = $this->createQueryBuilder('l');
  1501.         $query->select('
  1502.             l.id, 
  1503.             l.title,
  1504.             IDENTITY(l.course) AS courseId,
  1505.             IDENTITY(l.lessonModule) AS moduleId,
  1506.             lm.title AS moduleTitle
  1507.         ');
  1509.         $query->innerJoin(
  1510.             'EADPlataforma:LessonModule', 'lm', 'WITH', 'lm.id = l.lessonModule'
  1511.         );
  1513.         if(!empty($searchText)){
  1514.             $query->andWhere('l.title LIKE :searchText');
  1515.             $query->setParameter('searchText', "%{$searchText}%");
  1516.         }
  1518.         $query->andWhere('l.deleted = 0');
  1519.         $query->andWhere('lm.deleted = 0');
  1521.         $query->andWhere('l.course = :courseId');
  1522.         $query->setParameter('courseId', $course->getId());
  1524.         if($lessonModule){
  1525.             $query->andWhere('l.lessonModule = :lessonModuleId');
  1526.             $query->setParameter('lessonModuleId', $lessonModule->getId());
  1527.         }
  1529.         if(
  1530.             $userPermissionUtil->isLow($permission) || 
  1531.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  1532.         ){
  1534.             $query->andWhere('l.status = :lessonStatus');
  1535.             $query->andWhere('lm.status = :lessonModuleStatus');
  1536.             $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  1537.             $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  1538.         }
  1539.         
  1540.         $query->addOrderBy('lm.order', 'ASC');
  1541.         $query->addOrderBy('l.order', 'ASC');
  1542.         
  1543.         $data = $query->getQuery()->execute();
  1545.         $this->lessonIdsCourse[$keyCache] = $data;
  1547.         return $this->lessonIdsCourse[$keyCache];
  1548.     }
  1550.     public function getLessonIdBeforeThat(Lesson $lessonBase, bool $complete = false)
  1551.     {
  1552.         $lessons = $this->getCourseLessonsIds($lessonBase->getCourse());
  1554.         foreach ($lessons as $key => $lesson) {
  1555.             $lesson = (object)$lesson;
  1556.             if($lesson->id == $lessonBase->getId()){
  1557.                 if($key == 0){
  1558.                     return;
  1559.                 }else{
  1560.                     $obj = (object)$lessons[$key-1];
  1562.                     if($complete){
  1563.                         return $obj;
  1564.                     }
  1565.                     
  1566.                     return $obj->id;
  1567.                 }
  1568.             }
  1569.         }
  1570.         return;
  1571.     }
  1573.     public function getLessonIdAfterThat(Lesson $lessonBase, bool $complete = false)
  1574.     {
  1575.         $lessons = $this->getCourseLessonsIds($lessonBase->getCourse());
  1576.         $maxPosition = count($lessons) - 1;
  1578.         foreach ($lessons as $key => $lesson) {
  1579.             $lesson = (object)$lesson;
  1580.             if($lesson->id == $lessonBase->getId()){
  1581.                 if($key == $maxPosition){
  1582.                     return;
  1583.                 }else{
  1584.                     $obj = (object)$lessons[$key+1];
  1586.                     if($complete){
  1587.                         return $obj;
  1588.                     }
  1590.                     return $obj->id;
  1591.                 }
  1592.             }
  1593.         }
  1594.         return;
  1595.     }
  1597.     public function refreshOrder(
  1598.         $courseId, 
  1599.         $lessonModuleId, 
  1600.         $oldOrder, 
  1601.         $newOrder, 
  1602.         $isDelete = false
  1603.     )
  1604.     {
  1605.         $sql = "UPDATE EADPlataforma:Lesson AS l 
  1606.                 SET l.order = l.order - 1 
  1607.                 WHERE l.order > :oldOrder
  1608.                 AND l.deleted = 0
  1609.                 AND l.course = :courseId
  1610.                 AND l.lessonModule = :lessonModuleId ";
  1611.         
  1612.         $query = $this->em->createQuery($sql);
  1614.         $query->setParameter('oldOrder', $oldOrder);
  1615.         $query->setParameter('courseId', $courseId);
  1616.         $query->setParameter('lessonModuleId', $lessonModuleId);
  1617.         
  1618.         $query->execute();
  1620.         if(!$isDelete){
  1621.             $sql = "UPDATE EADPlataforma:Lesson AS l 
  1622.                     SET l.order = l.order + 1 
  1623.                     WHERE l.order >= :newOrder
  1624.                     AND l.deleted = 0
  1625.                     AND l.course = :courseId
  1626.                     AND l.lessonModule = :lessonModuleId ";
  1627.             $query = $this->em->createQuery($sql);
  1628.             
  1629.             $query->setParameter('newOrder', $newOrder);
  1630.             $query->setParameter('courseId', $courseId);
  1631.             $query->setParameter('lessonModuleId', $lessonModuleId);
  1633.             $query->execute();
  1634.         }
  1635.     }
  1637.     public function copyLesson(
  1638.         LessonModule $newModule, 
  1639.         Lesson $lesson, 
  1640.         $isPartial = false,
  1641.         $isModulePartial = false, 
  1642.         $copyType = null
  1643.     )
  1644.     {
  1645.         $course = $newModule->getCourse();
  1646.         $courseId = $course->getId();
  1647.     
  1648.         $newLesson = clone $lesson;
  1649.         $newLesson->setLessonModule($newModule);
  1650.         $newLesson->setCourse($course);
  1652.         if($copyType == LessonEnum::COPY_PUBLISHED){
  1653.             $newLesson->setStatus(LessonEnum::PUBLISHED);
  1654.         }else if($copyType == LessonEnum::COPY_DRAFT){
  1655.             $newLesson->setStatus(LessonEnum::DRAFT);
  1656.         }
  1657.         
  1658.         if($isPartial){
  1659.             $lastOrder = $this->count([ 
  1660.                 "course" => $courseId,
  1661.                 "lessonModule" => $newModule->getId(),
  1662.                 "deleted" => LessonEnum::ITEM_NO_DELETED 
  1663.             ]);
  1664.             $newLesson->setOrder($lastOrder + 1);
  1665.         }
  1667.         $this->em->persist($newLesson);
  1668.         $this->em->flush();
  1670.         if($isPartial || $isModulePartial){
  1671.             $userLessonId = $newLesson->getUser()->getId();
  1672.             $courseTeam = $this->em->getRepository(CourseTeam::class)->findOneBy([
  1673.                 "course" => $courseId, 
  1674.                 "user" => $userLessonId,
  1675.                 "deleted" => LessonEnum::ITEM_NO_DELETED
  1676.             ]);
  1677.             
  1678.             if(!$courseTeam){
  1679.                 $newCourseTeam = new CourseTeam();
  1680.                 $newCourseTeam->setCourse($course);
  1681.                 $newCourseTeam->setUser($newLesson->getUser());
  1683.                 $this->em->persist($newCourseTeam);
  1684.                 $this->em->flush();
  1685.             }
  1686.         }
  1687.         
  1688.         $files = $this->em->getRepository(LessonXLibrary::class)->findBy([
  1689.             "lesson"=> $lesson->getId(),
  1690.             "deleted"=> LessonXLibraryEnum::ITEM_NO_DELETED
  1691.         ]);
  1692.         
  1693.         if($files){
  1694.             foreach ($files as $key => $file) {
  1695.                 $newFile = clone $file;
  1696.                 $newFile->setLesson($newLesson);
  1697.                 
  1698.                 $this->em->persist($newFile);
  1699.                 $this->em->flush();
  1700.             }
  1701.         }
  1702.         
  1703.         $this->em->getRepository(Exam::class)->copyExamByLesson($lesson, $newLesson);
  1704.         $this->em->getRepository(Exam::class)->copyQuizByLesson($lesson, $newLesson);
  1705.     }
  1707.     public function notifyStudentsLesson(Lesson $lesson, $type)
  1708.     {   
  1709.         if(!$this->configuration->checkModuleIsAbleOnPlan('notificationFunction')){
  1710.             return;
  1711.         }
  1713.         $today = date('Y-m-d');
  1714.         $dateLastNotify = $lesson->getDateLastNotify('Y-m-d');
  1716.         if($today != $dateLastNotify && $lesson->getStatus() == LessonEnum::PUBLISHED){
  1717.             $course = $lesson->getCourse();
  1718.             $lessonModule = $lesson->getLessonModule();
  1720.             if(
  1721.                 $course->getStatus() == CourseEnum::PUBLISHED && 
  1722.                 $lessonModule->getStatus() == LessonModuleEnum::PUBLISHED
  1723.             ){
  1724.                 $taskQueueService = $this->generalService->getService('TaskQueueService');
  1725.                 $enrollmentRepository = $this->em->getRepository(Enrollment::class);
  1726.                 
  1727.                 $enrollments = $enrollmentRepository->getEnrollmentsByCourse(
  1728.                     $course->getId(), 
  1729.                     EnrollmentEnum::STATUS_ACTIVE
  1730.                 );
  1732.                 foreach ($enrollments as $key => $enrollment) {
  1733.                     if($enrollment->getUser()->getAllowNotifyNewLesson() == LessonEnum::YES){
  1734.                         $taskQueueService->insert($type, $enrollment->getUser(), $lesson->getId());
  1735.                     }
  1736.                 }
  1738.                 $lesson->setDateLastNotify(date('Y-m-d H:i:s'));
  1739.                 $this->em->flush();
  1740.             }
  1741.         }
  1742.     }
  1744.     public function lessonUpdateOrder($modules)
  1745.     {
  1746.         $dqlModule = "UPDATE EADPlataforma:LessonModule AS lm SET lm.order = CASE";
  1747.         $idModules = "";
  1749.         $dqlExam = "";
  1750.         $newModuleId = "";
  1751.         $whereExam = "";
  1753.         $caseLesson1 = " l.order = CASE ";
  1754.         $caseLesson2 = " l.lessonModule = CASE ";
  1755.         $caseLesson3 = " e.lessonModule = CASE ";
  1757.         $idsLesson = "";
  1759.         foreach ($modules as $key => $value) {
  1760.             
  1761.             $orderNew = $key + 1;
  1762.             $dqlModule .= " WHEN lm.id = {$value->moduleId} THEN {$orderNew}";
  1764.             if(empty($idModules)){
  1765.                 $idModules .= "{$value->moduleId}";
  1766.             }else{
  1767.                 $idModules .= ", {$value->moduleId}";
  1768.             }
  1770.             foreach ($value->lessons as $key_lesson => $valLesson) {
  1771.                 if(!empty($valLesson->lessonId)){
  1772.                     $ordemNewLesson = $key_lesson + 1;
  1773.                 
  1774.                     $caseLesson1 .= " WHEN l.id = {$valLesson->lessonId} THEN {$ordemNewLesson}";
  1775.                     $caseLesson2 .= " WHEN l.id = {$valLesson->lessonId} THEN {$value->moduleId}";
  1776.                     $caseLesson3 .= " WHEN e.lesson = {$valLesson->lessonId} THEN {$value->moduleId}";
  1777.                 
  1778.                     if(empty($idsLesson)){
  1779.                         $idsLesson .= " {$valLesson->lessonId} ";
  1780.                     }else{
  1781.                         $idsLesson .= ", {$valLesson->lessonId} ";
  1782.                     }
  1783.                 }
  1784.             }
  1785.         }
  1786.         
  1787.         $dqlModule .= " ELSE lm.order END WHERE lm.id IN ({$idModules}) ";
  1789.         $dqlLesson = "UPDATE EADPlataforma:Lesson AS l 
  1790.                       SET {$caseLesson1} ELSE l.order END, 
  1791.                           {$caseLesson2} ELSE IDENTITY(l.lessonModule) END 
  1792.                      WHERE l.id IN ({$idsLesson}) ";
  1794.         $dqlExam = "UPDATE EADPlataforma:Exam AS e
  1795.                     SET {$caseLesson3} ELSE IDENTITY(e.lessonModule) END 
  1796.                     WHERE e.lesson IN ({$idsLesson}) ";
  1798.         $query = $this->em->createQuery($dqlModule);
  1799.         $queryLesson = $this->em->createQuery($dqlLesson);
  1800.         $queryExam = $this->em->createQuery($dqlExam);
  1802.         $query->execute();
  1803.         $queryLesson->execute();
  1804.         $queryExam->execute();
  1805.     }
  1807.     public function getLessonPublicNumber(
  1808.         Course $course, 
  1809.         ?LessonModule $lessonModule = null,
  1810.         ?bool $required = false, 
  1811.         ?bool $filterModule = false
  1812.     )
  1813.     {
  1814.         $query = $this->createQueryBuilder('l');
  1815.         $query->select('COUNT(l.id) AS total');
  1816.         $query->innerJoin(
  1817.             'EADPlataforma:LessonModule', 
  1818.             'lm', 
  1819.             'WITH', 
  1820.             'lm.id = l.lessonModule AND lm.deleted = :deleted'
  1821.         );
  1823.         $query->innerJoin(
  1824.             'EADPlataforma:Course', 
  1825.             'c', 
  1826.             'WITH', 
  1827.             'c.id = l.course AND c.deleted = :deleted'
  1828.         );
  1830.         if($lessonModule){
  1831.             $query->andWhere('lm.order <= :lessonModuleOrder');
  1832.             $query->setParameter('lessonModuleOrder', $lessonModule->getOrder());
  1834.             if($filterModule){
  1835.                 $query->andWhere('lm.id = :lessonModule');
  1836.                 $query->setParameter('lessonModule', $lessonModule->getId());
  1837.             }
  1838.         }
  1840.         if($required){
  1841.             $query->andWhere('l.controlRequirement = :required');
  1842.             $query->setParameter('required', LessonEnum::YES);
  1843.         }
  1845.         $query->andWhere('l.deleted = :deleted');
  1846.         $query->andWhere('l.course = :courseId');
  1847.         $query->andWhere('l.status = :lessonStatus');
  1848.         $query->andWhere('lm.status = :lessonModuleStatus');
  1849.         
  1850.         $query->setParameter('courseId', $course->getId());
  1851.         $query->setParameter('deleted', LessonEnum::ITEM_NO_DELETED);
  1852.         $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  1853.         $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  1854.         $query->setMaxResults(1);
  1856.         $result = (object)$query->getQuery()->getOneOrNullResult();
  1857.         return $result->total;
  1858.     }
  1860.     public function countCourseLessons(
  1861.         Course $course,
  1862.         int $userId,
  1863.         ?LessonModule $lessonModule = null, 
  1864.         $isHistory = false
  1865.     )
  1866.     {
  1867.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  1869.         $permission = $userPermissionUtil->getPermission("course", "see");
  1870.         $user = $userPermissionUtil->getUser();
  1871.         $isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
  1872.             $course, 
  1873.             $user
  1874.         );
  1876.         $sqlDateConclusion = "
  1877.             SELECT
  1878.                 (
  1879.                     CASE 
  1880.                         WHEN ll.complete = :yes THEN ll.date_conclusion 
  1881.                         ELSE CURDATE() 
  1882.                     END
  1883.                 ) AS date_conclusion
  1884.             FROM lesson_log AS ll
  1885.             WHERE ll.lesson_id = l.id
  1886.             AND ll.course_id = l.course_id
  1887.             AND ll.user_id = :userId
  1888.             ORDER BY ll.id DESC
  1889.             LIMIT 1
  1890.         ";
  1892.         $sqlDateRegisterEnrollement = "
  1893.             SELECT
  1894.                 e.date_register
  1895.             FROM enrollment AS e
  1896.             WHERE e.deleted = :deletedEnrollment
  1897.             AND e.course_id = l.course_id
  1898.             AND e.user_id = :userId
  1899.             ORDER BY e.id DESC
  1900.             LIMIT 1
  1901.         ";
  1903.         $sql = "
  1904.             SELECT
  1905.                 COUNT(l.id) AS total
  1906.             FROM lesson AS l
  1907.             INNER JOIN course AS c ON (c.id = l.course_id AND c.deleted = :deletedCourse)
  1908.             INNER JOIN lesson_module AS lm ON (
  1909.                 lm.id = l.lesson_module_id AND lm.deleted = :deletedModule
  1910.             )
  1911.             LEFT JOIN library AS lb ON (lb.id = l.library_id AND lb.deleted = :deletedLibrary)
  1912.             WHERE l.deleted = :deleted
  1913.             AND l.course_id = :courseId
  1914.             /* AND  CASO FOSSE CONSIDERADA DATA DE LIBERAÇÃO DA AULA PARA ENCERRAR O ACESSO
  1915.             (
  1916.                 (
  1917.                     l.control_close_period = 0 OR 
  1918.                     l.control_close_period IS NULL
  1919.                 )
  1920.                 OR
  1921.                 (
  1922.                     l.control_close_period > 0
  1923.                     AND l.control_release_type = 0
  1924.                     AND DATEDIFF(CURDATE(), (DATE(
  1925.                         (
  1926.                             CASE 
  1927.                                 WHEN ({$sqlDateConclusion}) IS NOT NULL THEN ({$sqlDateConclusion})
  1928.                                 ELSE CURDATE()
  1929.                             END
  1930.                         )
  1931.                     ) + INTERVAL l.control_close_period DAY)) < 0
  1932.                 )
  1933.                 OR
  1934.                 (
  1935.                     l.control_close_period > 0
  1936.                     AND l.control_release_type = 1
  1937.                     AND DATEDIFF(CURDATE(), (DATE(
  1938.                         (l.control_date_release)
  1939.                     ) + INTERVAL l.control_close_period DAY)) < 0
  1940.                 )
  1941.                 OR
  1942.                 (
  1943.                     l.control_close_period > 0
  1944.                     AND l.control_release_type = 2
  1945.                     AND l.control_release_after_type = 1
  1946.                     AND DATEDIFF(CURDATE(), (DATE(
  1947.                         ({$sqlDateRegisterEnrollement})
  1948.                     ) + INTERVAL l.control_close_period DAY)) < 0
  1949.                 )
  1950.                 OR
  1951.                 (
  1952.                     l.control_close_period > 0
  1953.                     AND l.control_release_type = 2
  1954.                     AND l.control_release_after_type = 2
  1955.                 )
  1956.             )*/
  1957.         ";
  1960.         if($lessonModule){
  1961.             $sql .= " AND l.lesson_module_id = :lessonModuleId ";
  1962.         }
  1964.         if(
  1965.             $isHistory ||
  1966.             $userPermissionUtil->isLow($permission) || 
  1967.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  1968.         ){
  1969.             $sql .= " AND l.status = :lessonStatus ";
  1970.             $sql .= " AND lm.status = :lessonModuleStatus ";
  1971.         }
  1973.         $stmt = $this->em->getConnection()->prepare($sql);
  1975.         //$stmt->bindValue(':deletedEnrollment', EnrollmentEnum::ITEM_NO_DELETED, PDO::PARAM_INT);
  1976.         $stmt->bindValue(':deletedCourse', CourseEnum::ITEM_NO_DELETED, PDO::PARAM_INT);
  1977.         $stmt->bindValue(':deletedModule', LessonModuleEnum::ITEM_NO_DELETED, PDO::PARAM_INT);
  1978.         $stmt->bindValue(':deletedLibrary', LibraryEnum::ITEM_NO_DELETED, PDO::PARAM_INT);
  1979.         $stmt->bindValue(':deleted', LessonEnum::ITEM_NO_DELETED, PDO::PARAM_INT);
  1980.         $stmt->bindValue(':courseId', $course->getId(), PDO::PARAM_INT);
  1981.         //$stmt->bindValue(':yes', LessonEnum::YES, PDO::PARAM_INT);
  1982.         //$stmt->bindValue(':userId', $userId, PDO::PARAM_INT);
  1984.         if($lessonModule){
  1985.             $stmt->bindValue(':lessonModuleId', $lessonModule->getId(), PDO::PARAM_INT);
  1986.         }
  1988.         if(
  1989.             $isHistory ||
  1990.             $userPermissionUtil->isLow($permission) ||
  1991.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  1992.         ){
  1993.             $stmt->bindValue(':lessonStatus', LessonEnum::PUBLISHED, PDO::PARAM_INT);
  1994.             $stmt->bindValue(':lessonModuleStatus', LessonModuleEnum::PUBLISHED, PDO::PARAM_INT);
  1995.         }
  1996.         
  1997.         $stmt->execute();
  1999.         $result = $stmt->fetchAll(PDO::FETCH_CLASS);
  2001.         return $result[0]->total;
  2002.     }
  2004.     public function getCourseLessons(
  2005.         Course $course, 
  2006.         ?LessonModule $lessonModule = null, 
  2007.         ?array $lessonIds = null, 
  2008.         ?string $searchText = null
  2009.     )
  2010.     {
  2011.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2013.         $permission = $userPermissionUtil->getPermission("course", "see");
  2014.         $user = $userPermissionUtil->getUser();
  2015.         $isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
  2016.             $course, 
  2017.             $user
  2018.         );
  2019.         
  2020.         $query = $this->createQueryBuilder('l');
  2021.         $query->innerJoin(
  2022.             'EADPlataforma:LessonModule', 
  2023.             'lm', 
  2024.             'WITH', 
  2025.             'lm.id = l.lessonModule AND lm.deleted = 0'
  2026.         );
  2028.         $query->innerJoin(
  2029.             'EADPlataforma:Course', 
  2030.             'c', 
  2031.             'WITH', 
  2032.             'c.id = l.course AND c.deleted = 0'
  2033.         );
  2035.         $query->leftJoin(
  2036.             'EADPlataforma:Library', 
  2037.             'lb', 
  2038.             'WITH', 
  2039.             'lb.id = l.library AND lb.deleted = 0'
  2040.         );
  2042.         $query->andWhere('l.deleted = 0');
  2043.         $query->andWhere('l.course = :courseId');
  2044.         $query->setParameter('courseId', $course->getId());
  2046.         if(!empty($searchText)){
  2047.             $query->andWhere('(l.title LIKE :searchText OR lm.title LIKE :searchText)');
  2048.             $query->setParameter('searchText', "%{$searchText}%");
  2049.         }
  2051.         if($lessonModule){
  2052.             $query->andWhere('l.lessonModule = :lessonModuleId');
  2053.             $query->setParameter('lessonModuleId', $lessonModule->getId());
  2054.         }
  2056.         if(is_array($lessonIds) && !empty($lessonIds)){
  2057.             $query->andWhere($query->expr()->in('l.id', $lessonIds));
  2058.         }
  2060.         if(
  2061.             $userPermissionUtil->isLow($permission) || 
  2062.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  2063.         ){
  2064.             $query->andWhere('l.status = :lessonStatus');
  2065.             $query->andWhere('lm.status = :lessonModuleStatus');
  2066.             $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  2067.             $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  2068.         }
  2070.         $query->addOrderBy('l.order', 'ASC');
  2071.         $query->addOrderBy('l.lessonModule', 'ASC');
  2073.         $data = $query->getQuery()->execute();
  2075.         return $data;
  2076.     }
  2078.     public function getFirstLesson(Course $course, ?LessonModule $lessonModule = null)
  2079.     {
  2080.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2082.         $permission = $userPermissionUtil->getPermission("course", "see");
  2083.         $user = $userPermissionUtil->getUser();
  2085.         $courseTeamRepository = $this->em->getRepository(CourseTeam::class);
  2086.         $isInTeam = $courseTeamRepository->userExistInCourseTeam($course, $user);
  2087.         
  2088.         $query = $this->createQueryBuilder('l');
  2089.         $query->innerJoin(
  2090.             'EADPlataforma:LessonModule', 
  2091.             'lm', 
  2092.             'WITH', 
  2093.             'lm.id = l.lessonModule AND lm.deleted = 0'
  2094.         );
  2096.         $query->innerJoin(
  2097.             'EADPlataforma:Course', 
  2098.             'c', 
  2099.             'WITH', 
  2100.             'c.id = l.course AND c.deleted = 0'
  2101.         );
  2103.         $query->andWhere('l.deleted = 0');
  2104.         $query->andWhere('l.course = :courseId');
  2105.         $query->setParameter('courseId', $course->getId());
  2107.         if($lessonModule){
  2108.             $query->andWhere('l.lessonModule = :lessonModuleId');
  2109.             $query->setParameter('lessonModuleId', $lessonModule->getId());
  2110.         }
  2112.         if(
  2113.             $userPermissionUtil->isLow($permission) || 
  2114.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  2115.         ){
  2116.             $query->andWhere('l.status = :lessonStatus');
  2117.             $query->andWhere('lm.status = :lessonModuleStatus');
  2118.             $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  2119.             $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  2120.         }
  2122.         $query->addOrderBy('lm.order', 'ASC');
  2123.         $query->addOrderBy('l.order', 'ASC');
  2125.         $query->setMaxResults(1);
  2127.         return $query->getQuery()->getOneOrNullResult();
  2128.     }
  2130.     public function getLastLesson(Course $course, ?LessonModule $lessonModule = null)
  2131.     {
  2132.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2134.         $permission = $userPermissionUtil->getPermission("course", "see");
  2135.         $user = $userPermissionUtil->getUser();
  2136.         $isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
  2137.             $course, 
  2138.             $user
  2139.         );
  2140.         
  2141.         $query = $this->createQueryBuilder('l');
  2142.         $query->innerJoin(
  2143.             'EADPlataforma:LessonModule', 
  2144.             'lm', 
  2145.             'WITH', 
  2146.             'lm.id = l.lessonModule AND lm.deleted = 0'
  2147.         );
  2149.         $query->innerJoin(
  2150.             'EADPlataforma:Course', 
  2151.             'c', 
  2152.             'WITH', 
  2153.             'c.id = l.course AND c.deleted = 0'
  2154.         );
  2156.         $query->andWhere('l.deleted = 0');
  2157.         $query->andWhere('l.course = :courseId');
  2158.         $query->setParameter('courseId', $course->getId());
  2160.         if($lessonModule){
  2161.             $query->andWhere('l.lessonModule = :lessonModuleId');
  2162.             $query->setParameter('lessonModuleId', $lessonModule->getId());
  2163.         }
  2165.         if(
  2166.             $userPermissionUtil->isLow($permission) || 
  2167.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  2168.         ){
  2169.             $query->andWhere('l.status = :lessonStatus');
  2170.             $query->andWhere('lm.status = :lessonModuleStatus');
  2171.             $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  2172.             $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  2173.         }
  2175.         $query->addOrderBy('lm.order', 'DESC');
  2176.         $query->addOrderBy('l.order', 'DESC');
  2178.         $query->setMaxResults(1);
  2180.         return $query->getQuery()->getOneOrNullResult();
  2181.     }
  2183.     public function getLessonByLessonModule(LessonModule $lessonModule)
  2184.     {   
  2186.         $query = $this->createQueryBuilder('l');
  2187.         $query->leftJoin(
  2188.             'EADPlataforma:Library', 
  2189.             'li', 
  2190.             'WITH', 
  2191.             'li.id = l.library AND li.deleted = 0'
  2192.         );
  2194.         $query->andWhere('l.deleted = 0');
  2195.         $query->andWhere('l.status = :status');
  2196.         $query->andWhere('l.course = :courseId');
  2197.         $query->andWhere('l.lessonModule = :lessonModule');
  2198.         $query->setParameter('courseId', $lessonModule->getCourse()->getId());
  2199.         $query->setParameter('lessonModule', $lessonModule->getId());
  2200.         $query->setParameter('status', LessonEnum::PUBLISHED);
  2202.         $query->addOrderBy('l.order', 'ASC');
  2204.         return $query->getQuery()->execute();
  2205.     }
  2207.     public function getNextLessonByLessonModule(
  2208.         int $order, 
  2209.         LessonModule $lessonModule, 
  2210.         int $limit = 3
  2211.     )
  2212.     {   
  2214.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2215.         $permission = $userPermissionUtil->getPermission("course", "see");
  2217.         $course = $lessonModule->getCourse();
  2218.         $user = $userPermissionUtil->getUser();
  2221.         $isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
  2222.             $course, 
  2223.             $user
  2224.         );
  2226.         $query = $this->createQueryBuilder('l');
  2228.         $query->select('
  2229.             l.id,
  2230.             l.order,
  2231.             l.title,
  2232.             l.status,
  2233.             l.controlRequirement,
  2234.             l.controlReleaseType,
  2235.             l.controlReleaseAfterType,
  2236.             l.controlDateRelease,
  2237.             l.controlReleasePeriod,
  2238.             l.controlClosePeriod,
  2239.             lm.id AS lessonModule,
  2240.             li.type AS libraryType,
  2241.             li.pagesNumber,
  2242.             li.duration
  2243.         ');
  2245.         $query->innerJoin(
  2246.             'EADPlataforma:LessonModule', 
  2247.             'lm', 
  2248.             'WITH', 
  2249.             'lm.id = l.lessonModule AND lm.deleted = 0'
  2250.         );
  2252.         $query->innerJoin(
  2253.             'EADPlataforma:Course', 
  2254.             'c', 
  2255.             'WITH', 
  2256.             'c.id = l.course AND c.deleted = 0'
  2257.         );
  2259.         $query->leftJoin(
  2260.             'EADPlataforma:Library', 
  2261.             'li', 
  2262.             'WITH', 
  2263.             'li.id = l.library AND li.deleted = 0'
  2264.         );
  2266.         if(
  2267.             $userPermissionUtil->isLow($permission) || 
  2268.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  2269.         ){
  2270.             $query->andWhere('l.status = :lessonStatus');
  2271.             $query->andWhere('lm.status = :lessonModuleStatus');
  2272.             $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  2273.             $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  2274.         }
  2276.         $query->andWhere('l.deleted = 0');
  2277.         $query->andWhere('l.course = :courseId');
  2278.         $query->andWhere('l.lessonModule = :lessonModule');
  2279.         $query->andWhere('l.order > :order');
  2281.         $query->setParameter('courseId', $course->getId());
  2282.         $query->setParameter('lessonModule', $lessonModule->getId());
  2283.         $query->setParameter('order', $order);
  2285.         $query->addOrderBy('l.order', 'ASC');
  2287.         $query->setMaxResults($limit);
  2289.         return $query->getQuery()->execute();
  2290.     }
  2292.     public function getLessonNotView($userId, $courseId, $lessonId = null)
  2293.     {
  2294.         $and = '';
  2296.         if(!empty($lessonId))
  2297.         {
  2298.             $and .= " AND l.id = :lessonId";
  2299.         }
  2301.         if(empty($courseId) || empty($userId))
  2302.         {
  2303.             return [];
  2304.         }
  2306.         $dql = "SELECT
  2307.                     l.id,
  2308.                     l.title,
  2309.                     lm.title AS titleModule,
  2310.                     '0' AS totalView,
  2311.                     '' AS lastAccess,
  2312.                     '--' AS timeWatch,
  2313.                     '0' AS completed,
  2314.                     '---' AS dateConclusion
  2315.                 FROM EADPlataforma:Lesson AS l
  2316.                 INNER JOIN EADPlataforma:LessonModule AS lm WITH (lm.id = l.lessonModule AND lm.deleted = 0)
  2317.                 WHERE l.deleted = 0
  2318.                 AND l.course = :courseId
  2319.                 {$and}
  2320.                 AND l.id NOT IN (
  2321.                     SELECT
  2322.                         IDENTITY (ll.lesson)
  2323.                     FROM EADPlataforma:LessonLogOrigin AS ll
  2324.                     WHERE ll.user != 1
  2325.                     AND ll.user = :userId
  2326.                     AND ll.course = :courseId
  2327.                 )
  2328.                 ORDER BY l.order ASC";
  2329.                 
  2330.         $query = $this->em->createQuery($dql);
  2331.         $query->setParameter('userId', $userId);
  2332.         $query->setParameter('courseId', $courseId);
  2333.       
  2334.         if(!empty($lessonId))
  2335.         {
  2336.             $query->setParameter('lessonId', $lessonId);
  2337.         }
  2339.         $data = $query->execute();
  2340.         
  2341.         $result = [];
  2342.         foreach ($data as $key => $value) {
  2343.             $result[] = [
  2344.                 $value["id"],
  2345.                 $value["title"],
  2346.                 $value["titleModule"],
  2347.                 $value["totalView"],
  2348.                 $value["lastAccess"],
  2349.                 $value["timeWatch"],
  2350.                 $value["completed"],
  2351.                 $value["dateConclusion"]
  2352.             ];
  2353.         }
  2355.         return $result;
  2356.     }
  2358.     public function isFirstCourseLesson(?Lesson $lesson)
  2359.     {
  2360.         if(!$lesson){
  2361.             return false;
  2362.         }
  2364.         $firstLesson = $this->getFirstLesson($lesson->getCourse());
  2365.         if($firstLesson){
  2366.             return $firstLesson->getId() == $lesson->getId();
  2367.         }
  2368.         return true;
  2369.     }
  2371.     public function isFirstModuleLesson(?Lesson $lesson)
  2372.     {
  2373.         if(!$lesson){
  2374.             return false;
  2375.         }
  2377.         $firstLesson = $this->getFirstLesson($lesson->getCourse(), $lesson->getLessonModule());
  2378.         if($firstLesson){
  2379.             return $firstLesson->getId() == $lesson->getId();
  2380.         }
  2381.         return true;
  2382.     }
  2384.     public function isLastCourseLesson(?Lesson $lesson)
  2385.     {
  2386.         if(!$lesson){
  2387.             return false;
  2388.         }
  2390.         $firstLesson = $this->getLastLesson($lesson->getCourse());
  2391.         if($firstLesson){
  2392.             return $firstLesson->getId() == $lesson->getId();
  2393.         }
  2394.         return true;
  2395.     }
  2397.     public function isLastModuleLesson(?Lesson $lesson)
  2398.     {
  2399.         if(!$lesson){
  2400.             return false;
  2401.         }
  2403.         $firstLesson = $this->getLastLesson(
  2404.             $lesson->getCourse(), 
  2405.             $lesson->getLessonModule()
  2406.         );
  2408.         if($firstLesson){
  2409.             return $firstLesson->getId() == $lesson->getId();
  2410.         }
  2411.         return true;
  2412.     }
  2414.     public function isLessonVisibleToStudent(
  2415.         Lesson $lesson, 
  2416.         ?bool $ignoreControlFunction = false,
  2417.         ?bool $isStudent = true
  2418.     ): bool
  2419.     {
  2420.         $info = $this->checkLessonVisibleToStudent($lesson, $ignoreControlFunction, $isStudent);
  2422.         return $info->visible;
  2423.     }
  2425.     public function checkLessonVisibleToStudent(
  2426.         Lesson $lesson, 
  2427.         ?bool $ignoreControlFunction = false,
  2428.         ?bool $isStudent = true
  2429.     ): object
  2430.     {
  2432.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2433.         $user = $userPermissionUtil->getUser();
  2435.         $info = (object)[
  2436.             "visible" => true,
  2437.             "message" => "",
  2438.         ];
  2440.         if(!$user){
  2442.             $info->visible = false;
  2444.             return $info;
  2445.         }
  2447.         $course = $lesson->getCourse();
  2448.         $lessonModule = $lesson->getLessonModule();
  2450.         if($lesson->isDeleted() || $lessonModule->isDeleted() || $course->isDeleted()){
  2451.             $info->visible = false;
  2453.             return $info;
  2454.         }
  2456.         if(!$isStudent){
  2458.             $info->visible = true;
  2460.             return $info;
  2461.         }
  2463.         $enrollmentRepository = $this->em->getRepository(Enrollment::class);
  2464.         $isEnroll = $enrollmentRepository->isValidEnrollmentByUser(
  2465.             $user->getId(), 
  2466.             $course->getId()
  2467.         );
  2469.         $hasLessonControl = $this->configuration->checkModuleIsAbleOnPlan(
  2470.             'lessonControlFunction'
  2471.         );
  2473.             
  2474.         if($lesson->getStatus() == LessonEnum::DRAFT){
  2475.             $info->visible = false;
  2477.             return $info;
  2478.         }
  2480.         if($lessonModule->getStatus() == LessonModuleEnum::DRAFT){
  2481.             $info->visible = false;
  2483.             return $info;
  2484.         }
  2486.         if($course->getStatus() == CourseEnum::DRAFT){
  2487.             $info->visible = false;
  2489.             return $info;
  2490.         }
  2492.         if(!$isEnroll){
  2493.             $info->visible = false;
  2495.             return $info;
  2496.         }
  2497.         
  2498.         if(!$ignoreControlFunction){
  2499.             if($lesson->getControlReleaseType() == LessonEnum::FIXED_DATE){
  2500.                 $todaySeconds = strtotime(date('Y-m-d H:i:s'));
  2501.                 if($hasLessonControl){
  2502.                     $controlClosePeriod = $lesson->getControlClosePeriod();
  2503.                     if(!empty($controlClosePeriod)){
  2504.                         $timeLog = strtotime(
  2505.                             "{$lesson->getControlDateRelease()} + {$controlClosePeriod} day"
  2506.                         );
  2508.                         if($todaySeconds > $timeLog){
  2509.                             $info->visible = false;
  2511.                             return $info;
  2512.                         }
  2513.                     }
  2514.                 }
  2515.             }else{
  2516.                 $lessonLogRepository = $this->emEadmin->getRepository(LessonLog::class);
  2517.                 $logId = "{$course->getId()}#{$user->getId()}#{$lesson->getId()}";
  2518.                 $lessonLog = $lessonLogRepository->find($logId);
  2520.                 //check lesson to user is closed
  2521.                 if($lessonLog){
  2522.                     $todaySeconds = strtotime(date('Y-m-d H:i:s'));
  2523.                     if($hasLessonControl){
  2524.                         $controlClosePeriod = $lesson->getControlClosePeriod();
  2525.                         if(
  2526.                             !empty($controlClosePeriod) && 
  2527.                             $lessonLog->getComplete() == LessonEnum::YES
  2528.                         ){
  2529.                             $timeLog = strtotime(
  2530.                                 "{$lessonLog->getDateConclusion()} + {$controlClosePeriod} day"
  2531.                             );
  2533.                             if($todaySeconds > $timeLog){
  2534.                                 $info->visible = false;
  2536.                                 return $info;
  2537.                             }
  2538.                         }
  2539.                     }
  2540.                 }
  2541.             } 
  2542.         }
  2544.         return $info;
  2545.     }
  2547.     public function getLessonNumberByProduct(Product $product)
  2548.     {
  2549.         $query = $this->createQueryBuilder('l');
  2550.         $query->select("COUNT(l.id) AS total");
  2551.         $query->innerJoin('EADPlataforma:Course', 'c', 'WITH', 'l.course = c.id');
  2552.         $query->innerJoin('EADPlataforma:Product', 'p', 'WITH', 'l.course MEMBER OF p.course');
  2553.         $query->innerJoin('EADPlataforma:LessonModule', 'lm', 'WITH', 'l.lessonModule = lm.id');
  2555.         $query->andWhere('l.deleted = :deletedLesson');
  2556.         $query->andWhere('c.deleted = :deletedCourse');
  2557.         $query->andWhere('lm.deleted = :deletedLessonModule');
  2559.         $query->andWhere('l.status = :statusLesson');
  2560.         $query->andWhere('c.status = :statusCourse');
  2561.         $query->andWhere('lm.status = :statusLessonModule');
  2563.         $query->andWhere('p.id = :productId');
  2565.         $query->setParameter('deletedLesson', LessonEnum::ITEM_NO_DELETED);
  2566.         $query->setParameter('deletedCourse', CourseEnum::ITEM_NO_DELETED);
  2567.         $query->setParameter('deletedLessonModule', LessonModuleEnum::ITEM_NO_DELETED);
  2569.         $query->setParameter('statusLesson', LessonEnum::PUBLISHED);
  2570.         $query->setParameter('statusCourse', CourseEnum::PUBLISHED);
  2571.         $query->setParameter('statusLessonModule', LessonModuleEnum::PUBLISHED);
  2573.         $query->setParameter('productId', $product->getId());
  2575.         $result = (object)$query->getQuery()->getOneOrNullResult();
  2576.         return $result->total;
  2577.     }
  2579.     public function getLessonForExportPresence(Course $course, $lessonModuleId = null){
  2580.         $query = $this->createQueryBuilder('l');
  2582.         $query->select('
  2583.             l.id,
  2584.             lm.id AS lessonModuleId,
  2585.             l.order,
  2586.             lm.title,
  2587.             l.title AS lessonTitle
  2588.         ');
  2590.         $query->innerJoin(
  2591.             'EADPlataforma:LessonModule', 
  2592.             'lm', 
  2593.             'WITH', 
  2594.             'lm.id = l.lessonModule AND lm.deleted = 0'
  2595.         );
  2597.         if($lessonModuleId){
  2598.             $query->andWhere('lm.id = :lessonModuleId');
  2599.             $query->setParameter('lessonModuleId', $lessonModuleId);
  2600.         }
  2601.         
  2602.         $query->andWhere('l.status = :lessonStatus');
  2603.         $query->andWhere('lm.status = :lessonModuleStatus');
  2604.         $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  2605.         $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  2606.         
  2607.         $query->andWhere('l.deleted = 0');
  2608.         $query->andWhere('l.course = :courseId');
  2610.         $query->setParameter('courseId', $course->getId());
  2612.         $query->addOrderBy('lm.order', 'ASC');
  2613.         $query->addOrderBy('lm.id', 'ASC');
  2614.         $query->addOrderBy('l.order', 'ASC');
  2615.         $query->addOrderBy('l.id', 'ASC');
  2617.         return $query->getQuery()->execute();
  2618.     }
  2620.     public function restore(Lesson $lesson, $typeItem, $key)
  2621.     {
  2622.         $lessonId = $lesson->getId();
  2623.         $dateNow = date('Y-m-d H:i:s');
  2625.         $lastOrder = $this->count(
  2626.             [ 
  2627.                 "deleted" => LessonEnum::ITEM_NO_DELETED, 
  2628.                 "lessonModule" => $lesson->getLessonModule()->getId() 
  2629.             ]
  2630.         ) + ($key + 1);
  2632.         $lesson->setOrder($lastOrder);
  2634.         $courseRepository =  $this->em->getRepository(Course::class);
  2636.         $lesson->setUserDelete($this->getUser());
  2637.         $lesson->setDateDelete($dateNow);
  2638.         $lesson->restore();
  2639.         $deleted = LessonEnum::ITEM_NO_DELETED;
  2640.         $typeDelete = LessonEnum::CASCADE;
  2642.         $this->em->getRepository(Exam::class)->restoreByLesson(
  2643.             $lessonId, 
  2644.             $deleted, 
  2645.             $typeDelete, 
  2646.             $this->getUser(), 
  2647.             $dateNow
  2648.         );
  2650.         $this->em->getRepository(ExamUser::class)->restoreByLesson(
  2651.             $lessonId, 
  2652.             $deleted, 
  2653.             $typeDelete, 
  2654.             $this->getUser(), 
  2655.             $dateNow
  2656.         );
  2658.         $this->em->getRepository(LessonSupport::class)->restoreByLesson(
  2659.             $lessonId, 
  2660.             $deleted, 
  2661.             $typeDelete, 
  2662.             $this->getUser(), 
  2663.             $dateNow
  2664.         );
  2666.         $this->em->getRepository(LessonXLibrary::class)->restoreByLesson(
  2667.             $lessonId, 
  2668.             $deleted, 
  2669.             $typeDelete, 
  2670.             $this->getUser(), 
  2671.             $dateNow
  2672.         );
  2673.         $this->em->getRepository(Trash::class)->deleteTrash($lessonId, $typeItem);
  2674.     }
  2676.     public function delete(Lesson $lesson, $typeItem, $permission, $isTrash)
  2677.     {
  2678.         $lessonId = $lesson->getId();
  2679.         $dateNow = date('Y-m-d H:i:s');
  2680.         $typeDelete = LessonEnum::CASCADE;
  2682.         $notificationService = $this->generalService->getService('NotificationService');
  2683.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2685.         $lessonXLibrarys = $this->em->getRepository(LessonXLibrary::class)->findBy([
  2686.             "lesson" => $lesson->getId(),
  2687.         ]);
  2689.         $libraryRepository = $this->em->getRepository(Library::class);
  2690.         $libraryModule = $this->configuration->checkModuleIsAbleOnPlan('libraryModule');
  2692.         if($isTrash == LessonEnum::YES){
  2693.             $permission = $userPermissionUtil->getPermission("trash", "delete");
  2694.         }
  2696.         $isLessonTeacher = $this->isLessonTeacher($lesson, $this->getUser());
  2697.         if($isLessonTeacher || $userPermissionUtil->isHigh($permission)){
  2698.             $lesson->setUserDelete($this->getUser());
  2699.             $lesson->setDateDelete($dateNow);
  2700.             $lesson->individual();
  2701.             
  2702.             if($lesson->isOnTrash() || $lesson->isDeleted()){
  2703.                 
  2704.                 $lesson->delete();
  2705.                 $deleted = LessonEnum::ITEM_DELETED;
  2706.                 $this->em->getRepository(Trash::class)->deleteTrash($lessonId, $typeItem);
  2708.                 $this->em->flush();
  2710.                 foreach ($lessonXLibrarys as $key => $lessonXLibrary) {
  2711.                     $library = $lessonXLibrary->getLibrary();
  2712.                     if(!$libraryModule && $library){
  2713.                         $library->cascade();
  2714.                         $libraryRepository->deleteContent($library);
  2715.                     }
  2716.                     $lessonXLibrary->delete();
  2717.                 }
  2719.                 $library = $lesson->getLibrary();
  2721.                 if(!$libraryModule && $library){
  2722.                     $library->cascade();
  2723.                     $libraryRepository->deleteContent($library);
  2724.                 }
  2725.             }
  2727.             if(!$lesson->isOnTrash() && !$lesson->isDeleted()){
  2728.                 $order = $lesson->getOrder();
  2729.                 $this->refreshOrder(
  2730.                     $lesson->getCourse()->getId(), 
  2731.                     $lesson->getLessonModule()->getId(),
  2732.                     $order,
  2733.                     null,
  2734.                     true
  2735.                 );
  2737.                 $notificationService->delete(
  2738.                     NotificationEnum::ORIGIN_LESSON_SUPPORT_LIKE, 
  2739.                     $lessonId
  2740.                 );
  2742.                 $notificationService->delete(
  2743.                     NotificationEnum::ORIGIN_LESSON_SUPPORT_ANSWER_LIKE, 
  2744.                     $lessonId
  2745.                 );
  2746.                 $notificationService->delete(
  2747.                     NotificationEnum::ORIGIN_LESSON_SUPPORT_NEW, 
  2748.                     $lessonId
  2749.                 );
  2750.                 $notificationService->delete(
  2751.                     NotificationEnum::ORIGIN_LESSON_SUPPORT_ANSWER_NEW, 
  2752.                     $lessonId
  2753.                 );
  2754.                 $notificationService->delete(
  2755.                     NotificationEnum::ORIGIN_LESSON_NEW, 
  2756.                     $lessonId
  2757.                 );
  2758.                 $notificationService->delete(
  2759.                     NotificationEnum::ORIGIN_LESSON_CHANGE, 
  2760.                     $lessonId
  2761.                 );
  2763.                 $lesson->trash();
  2764.                 $deleted = LessonEnum::ITEM_ON_TRASH;
  2765.                 $this->em->getRepository(Trash::class)->insertTrash(
  2766.                     $lesson, 
  2767.                     $typeItem, 
  2768.                     "Aula: {$lesson->getTitle()} | Prof. {$lesson->getUser()->getName()}"
  2769.                 );
  2770.             }
  2771.         }
  2772.         
  2773.         $this->em->getRepository(Exam::class)->deleteByLesson(
  2774.             $lessonId, 
  2775.             $deleted, 
  2776.             $typeDelete, 
  2777.             $this->getUser(), 
  2778.             $dateNow
  2779.         );
  2781.         $this->em->getRepository(ExamUser::class)->deleteByLesson(
  2782.             $lessonId, 
  2783.             $deleted, 
  2784.             $typeDelete, 
  2785.             $this->getUser(), 
  2786.             $dateNow
  2787.         );
  2789.         $this->em->getRepository(LessonSupport::class)->deleteByLesson(
  2790.             $lessonId, 
  2791.             $deleted, 
  2792.             $typeDelete, 
  2793.             $this->getUser(), 
  2794.             $dateNow
  2795.         );
  2797.         $this->em->getRepository(LessonXLibrary::class)->deleteByLesson(
  2798.             $lessonId, 
  2799.             $deleted, 
  2800.             $typeDelete, 
  2801.             $this->getUser(), 
  2802.             $dateNow
  2803.         );
  2804.     }
  2806.     public function restoreByCourse($courseId, $deleted, $typeDelete){
  2808.         $typeItem = TrashEnum::LESSON;
  2810.         $lessons = $this->em->getRepository(Lesson::class)->findBy([
  2811.             "course" => $courseId,
  2812.             "deleted" => (1 - $deleted),
  2813.             "typeDelete" => $typeDelete
  2814.         ]);
  2816.         foreach ($lessons as $key => $lesson) {
  2817.             $this->restore($lesson, $typeItem, $key);
  2818.         }
  2819.     }
  2821.     public function deleteByCourse($courseId, $deleted){
  2823.         $typeItem = TrashEnum::LESSON;
  2824.         $isTrash = LessonEnum::NO;
  2826.         if($deleted == LessonEnum::ITEM_ON_TRASH){
  2827.             $isTrash = LessonEnum::YES;
  2828.         }
  2830.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2831.         $permission = $userPermissionUtil->getPermission(
  2832.             "course", 
  2833.             "lesson", 
  2834.             "delete"
  2835.         );
  2837.         $lessons = $this->em->getRepository(Lesson::class)->findBy([
  2838.             "course" => $courseId,
  2839.             "deleted" => ($deleted - 1)
  2840.         ]);
  2842.         foreach ($lessons as $key => $lesson) {
  2843.             $this->delete($lesson, $typeItem, $permission, $isTrash);
  2844.             $lesson->cascade();
  2845.         }
  2846.     }
  2848.     public function restoreByLessonModule($lessonModuleId, $deleted, $typeDelete){
  2850.         $typeItem = TrashEnum::LESSON;
  2852.         $lessons = $this->em->getRepository(Lesson::class)->findBy([
  2853.             "lessonModule" => $lessonModuleId,
  2854.             "deleted" => (1 - $deleted),
  2855.             "typeDelete" => $typeDelete
  2856.         ]);
  2858.         foreach ($lessons as $key => $lesson) {
  2859.             $this->restore($lesson, $typeItem, $key);
  2860.         }
  2861.     }
  2863.     public function deleteByLessonModule($lessonModuleId, $deleted){
  2865.         $typeItem = TrashEnum::LESSON;
  2866.         $isTrash = LessonEnum::NO;
  2868.         if($deleted == LessonEnum::ITEM_ON_TRASH){
  2869.             $isTrash = LessonEnum::YES;
  2870.         }
  2872.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2873.         $permission = $userPermissionUtil->getPermission(
  2874.             "course", 
  2875.             "lesson", 
  2876.             "delete"
  2877.         );
  2879.         $lessons = $this->em->getRepository(Lesson::class)->findBy([
  2880.             "lessonModule" => $lessonModuleId,
  2881.             "deleted" => ($deleted - 1)
  2882.         ]);
  2884.         foreach ($lessons as $key => $lesson) {
  2885.             $this->delete($lesson, $typeItem, $permission, $isTrash);
  2886.             $lesson->cascade();
  2887.         }
  2888.     }
  2890.     public function deleteTrashCron()
  2891.     {
  2892.         $sql = "UPDATE EADPlataforma:Lesson AS l SET l.deleted = 2 
  2893.                 WHERE l.dateDelete <= :date AND l.deleted = 1 ";
  2894.         $query = $this->em->createQuery($sql);
  2895.         $query->setParameter('date', date('Y-m-d H:i:s', strtotime('-90 days')));
  2896.         $query->execute();
  2897.     }
  2898. }